from fastapi import APIRouter, Depends, HTTPException, Query
from sqlalchemy.orm import Session

from app.api.deps import get_current_user
from app.core.config import get_settings
from app.db.session import get_db
from app.models.enums import WhatsAppLogStatus
from app.repositories.insurance_company_repository import WhatsAppLogRepository
from app.schemas.user_context import CurrentUser
from app.schemas.whatsapp import WhatsAppMessageRequest, WhatsAppMessageResponse, WhatsAppWebhookPayload
from app.services.policy_service import PolicyService
from app.services.whatsapp_service import WhatsAppService

router = APIRouter()

STATUS_MAP = {
    "sent": WhatsAppLogStatus.SENT,
    "delivered": WhatsAppLogStatus.DELIVERED,
    "read": WhatsAppLogStatus.READ,
    "failed": WhatsAppLogStatus.FAILED,
}


@router.get("/webhook")
def verify_webhook(
    hub_mode: str = Query(alias="hub.mode"),
    hub_challenge: str = Query(alias="hub.challenge"),
    hub_verify_token: str = Query(alias="hub.verify_token"),
):
    settings = get_settings()
    if hub_mode == "subscribe" and hub_verify_token == settings.whatsapp_webhook_verify_token:
        return int(hub_challenge)
    raise HTTPException(status_code=403, detail="Webhook verification failed")


@router.post("/webhook")
async def receive_webhook(payload: WhatsAppWebhookPayload, db: Session = Depends(get_db)):
    service = WhatsAppService(db)
    updated = 0
    for entry in payload.entry:
        for change in entry.changes:
            for status in change.value.statuses:
                mapped = STATUS_MAP.get(status.status)
                if mapped and status.id:
                    if service.update_delivery_status(status.id, mapped):
                        updated += 1
    return {"updated": updated}


@router.post("/policies/{policy_id}/message", response_model=WhatsAppMessageResponse)
def generate_whatsapp_message(
    policy_id: int,
    payload: WhatsAppMessageRequest,
    current_user: CurrentUser = Depends(get_current_user),
    db: Session = Depends(get_db),
):
    return WhatsAppService(db).build_manual_message(
        current_user.agency_id,
        current_user.agency_name,
        policy_id,
        current_user.id,
        payload,
    )


@router.get("/policies/{policy_id}/logs")
def whatsapp_logs(
    policy_id: int,
    current_user: CurrentUser = Depends(get_current_user),
    db: Session = Depends(get_db),
):
    PolicyService(db).get_policy(current_user.agency_id, policy_id)
    logs = WhatsAppLogRepository(db).list_by_policy(policy_id)
    return [
        {
            "id": log.id,
            "mobile": log.mobile,
            "message": log.message,
            "status": log.status.value,
            "send_mode": log.send_mode.value,
            "whatsapp_url": log.whatsapp_url,
            "external_message_id": log.external_message_id,
            "template_name": log.template_name,
            "failure_reason": log.failure_reason,
            "reminder_offset_days": log.reminder_offset_days,
            "created_at": log.created_at.isoformat(),
        }
        for log in logs
    ]


@router.get("/status")
def whatsapp_integration_status(current_user: CurrentUser = Depends(get_current_user)):
    settings = get_settings()
    return {
        "cloud_enabled": settings.whatsapp_cloud_enabled,
        "configured": settings.whatsapp_configured,
        "template_name": settings.whatsapp_template_name,
        "quiet_hours": {
            "start": settings.whatsapp_quiet_hours_start,
            "end": settings.whatsapp_quiet_hours_end,
        },
    }