from fastapi import APIRouter, Depends, HTTPException
from sqlalchemy.orm import Session
from datetime import datetime, timedelta
from typing import List, Optional
from app.db.session import get_db
from app.db.models import User
from app.api.deps import get_current_user
from pydantic import BaseModel

router = APIRouter(prefix="/ab-testing", tags=["ab-testing"])


class ABTestVariant(BaseModel):
    id: int
    name: str
    content: str
    traffic_percentage: int  # 0-100
    metrics: dict  # {"sent": 100, "opened": 50, "clicked": 10}


class ABTest(BaseModel):
    id: int
    name: str
    status: str  # "draft", "running", "completed", "paused"
    variants: List[ABTestVariant]
    start_date: Optional[datetime]
    end_date: Optional[datetime]
    winner_variant_id: Optional[int]
    created_at: datetime


class ABTestCreate(BaseModel):
    name: str
    template_id: int
    variants: List[dict]  # [{"name": "Version A", "content": "..."}, ...]


class ABTestOut(ABTest):
    tenant_id: int

    class Config:
        from_attributes = True


@router.get("", response_model=List[ABTestOut])
def list_ab_tests(
    current_user: User = Depends(get_current_user),
    db: Session = Depends(get_db),
):
    """List all A/B tests for the tenant"""
    # Mock data for now - in a real implementation, you'd query the database
    return [
        ABTestOut(
            id=1,
            tenant_id=current_user.tenant_id,
            name="Welcome Email Test",
            status="completed",
            variants=[
                ABTestVariant(
                    id=1,
                    name="Version A (Original)",
                    content="Welcome to our service!",
                    traffic_percentage=50,
                    metrics={"sent": 1000, "opened": 650, "clicked": 130}
                ),
                ABTestVariant(
                    id=2,
                    name="Version B (New)",
                    content="Welcome! Get 20% off your first order.",
                    traffic_percentage=50,
                    metrics={"sent": 1000, "opened": 720, "clicked": 180}
                )
            ],
            start_date=datetime.utcnow() - timedelta(days=7),
            end_date=datetime.utcnow() - timedelta(days=1),
            winner_variant_id=2,
            created_at=datetime.utcnow() - timedelta(days=7)
        ),
        ABTestOut(
            id=2,
            tenant_id=current_user.tenant_id,
            name="Order Confirmation Test",
            status="running",
            variants=[
                ABTestVariant(
                    id=3,
                    name="Standard",
                    content="Your order has been confirmed.",
                    traffic_percentage=50,
                    metrics={"sent": 500, "opened": 300, "clicked": 60}
                ),
                ABTestVariant(
                    id=4,
                    name="With Tracking",
                    content="Your order #12345 has been confirmed. Track it here.",
                    traffic_percentage=50,
                    metrics={"sent": 500, "opened": 320, "clicked": 80}
                )
            ],
            start_date=datetime.utcnow() - timedelta(days=3),
            end_date=None,
            winner_variant_id=None,
            created_at=datetime.utcnow() - timedelta(days=3)
        )
    ]


@router.post("", response_model=ABTestOut)
def create_ab_test(
    test_data: ABTestCreate,
    current_user: User = Depends(get_current_user),
    db: Session = Depends(get_db),
):
    """Create a new A/B test"""
    # Mock implementation - in a real implementation, you'd save to database
    return ABTestOut(
        id=3,
        tenant_id=current_user.tenant_id,
        name=test_data.name,
        status="draft",
        variants=[
            ABTestVariant(
                id=5,
                name=variant["name"],
                content=variant["content"],
                traffic_percentage=100 // len(test_data.variants),
                metrics={"sent": 0, "opened": 0, "clicked": 0}
            )
            for variant in test_data.variants
        ],
        start_date=None,
        end_date=None,
        winner_variant_id=None,
        created_at=datetime.utcnow()
    )


@router.get("/{test_id}", response_model=ABTestOut)
def get_ab_test(
    test_id: int,
    current_user: User = Depends(get_current_user),
    db: Session = Depends(get_db),
):
    """Get specific A/B test details"""
    # Mock implementation
    return ABTestOut(
        id=test_id,
        tenant_id=current_user.tenant_id,
        name="Test Email",
        status="running",
        variants=[
            ABTestVariant(
                id=1,
                name="Version A",
                content="Test content A",
                traffic_percentage=50,
                metrics={"sent": 100, "opened": 60, "clicked": 12}
            ),
            ABTestVariant(
                id=2,
                name="Version B",
                content="Test content B",
                traffic_percentage=50,
                metrics={"sent": 100, "opened": 70, "clicked": 18}
            )
        ],
        start_date=datetime.utcnow() - timedelta(days=2),
        end_date=None,
        winner_variant_id=None,
        created_at=datetime.utcnow() - timedelta(days=2)
    )


@router.post("/{test_id}/start")
def start_ab_test(
    test_id: int,
    current_user: User = Depends(get_current_user),
    db: Session = Depends(get_db),
):
    """Start an A/B test"""
    return {"message": f"A/B test {test_id} started successfully", "status": "success"}


@router.post("/{test_id}/stop")
def stop_ab_test(
    test_id: int,
    current_user: User = Depends(get_current_user),
    db: Session = Depends(get_db),
):
    """Stop an A/B test"""
    return {"message": f"A/B test {test_id} stopped successfully", "status": "success"}


@router.post("/{test_id}/declare-winner")
def declare_winner(
    test_id: int,
    variant_id: int,
    current_user: User = Depends(get_current_user),
    db: Session = Depends(get_db),
):
    """Declare a winner for the A/B test"""
    return {
        "message": f"Variant {variant_id} declared as winner for test {test_id}",
        "status": "success"
    }