from datetime import datetime, timezone
from uuid import UUID

from fastapi import APIRouter, Depends, HTTPException, Response, status
from pydantic import BaseModel, Field
from sqlalchemy import select
from sqlalchemy.orm import Session, joinedload

from .auth import ADMIN_COOKIE_NAME, create_admin_token, current_admin
from .config import settings
from .database import get_db
from .dlt_service import refresh_dlt_application_status, serialize_dlt
from .kyc_service import refresh_application_status, serialize_kyc
from .routes_messaging import serialize_sender, serialize_template
from .models import (
    DltApplication,
    DltDocument,
    KycApplication,
    KycDocument,
    PhoneNumber,
    SenderConfig,
    TemplateConfig,
    UrmiOtpProject,
    UserAccount,
)
from .phone_number_validators import normalize_phone_number, validate_per_min_price, validate_price
from .routes_urmiotp import serialize_project

router = APIRouter(prefix="/api/v1/admin", tags=["admin"])


class AdminLoginRequest(BaseModel):
    username: str
    password: str


class DocumentReviewRequest(BaseModel):
    status: str = Field(pattern="^(approved|rejected)$")
    review_note: str | None = Field(default=None, max_length=500)


class ProjectReviewRequest(BaseModel):
    status: str = Field(pattern="^(approved|rejected)$")
    review_note: str | None = Field(default=None, max_length=500)


class CreatePhoneNumberRequest(BaseModel):
    phone_number: str = Field(min_length=10, max_length=10)
    monthly_number_price: float = Field(ge=0)
    inbound_price: float = Field(ge=0)
    outbound_price: float = Field(ge=0)
    user_email: str | None = Field(default=None, max_length=320)


class UpdatePhoneNumberRequest(BaseModel):
    monthly_number_price: float | None = Field(default=None, ge=0)
    inbound_price: float | None = Field(default=None, ge=0)
    outbound_price: float | None = Field(default=None, ge=0)
    user_email: str | None = Field(default=None, max_length=320)
    release: bool = False


def set_admin_session(response: Response) -> None:
    response.set_cookie(
        ADMIN_COOKIE_NAME,
        create_admin_token(settings.admin_username),
        httponly=True,
        secure=settings.auth_cookie_secure,
        samesite="lax",
        max_age=settings.access_token_minutes * 60,
        path="/",
    )


@router.post("/login")
def admin_login(payload: AdminLoginRequest, response: Response) -> dict[str, str]:
    if payload.username != settings.admin_username or payload.password != settings.admin_password:
        raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED, detail="Invalid admin credentials")
    set_admin_session(response)
    return {"username": settings.admin_username}


@router.post("/logout", status_code=status.HTTP_204_NO_CONTENT)
def admin_logout(response: Response) -> None:
    response.delete_cookie(ADMIN_COOKIE_NAME, path="/")


@router.get("/me")
def admin_me(username: str = Depends(current_admin)) -> dict[str, str]:
    return {"username": username}


@router.get("/compliance/kyc")
def list_kyc_applications(
    db: Session = Depends(get_db),
    _: str = Depends(current_admin),
) -> list[dict]:
    applications = db.scalars(
        select(KycApplication)
        .options(joinedload(KycApplication.user), joinedload(KycApplication.documents))
        .order_by(KycApplication.updated_at.desc())
    ).unique().all()
    return [
        {
            **serialize_kyc(app),
            "user": {
                "id": str(app.user.id),
                "name": app.user.display_name,
                "email": app.user.email,
            },
        }
        for app in applications
        if app.status != "not_started" or app.pan_number or any(doc.status != "missing" for doc in app.documents)
    ]


@router.patch("/compliance/kyc/{application_id}/documents/{document_id}")
def review_document(
    application_id: UUID,
    document_id: UUID,
    payload: DocumentReviewRequest,
    db: Session = Depends(get_db),
    _: str = Depends(current_admin),
) -> dict:
    application = db.scalar(
        select(KycApplication)
        .options(joinedload(KycApplication.user), joinedload(KycApplication.documents))
        .where(KycApplication.id == application_id)
    )
    if not application:
        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="KYC application not found")
    document = db.get(KycDocument, document_id)
    if not document or document.application_id != application.id:
        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Document not found")
    if document.status == "missing":
        raise HTTPException(status_code=status.HTTP_422_UNPROCESSABLE_ENTITY, detail="Document not uploaded yet")

    document.status = payload.status
    document.review_note = payload.review_note
    document.reviewed_at = datetime.now(timezone.utc)
    refresh_application_status(application)
    db.commit()
    db.refresh(application)
    return {
        **serialize_kyc(application),
        "user": {
            "id": str(application.user.id),
            "name": application.user.display_name,
            "email": application.user.email,
        },
    }


@router.get("/compliance/dlt")
def list_dlt_applications(
    db: Session = Depends(get_db),
    _: str = Depends(current_admin),
) -> list[dict]:
    applications = db.scalars(
        select(DltApplication)
        .options(joinedload(DltApplication.user), joinedload(DltApplication.documents))
        .order_by(DltApplication.updated_at.desc())
    ).unique().all()
    return [
        {
            **serialize_dlt(app),
            "user": {
                "id": str(app.user.id),
                "name": app.user.display_name,
                "email": app.user.email,
            },
        }
        for app in applications
        if app.status != "not_started" or any(doc.status != "missing" for doc in app.documents)
    ]


@router.patch("/compliance/dlt/{application_id}/documents/{document_id}")
def review_dlt_document(
    application_id: UUID,
    document_id: UUID,
    payload: DocumentReviewRequest,
    db: Session = Depends(get_db),
    _: str = Depends(current_admin),
) -> dict:
    application = db.scalar(
        select(DltApplication)
        .options(joinedload(DltApplication.user), joinedload(DltApplication.documents))
        .where(DltApplication.id == application_id)
    )
    if not application:
        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="DLT application not found")
    document = db.get(DltDocument, document_id)
    if not document or document.application_id != application.id:
        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Document not found")
    if document.status == "missing":
        raise HTTPException(status_code=status.HTTP_422_UNPROCESSABLE_ENTITY, detail="Document not uploaded yet")

    document.status = payload.status
    document.review_note = payload.review_note
    document.reviewed_at = datetime.now(timezone.utc)
    refresh_dlt_application_status(application)
    db.commit()
    db.refresh(application)
    return {
        **serialize_dlt(application),
        "user": {
            "id": str(application.user.id),
            "name": application.user.display_name,
            "email": application.user.email,
        },
    }


@router.get("/compliance/senders")
def list_sender_configs(
    db: Session = Depends(get_db),
    _: str = Depends(current_admin),
) -> list[dict]:
    senders = db.scalars(
        select(SenderConfig)
        .options(joinedload(SenderConfig.user))
        .order_by(SenderConfig.created_at.desc())
    ).unique().all()
    return [
        {
            **serialize_sender(sender),
            "user": {
                "id": str(sender.user.id),
                "name": sender.user.display_name,
                "email": sender.user.email,
            },
        }
        for sender in senders
    ]


@router.patch("/compliance/senders/{sender_id}")
def review_sender(
    sender_id: UUID,
    payload: DocumentReviewRequest,
    db: Session = Depends(get_db),
    _: str = Depends(current_admin),
) -> dict:
    sender = db.scalar(
        select(SenderConfig)
        .options(joinedload(SenderConfig.user))
        .where(SenderConfig.id == sender_id)
    )
    if not sender:
        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Sender config not found")
    if sender.status != "pending":
        raise HTTPException(status_code=status.HTTP_422_UNPROCESSABLE_ENTITY, detail="Sender already reviewed")

    sender.status = payload.status
    sender.review_note = payload.review_note
    sender.reviewed_at = datetime.now(timezone.utc)
    db.commit()
    db.refresh(sender)
    return {
        **serialize_sender(sender),
        "user": {
            "id": str(sender.user.id),
            "name": sender.user.display_name,
            "email": sender.user.email,
        },
    }


@router.get("/compliance/templates")
def list_template_configs(
    db: Session = Depends(get_db),
    _: str = Depends(current_admin),
) -> list[dict]:
    templates = db.scalars(
        select(TemplateConfig)
        .options(joinedload(TemplateConfig.user), joinedload(TemplateConfig.sender_config))
        .order_by(TemplateConfig.created_at.desc())
    ).unique().all()
    return [
        {
            **serialize_template(template),
            "user": {
                "id": str(template.user.id),
                "name": template.user.display_name,
                "email": template.user.email,
            },
        }
        for template in templates
    ]


@router.patch("/compliance/templates/{template_id}")
def review_template(
    template_id: UUID,
    payload: DocumentReviewRequest,
    db: Session = Depends(get_db),
    _: str = Depends(current_admin),
) -> dict:
    template = db.scalar(
        select(TemplateConfig)
        .options(joinedload(TemplateConfig.user), joinedload(TemplateConfig.sender_config))
        .where(TemplateConfig.id == template_id)
    )
    if not template:
        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Template config not found")
    if template.status != "pending":
        raise HTTPException(status_code=status.HTTP_422_UNPROCESSABLE_ENTITY, detail="Template already reviewed")

    template.status = payload.status
    template.review_note = payload.review_note
    template.reviewed_at = datetime.now(timezone.utc)
    db.commit()
    db.refresh(template)
    return {
        **serialize_template(template),
        "user": {
            "id": str(template.user.id),
            "name": template.user.display_name,
            "email": template.user.email,
        },
    }


@router.get("/compliance/urmiotp-projects")
def list_urmiotp_projects(
    db: Session = Depends(get_db),
    _: str = Depends(current_admin),
) -> list[dict]:
    projects = db.scalars(
        select(UrmiOtpProject)
        .options(joinedload(UrmiOtpProject.user))
        .order_by(UrmiOtpProject.created_at.desc())
    ).all()
    return [
        {
            **serialize_project(project),
            "user": {
                "id": str(project.user.id),
                "name": project.user.display_name,
                "email": project.user.email,
            },
        }
        for project in projects
    ]


@router.patch("/compliance/urmiotp-projects/{project_id}")
def review_urmiotp_project(
    project_id: UUID,
    payload: ProjectReviewRequest,
    db: Session = Depends(get_db),
    _: str = Depends(current_admin),
) -> dict:
    project = db.scalar(
        select(UrmiOtpProject)
        .options(joinedload(UrmiOtpProject.user))
        .where(UrmiOtpProject.id == project_id)
    )
    if not project:
        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="UrmiOTP project not found")
    if project.status != "pending":
        raise HTTPException(status_code=status.HTTP_422_UNPROCESSABLE_ENTITY, detail="Project already reviewed")

    project.status = payload.status
    project.review_note = payload.review_note
    project.reviewed_at = datetime.now(timezone.utc)
    db.commit()
    db.refresh(project)
    return {
        **serialize_project(project),
        "user": {
            "id": str(project.user.id),
            "name": project.user.display_name,
            "email": project.user.email,
        },
    }


def serialize_admin_phone_number(number: PhoneNumber) -> dict:
    return {
        "id": str(number.id),
        "phone_number": number.phone_number,
        "monthly_number_price": float(number.monthly_number_price),
        "inbound_price": float(number.inbound_price),
        "outbound_price": float(number.outbound_price),
        "currency": number.currency,
        "status": number.status,
        "acquisition_type": number.acquisition_type,
        "assigned_at": number.assigned_at,
        "created_at": number.created_at,
        "user": (
            {
                "id": str(number.user.id),
                "name": number.user.display_name,
                "email": number.user.email,
            }
            if number.user
            else None
        ),
    }


@router.get("/phone-numbers")
def list_phone_numbers(
    db: Session = Depends(get_db),
    _: str = Depends(current_admin),
) -> list[dict]:
    numbers = db.scalars(
        select(PhoneNumber)
        .options(joinedload(PhoneNumber.user))
        .order_by(PhoneNumber.created_at.desc())
    ).all()
    return [serialize_admin_phone_number(number) for number in numbers]


@router.post("/phone-numbers", status_code=status.HTTP_201_CREATED)
def create_phone_number(
    payload: CreatePhoneNumberRequest,
    db: Session = Depends(get_db),
    _: str = Depends(current_admin),
) -> dict:
    try:
        phone_number = normalize_phone_number(payload.phone_number)
        monthly_number_price = validate_price(payload.monthly_number_price, "Number monthly price")
        inbound_price = validate_per_min_price(payload.inbound_price, "Inbound price per min")
        outbound_price = validate_per_min_price(payload.outbound_price, "Outbound price per min")
    except ValueError as exc:
        raise HTTPException(status_code=status.HTTP_422_UNPROCESSABLE_ENTITY, detail=str(exc)) from exc

    existing = db.scalar(select(PhoneNumber).where(PhoneNumber.phone_number == phone_number))
    if existing:
        raise HTTPException(status_code=status.HTTP_409_CONFLICT, detail="This phone number already exists")

    user = None
    if payload.user_email:
        user = db.scalar(select(UserAccount).where(UserAccount.email == payload.user_email.strip().lower()))
        if not user:
            raise HTTPException(
                status_code=status.HTTP_404_NOT_FOUND,
                detail="No user account found for that email",
            )

    now = datetime.now(timezone.utc)
    number = PhoneNumber(
        phone_number=phone_number,
        inbound_price=inbound_price,
        outbound_price=outbound_price,
        monthly_number_price=monthly_number_price,
        user_id=user.id if user else None,
        status="assigned" if user else "available",
        acquisition_type="admin_assigned" if user else None,
        assigned_at=now if user else None,
    )
    db.add(number)
    db.commit()
    db.refresh(number)
    if user:
        number.user = user
    return serialize_admin_phone_number(number)


@router.patch("/phone-numbers/{number_id}")
def update_phone_number(
    number_id: UUID,
    payload: UpdatePhoneNumberRequest,
    db: Session = Depends(get_db),
    _: str = Depends(current_admin),
) -> dict:
    number = db.scalar(
        select(PhoneNumber)
        .options(joinedload(PhoneNumber.user))
        .where(PhoneNumber.id == number_id)
    )
    if not number:
        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Phone number not found")

    if payload.release:
        number.user_id = None
        number.status = "available"
        number.acquisition_type = None
        number.assigned_at = None
        number.user = None
    elif payload.user_email is not None:
        email = payload.user_email.strip().lower()
        if not email:
            raise HTTPException(
                status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
                detail="User email cannot be empty",
            )
        user = db.scalar(select(UserAccount).where(UserAccount.email == email))
        if not user:
            raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="No user account found for that email")
        number.user_id = user.id
        number.status = "assigned"
        number.acquisition_type = "admin_assigned"
        number.assigned_at = datetime.now(timezone.utc)
        number.user = user

    if payload.monthly_number_price is not None:
        try:
            number.monthly_number_price = validate_price(payload.monthly_number_price, "Number monthly price")
        except ValueError as exc:
            raise HTTPException(status_code=status.HTTP_422_UNPROCESSABLE_ENTITY, detail=str(exc)) from exc
    if payload.inbound_price is not None:
        try:
            number.inbound_price = validate_per_min_price(payload.inbound_price, "Inbound price per min")
        except ValueError as exc:
            raise HTTPException(status_code=status.HTTP_422_UNPROCESSABLE_ENTITY, detail=str(exc)) from exc
    if payload.outbound_price is not None:
        try:
            number.outbound_price = validate_per_min_price(payload.outbound_price, "Outbound price per min")
        except ValueError as exc:
            raise HTTPException(status_code=status.HTTP_422_UNPROCESSABLE_ENTITY, detail=str(exc)) from exc

    db.commit()
    db.refresh(number)
    return serialize_admin_phone_number(number)