from datetime import datetime
from typing import Optional

from fastapi import APIRouter, Depends, Query
from pydantic import BaseModel, ConfigDict
from sqlalchemy import select, func
from sqlalchemy.orm import Session

from app.core.database import get_db
from app.core.models import EmailTemplate

router = APIRouter(prefix="/api/email-templates", tags=["email-templates"])


# ===== Pydantic Models =====

class EmailTemplateBase(BaseModel):
    name: str
    subject: str
    body: str


class EmailTemplateCreate(EmailTemplateBase):
    pass


class EmailTemplateUpdate(BaseModel):
    name: Optional[str] = None
    subject: Optional[str] = None
    body: Optional[str] = None


class EmailTemplateResponse(EmailTemplateBase):
    id: int
    created_at: datetime

    model_config = ConfigDict(from_attributes=True)


class PaginatedTemplates(BaseModel):
    items: list[EmailTemplateResponse]
    total: int
    page: int
    page_size: int


# ===== Endpoints =====

@router.get("", response_model=PaginatedTemplates)
def list_templates(
    page: int = Query(1, ge=1),
    page_size: int = Query(20, ge=1, le=100),
    db: Session = Depends(get_db),
):
    offset = (page - 1) * page_size
    total = db.scalar(select(func.count(EmailTemplate.id)))
    rows = db.scalars(
        select(EmailTemplate)
        .order_by(EmailTemplate.id.desc())
        .offset(offset)
        .limit(page_size)
    ).all()
    return PaginatedTemplates(
        items=[EmailTemplateResponse.model_validate(r) for r in rows],
        total=total or 0,
        page=page,
        page_size=page_size,
    )


@router.post("", response_model=EmailTemplateResponse, status_code=201)
def create_template(data: EmailTemplateCreate, db: Session = Depends(get_db)):
    tmpl = EmailTemplate(name=data.name, subject=data.subject, body=data.body)
    db.add(tmpl)
    db.commit()
    db.refresh(tmpl)
    return EmailTemplateResponse.model_validate(tmpl)


@router.get("/{template_id}", response_model=EmailTemplateResponse)
def get_template(template_id: int, db: Session = Depends(get_db)):
    tmpl = db.get(EmailTemplate, template_id)
    if not tmpl:
        from fastapi import HTTPException
        raise HTTPException(status_code=404, detail="Template not found")
    return EmailTemplateResponse.model_validate(tmpl)


@router.put("/{template_id}", response_model=EmailTemplateResponse)
def update_template(template_id: int, data: EmailTemplateUpdate, db: Session = Depends(get_db)):
    tmpl = db.get(EmailTemplate, template_id)
    if not tmpl:
        from fastapi import HTTPException
        raise HTTPException(status_code=404, detail="Template not found")
    if data.name is not None:
        tmpl.name = data.name
    if data.subject is not None:
        tmpl.subject = data.subject
    if data.body is not None:
        tmpl.body = data.body
    db.commit()
    db.refresh(tmpl)
    return EmailTemplateResponse.model_validate(tmpl)


@router.delete("/{template_id}", status_code=204)
def delete_template(template_id: int, db: Session = Depends(get_db)):
    tmpl = db.get(EmailTemplate, template_id)
    if not tmpl:
        from fastapi import HTTPException
        raise HTTPException(status_code=404, detail="Template not found")
    db.delete(tmpl)
    db.commit()
    return None