# backend/app/plugins/contact_forms/admin_router.py
from fastapi import APIRouter, Depends, HTTPException, Query
from sqlalchemy import select, func, delete
from sqlalchemy.ext.asyncio import AsyncSession

from app.api.deps import get_db, get_admin_user
from app.core.models.user import User
from app.core.services.plugin_helper import require_plugin
from app.core.models.tenant_settings import TenantSettings
from app.services.email import build_smtp_config


async def _guard(db: AsyncSession = Depends(get_db)) -> None:
    await require_plugin("contact_forms", db)


router = APIRouter(
    prefix="/contact-forms",
    tags=["contact_forms_admin"],
    dependencies=[Depends(_guard)],
)


async def _get_smtp(db: AsyncSession, tenant_id: int) -> dict:
    r = await db.execute(
        select(TenantSettings).where(TenantSettings.tenant_id == tenant_id)
    )
    return build_smtp_config(r.scalar_one_or_none())


# ── 表单 CRUD ──────────────────────────────────────────────────

@router.get("", response_model=list)
async def list_forms(
    db: AsyncSession = Depends(get_db),
    user: User = Depends(get_admin_user),
):
    from app.core.models import ContactForm
    from app.plugins.contact_forms.schemas import ContactFormListOut
    r = await db.execute(
        select(ContactForm)
        .where(ContactForm.tenant_id == user.tenant_id)
        .order_by(ContactForm.id.desc())
    )
    forms = r.scalars().all()
    return [ContactFormListOut.model_validate(f) for f in forms]


@router.post("", status_code=201)
async def create_form(
    body: dict,
    db: AsyncSession = Depends(get_db),
    user: User = Depends(get_admin_user),
):
    from app.core.models import ContactForm, ContactFormField
    from app.plugins.contact_forms.schemas import ContactFormIn, ContactFormOut
    from app.plugins.contact_forms.services import get_form_with_fields

    data = ContactFormIn(**body)
    form = ContactForm(
        tenant_id=user.tenant_id,
        name=data.name,
        title=data.title,
        success_message=data.success_message,
        notification_emails=data.notification_emails,
        admin_email_subject=data.admin_email_subject,
        admin_email_body=data.admin_email_body,
        confirm_email_enabled=int(data.confirm_email_enabled),
        confirm_email_subject=data.confirm_email_subject,
        confirm_email_body=data.confirm_email_body,
        is_active=int(data.is_active),
    )
    db.add(form)
    await db.flush()

    for i, f in enumerate(data.fields):
        db.add(ContactFormField(
            form_id=form.id,
            field_type=f.field_type,
            label=f.label,
            name=f.name,
            placeholder=f.placeholder,
            is_required=int(f.is_required),
            options=[o.model_dump() for o in f.options],
            sort_order=f.sort_order if f.sort_order else i,
            validation=f.validation,
        ))

    await db.commit()
    result = await get_form_with_fields(db, form.id, user.tenant_id)
    return ContactFormOut.model_validate(result)


@router.get("/submissions/{sub_id}")
async def get_submission(
    sub_id: int,
    db: AsyncSession = Depends(get_db),
    user: User = Depends(get_admin_user),
):
    from app.core.models import ContactFormSubmission, ContactFormReply
    from app.plugins.contact_forms.schemas import ContactFormSubmissionOut

    r = await db.execute(
        select(ContactFormSubmission).where(
            ContactFormSubmission.id == sub_id,
            ContactFormSubmission.tenant_id == user.tenant_id,
        )
    )
    sub = r.scalar_one_or_none()
    if not sub:
        raise HTTPException(404, "提交记录不存在")

    if sub.status == "unread":
        sub.status = "read"
        await db.commit()

    replies_r = await db.execute(
        select(ContactFormReply)
        .where(ContactFormReply.submission_id == sub_id)
        .order_by(ContactFormReply.sent_at)
    )
    sub.replies = list(replies_r.scalars().all())
    return ContactFormSubmissionOut.model_validate(sub)


@router.post("/submissions/{sub_id}/reply", status_code=201)
async def reply_submission(
    sub_id: int,
    body: dict,
    db: AsyncSession = Depends(get_db),
    user: User = Depends(get_admin_user),
):
    from app.core.models import ContactFormSubmission, ContactFormReply
    from app.plugins.contact_forms.schemas import ContactFormReplyIn, ContactFormReplyOut
    from app.plugins.contact_forms.services import get_form_with_fields, send_reply_email

    r = await db.execute(
        select(ContactFormSubmission).where(
            ContactFormSubmission.id == sub_id,
            ContactFormSubmission.tenant_id == user.tenant_id,
        )
    )
    sub = r.scalar_one_or_none()
    if not sub:
        raise HTTPException(404, "提交记录不存在")

    reply_data = ContactFormReplyIn(**body)
    reply = ContactFormReply(
        submission_id=sub_id,
        admin_user_id=user.id,
        body=reply_data.body,
    )
    db.add(reply)
    sub.status = "replied"
    await db.commit()
    await db.refresh(reply)

    form = await get_form_with_fields(db, sub.form_id, user.tenant_id)
    smtp_config = await _get_smtp(db, user.tenant_id)
    await send_reply_email(db, form, sub, reply_data.body, smtp_config)

    return ContactFormReplyOut.model_validate(reply)


@router.get("/submissions")
async def list_all_submissions(
    status: str | None = Query(None),
    page: int = Query(1, ge=1),
    page_size: int = Query(20, ge=1, le=100),
    db: AsyncSession = Depends(get_db),
    user: User = Depends(get_admin_user),
):
    from app.core.models import ContactFormSubmission
    from app.plugins.contact_forms.models import ContactForm
    from app.plugins.contact_forms.schemas import AllSubmissionsListOut, PaginatedAllSubmissions

    q = (
        select(ContactFormSubmission, ContactForm.name.label("form_name"))
        .join(ContactForm, ContactForm.id == ContactFormSubmission.form_id)
        .where(ContactFormSubmission.tenant_id == user.tenant_id)
    )
    if status:
        q = q.where(ContactFormSubmission.status == status)

    total_r = await db.execute(select(func.count()).select_from(q.subquery()))
    total = total_r.scalar()

    rows = await db.execute(
        q.order_by(ContactFormSubmission.created_at.desc())
        .offset((page - 1) * page_size)
        .limit(page_size)
    )
    items = [
        AllSubmissionsListOut(
            id=sub.id,
            form_id=sub.form_id,
            form_name=form_name,
            submitter_email=sub.submitter_email,
            submitter_name=sub.submitter_name,
            status=sub.status,
            created_at=sub.created_at,
        )
        for sub, form_name in rows.all()
    ]
    return PaginatedAllSubmissions(items=items, total=total, page=page, page_size=page_size)



@router.get("/{form_id}")
async def get_form(
    form_id: int,
    db: AsyncSession = Depends(get_db),
    user: User = Depends(get_admin_user),
):
    from app.plugins.contact_forms.services import get_form_with_fields
    from app.plugins.contact_forms.schemas import ContactFormOut

    form = await get_form_with_fields(db, form_id, user.tenant_id)
    if not form:
        raise HTTPException(404, "表单不存在")
    return ContactFormOut.model_validate(form)


@router.put("/{form_id}")
async def update_form(
    form_id: int,
    body: dict,
    db: AsyncSession = Depends(get_db),
    user: User = Depends(get_admin_user),
):
    from app.core.models import ContactFormField
    from app.plugins.contact_forms.schemas import ContactFormIn, ContactFormOut
    from app.plugins.contact_forms.services import get_form_with_fields

    form = await get_form_with_fields(db, form_id, user.tenant_id)
    if not form:
        raise HTTPException(404, "表单不存在")

    data = ContactFormIn(**body)
    form.name = data.name
    form.title = data.title
    form.success_message = data.success_message
    form.notification_emails = data.notification_emails
    form.admin_email_subject = data.admin_email_subject
    form.admin_email_body = data.admin_email_body
    form.confirm_email_enabled = int(data.confirm_email_enabled)
    form.confirm_email_subject = data.confirm_email_subject
    form.confirm_email_body = data.confirm_email_body
    form.is_active = int(data.is_active)

    await db.execute(delete(ContactFormField).where(ContactFormField.form_id == form_id))
    for i, f in enumerate(data.fields):
        db.add(ContactFormField(
            form_id=form_id,
            field_type=f.field_type,
            label=f.label,
            name=f.name,
            placeholder=f.placeholder,
            is_required=int(f.is_required),
            options=[o.model_dump() for o in f.options],
            sort_order=f.sort_order if f.sort_order else i,
            validation=f.validation,
        ))

    await db.commit()
    result = await get_form_with_fields(db, form_id, user.tenant_id)
    return ContactFormOut.model_validate(result)


@router.delete("/{form_id}", status_code=204)
async def delete_form(
    form_id: int,
    db: AsyncSession = Depends(get_db),
    user: User = Depends(get_admin_user),
):
    from app.plugins.contact_forms.services import get_form_with_fields

    form = await get_form_with_fields(db, form_id, user.tenant_id)
    if not form:
        raise HTTPException(404, "表单不存在")
    await db.delete(form)
    await db.commit()


@router.get("/{form_id}/submissions")
async def list_submissions(
    form_id: int,
    status: str | None = Query(None),
    page: int = Query(1, ge=1),
    page_size: int = Query(20, ge=1, le=100),
    db: AsyncSession = Depends(get_db),
    user: User = Depends(get_admin_user),
):
    from app.core.models import ContactFormSubmission
    from app.plugins.contact_forms.schemas import PaginatedSubmissions, ContactFormSubmissionListOut
    from app.plugins.contact_forms.services import get_form_with_fields

    form = await get_form_with_fields(db, form_id, user.tenant_id)
    if not form:
        raise HTTPException(404, "表单不存在")

    q = select(ContactFormSubmission).where(
        ContactFormSubmission.form_id == form_id,
        ContactFormSubmission.tenant_id == user.tenant_id,
    )
    if status:
        q = q.where(ContactFormSubmission.status == status)

    total_r = await db.execute(select(func.count()).select_from(q.subquery()))
    total = total_r.scalar()

    items_r = await db.execute(
        q.order_by(ContactFormSubmission.created_at.desc())
        .offset((page - 1) * page_size)
        .limit(page_size)
    )
    items = [ContactFormSubmissionListOut.model_validate(s) for s in items_r.scalars().all()]
    return PaginatedSubmissions(items=items, total=total, page=page, page_size=page_size)