import uuid
from datetime import datetime

from fastapi import APIRouter, Depends, HTTPException, Query, status
from sqlalchemy import select, func
from sqlalchemy.ext.asyncio import AsyncSession

from app.api.deps import get_current_user
from app.database import get_db
from app.models.user import User
from app.models.brand import Brand
from app.models.geo_plan import GeoPlan, GeoPlanAction
from app.schemas.geo_plan import (
    GeoPlanGenerateRequest,
    GeoPlanResponse,
    GeoPlanListResponse,
    GeoPlanActionResponse,
    GeoPlanActionUpdateStatus,
    GeoPlanActionExecuteResponse,
)
from app.services.scoring.brand_scoring_data_service import get_brand_scoring_data_service
from app.services.strategy.geo_plan_generator import generate_geo_plan
from app.services.content.content_generation_service import ContentGenerationService

router = APIRouter()
def _to_uuid(value: str | uuid.UUID) -> uuid.UUID:
    if isinstance(value, uuid.UUID):
        return value
    return uuid.UUID(str(value))


async def _get_brand_with_access(
    brand_id: uuid.UUID,
    db: AsyncSession,
    current_user: User,
) -> Brand:
    stmt = select(Brand).where(
        Brand.id == brand_id,
        Brand.user_id == _to_uuid(current_user.id),
    )
    result = await db.execute(stmt)
    brand = result.scalar_one_or_none()

    if not brand:
        raise HTTPException(
            status_code=status.HTTP_404_NOT_FOUND,
            detail="品牌不存在",
        )
    return brand


async def _get_brand_scoring_data(
    db: AsyncSession,
    user_id: uuid.UUID,
    brand: Brand,
) -> tuple:
    scoring_data_service = get_brand_scoring_data_service()
    scoring_data = await scoring_data_service.get_brand_scoring_data(db, user_id, brand)
    return (
        scoring_data.v2_result,
        scoring_data.competitor_data,
        scoring_data.sentiment_counts,
        scoring_data.platform_scores,
        scoring_data.total_queries,
        scoring_data.mentioned_count,
    )


def _plan_to_response(plan: GeoPlan) -> GeoPlanResponse:
    actions = [
        GeoPlanActionResponse(
            id=action.id,
            plan_id=action.plan_id,
            action_type=action.action_type,
            title=action.title,
            description=action.description,
            reason=action.reason,
            priority=action.priority,
            status=action.status,
            target_keyword=action.target_keyword,
            target_platform=action.target_platform,
            content_style=action.content_style,
            estimated_impact=action.estimated_impact,
            difficulty=action.difficulty,
            execution_params=action.execution_params,
            sort_order=action.sort_order,
            completed_at=action.completed_at,
            created_at=action.created_at,
        )
        for action in sorted(plan.actions, key=lambda a: a.sort_order)
    ]
    return GeoPlanResponse(
        id=plan.id,
        brand_id=plan.brand_id,
        title=plan.title,
        status=plan.status,
        diagnosis_score=plan.diagnosis_score,
        target_score=plan.target_score,
        estimated_weeks=plan.estimated_weeks,
        plan_data=plan.plan_data,
        source=plan.source,
        actions=actions,
        created_at=plan.created_at,
        updated_at=plan.updated_at,
    )


@router.post("/generate", response_model=GeoPlanResponse)
async def generate_geo_plan_endpoint(
    request: GeoPlanGenerateRequest,
    current_user: User = Depends(get_current_user),
    db: AsyncSession = Depends(get_db),
):
    brand = await _get_brand_with_access(request.brand_id, db, current_user)

    (
        v2_result,
        competitor_data,
        sentiment_data,
        platform_scores,
        total_queries,
        mentioned_count,
    ) = await _get_brand_scoring_data(db, _to_uuid(current_user.id), brand)

    target_score = request.target_score or 75

    plan_data = await generate_geo_plan(
        brand_name=brand.name,
        scoring_result=v2_result,
        target_score=target_score,
        total_queries=total_queries,
        platform_scores=platform_scores,
        competitor_data=competitor_data,
    )

    from app.config import settings
    source = "llm" if (settings.ENABLE_LLM and settings.DEEPSEEK_API_KEY) else "rule"

    organization_id = current_user.id
    org_stmt = select(func.count()).select_from(
        select(1).where(True).subquery()
    )

    db_plan = GeoPlan(
        organization_id=organization_id,
        brand_id=brand.id,
        title=plan_data.title,
        status="draft",
        diagnosis_score=int(round(v2_result.overall_score)),
        target_score=target_score,
        estimated_weeks=plan_data.estimated_weeks,
        plan_data={
            "weekly_plan": plan_data.weekly_plan,
        },
        source=source,
        created_by=current_user.id,
    )
    db.add(db_plan)
    await db.flush()

    for idx, action_item in enumerate(plan_data.actions):
        db_action = GeoPlanAction(
            plan_id=db_plan.id,
            action_type=action_item.action_type,
            title=action_item.title,
            description=action_item.description,
            reason=action_item.reason,
            priority=action_item.priority,
            status="pending",
            target_keyword=action_item.target_keyword,
            target_platform=action_item.target_platform,
            content_style=action_item.content_style,
            estimated_impact=action_item.estimated_impact,
            difficulty=action_item.difficulty,
            execution_params=action_item.execution_params,
            sort_order=idx,
        )
        db.add(db_action)

    await db.commit()
    await db.refresh(db_plan)

    stmt = select(GeoPlan).where(GeoPlan.id == db_plan.id)
    result = await db.execute(stmt)
    db_plan = result.scalar_one()

    action_stmt = select(GeoPlanAction).where(
        GeoPlanAction.plan_id == db_plan.id
    ).order_by(GeoPlanAction.sort_order)
    action_result = await db.execute(action_stmt)
    db_plan.actions = list(action_result.scalars().all())

    return _plan_to_response(db_plan)


@router.get("/brand/{brand_id}", response_model=GeoPlanListResponse)
async def get_brand_plans(
    brand_id: uuid.UUID,
    skip: int = Query(0, ge=0),
    limit: int = Query(20, ge=1, le=100),
    current_user: User = Depends(get_current_user),
    db: AsyncSession = Depends(get_db),
):
    await _get_brand_with_access(brand_id, db, current_user)

    count_stmt = select(func.count()).select_from(GeoPlan).where(
        GeoPlan.brand_id == brand_id,
    )
    count_result = await db.execute(count_stmt)
    total = count_result.scalar_one()

    stmt = (
        select(GeoPlan)
        .where(GeoPlan.brand_id == brand_id)
        .order_by(GeoPlan.created_at.desc())
        .offset(skip)
        .limit(limit)
    )
    result = await db.execute(stmt)
    plans = list(result.scalars().all())

    plan_responses = []
    for plan in plans:
        action_stmt = select(GeoPlanAction).where(
            GeoPlanAction.plan_id == plan.id
        ).order_by(GeoPlanAction.sort_order)
        action_result = await db.execute(action_stmt)
        plan.actions = list(action_result.scalars().all())
        plan_responses.append(_plan_to_response(plan))

    return GeoPlanListResponse(plans=plan_responses, total=total)


@router.get("/{plan_id}", response_model=GeoPlanResponse)
async def get_plan_detail(
    plan_id: uuid.UUID,
    current_user: User = Depends(get_current_user),
    db: AsyncSession = Depends(get_db),
):
    stmt = select(GeoPlan).where(GeoPlan.id == plan_id)
    result = await db.execute(stmt)
    plan = result.scalar_one_or_none()

    if not plan:
        raise HTTPException(
            status_code=status.HTTP_404_NOT_FOUND,
            detail="方案不存在",
        )

    brand = await _get_brand_with_access(plan.brand_id, db, current_user)

    action_stmt = select(GeoPlanAction).where(
        GeoPlanAction.plan_id == plan.id
    ).order_by(GeoPlanAction.sort_order)
    action_result = await db.execute(action_stmt)
    plan.actions = list(action_result.scalars().all())

    return _plan_to_response(plan)


@router.put("/actions/{action_id}/status", response_model=GeoPlanActionResponse)
async def update_action_status(
    action_id: uuid.UUID,
    status_update: GeoPlanActionUpdateStatus,
    current_user: User = Depends(get_current_user),
    db: AsyncSession = Depends(get_db),
):
    valid_statuses = {"pending", "in_progress", "completed", "skipped"}
    if status_update.status not in valid_statuses:
        raise HTTPException(
            status_code=status.HTTP_400_BAD_REQUEST,
            detail=f"无效的状态值，支持: {', '.join(valid_statuses)}",
        )

    stmt = select(GeoPlanAction).where(GeoPlanAction.id == action_id)
    result = await db.execute(stmt)
    action = result.scalar_one_or_none()

    if not action:
        raise HTTPException(
            status_code=status.HTTP_404_NOT_FOUND,
            detail="行动项不存在",
        )

    plan_stmt = select(GeoPlan).where(GeoPlan.id == action.plan_id)
    plan_result = await db.execute(plan_stmt)
    plan = plan_result.scalar_one()

    await _get_brand_with_access(plan.brand_id, db, current_user)

    action.status = status_update.status
    if status_update.status == "completed":
        action.completed_at = datetime.now()

    await db.commit()
    await db.refresh(action)

    return GeoPlanActionResponse(
        id=action.id,
        plan_id=action.plan_id,
        action_type=action.action_type,
        title=action.title,
        description=action.description,
        reason=action.reason,
        priority=action.priority,
        status=action.status,
        target_keyword=action.target_keyword,
        target_platform=action.target_platform,
        content_style=action.content_style,
        estimated_impact=action.estimated_impact,
        difficulty=action.difficulty,
        execution_params=action.execution_params,
        sort_order=action.sort_order,
        completed_at=action.completed_at,
        created_at=action.created_at,
    )


@router.post("/actions/{action_id}/execute", response_model=GeoPlanActionExecuteResponse)
async def execute_action(
    action_id: uuid.UUID,
    current_user: User = Depends(get_current_user),
    db: AsyncSession = Depends(get_db),
):
    stmt = select(GeoPlanAction).where(GeoPlanAction.id == action_id)
    result = await db.execute(stmt)
    action = result.scalar_one_or_none()

    if not action:
        raise HTTPException(
            status_code=status.HTTP_404_NOT_FOUND,
            detail="行动项不存在",
        )

    plan_stmt = select(GeoPlan).where(GeoPlan.id == action.plan_id)
    plan_result = await db.execute(plan_stmt)
    plan = plan_result.scalar_one()

    brand = await _get_brand_with_access(plan.brand_id, db, current_user)

    if action.action_type not in ("content_creation", "content_optimization"):
        raise HTTPException(
            status_code=status.HTTP_400_BAD_REQUEST,
            detail=f"行动类型 '{action.action_type}' 不支持一键执行，仅支持 content_creation 和 content_optimization",
        )

    params = action.execution_params or {}
    keyword = params.get("keyword", action.target_keyword or brand.name)
    platform = params.get("platform", action.target_platform or "通用")
    style = params.get("style", action.content_style or "专业严谨")
    word_count = params.get("word_count", 2000)
    knowledge_base_ids = params.get("knowledge_base_ids")

    content_service = ContentGenerationService()

    try:
        gen_result = await content_service.generate_content(
            keyword=keyword,
            brand_name=brand.name,
            platform=platform,
            content_style=style,
            word_count=word_count,
            knowledge_base_ids=knowledge_base_ids,
            db=db,
            user_id=current_user.id,
            org_id=str(plan.organization_id),
            run_deai=True,
            run_geo=True,
        )
    except Exception as e:
        raise HTTPException(
            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
            detail=f"内容生成失败: {str(e)}",
        )

    action.status = "completed"
    action.completed_at = datetime.now()
    await db.commit()
    await db.refresh(action)

    content_id = gen_result.get("content_id")

    return GeoPlanActionExecuteResponse(
        action_id=action.id,
        content_id=content_id,
        message="内容生成成功" if content_id else "内容生成完成（未持久化）",
    )