from datetime import UTC, datetime, timedelta
from uuid import UUID

from fastapi import APIRouter, Depends, HTTPException
from sqlalchemy import delete, select
from sqlalchemy.exc import IntegrityError
from sqlalchemy.orm import Session, selectinload

from app.api import deps
from app.api.utils import assert_project_exists_or_404, get_project_or_404
from app.importData.gsheet import ParsingError, extract_doc_uid, parseGsheet
from app.models import (
    Commission,
    GlobalRole,
    OrgRole,
    Project,
    Slot,
    SlotTag,
    SlotTemplate,
    Sms,
    User,
    Volunteer,
    VolunteerGroup,
)
from app.schemas.objects import PlanningConstraints
from app.schemas.requests import (
    ProjectConstraintUpdateRequest,
    ProjectCreateRequest,
    ProjectImportGsheetRequest,
    ProjectSMSBatchRequest,
    ProjectUpdateRequest,
)
from app.schemas.responses import ProjectListResponse, ProjectResponse, SMSResponse

router = APIRouter()


@router.get("/projects", response_model=list[ProjectListResponse])
async def list_project(
    current_user: User = Depends(deps.get_current_user),
    session: Session = Depends(deps.get_session),
):
    """Get project list, scoped to the caller's organizations (all projects for super_admin)."""
    if current_user.global_role == GlobalRole.SUPER_ADMIN:
        results = session.execute(select(Project))
    else:
        org_ids = [m.organization_id for m in current_user.organizations]
        if not org_ids:
            return []
        results = session.execute(select(Project).where(Project.organization_id.in_(org_ids)))
    return results.scalars().all()


@router.get("/public-projects", response_model=list[ProjectListResponse])
async def list_public_project(
    session: Session = Depends(deps.get_session),
):
    """Get the list of public projects — unchanged, stays fully public."""
    results = session.execute(select(Project).where(Project.is_public))
    return results.scalars().all()


@router.post("/project", response_model=ProjectResponse)
async def create_project(
    new_project: ProjectCreateRequest,
    current_user: User = Depends(deps.get_current_user),
    session: Session = Depends(deps.get_session),
):
    """Create a new project within one of the caller's organizations."""
    org_id = str(new_project.organization_id)
    if current_user.global_role != GlobalRole.SUPER_ADMIN:
        role = next(
            (m.role for m in current_user.organizations if m.organization_id == org_id),
            None,
        )
        if role != OrgRole.ORG_ADMIN:
            raise HTTPException(403, "Only an org_admin can create projects for this organization")

    project = Project(**new_project.model_dump())
    session.add(project)
    try:
        session.commit()
    except IntegrityError:
        raise HTTPException(400, "Project name already exist")

    session.refresh(project)
    return project


@router.get("/public-project/{project_id}", response_model=ProjectResponse)
async def get_public_project(
    project_id: UUID,
    session: Session = Depends(deps.get_session),
):
    """Get a project that is public — unchanged, stays fully public."""
    result = session.get(Project, project_id)
    if (result is None) or not result.is_public:
        raise HTTPException(status_code=404, detail="Project not found")
    return result


@router.get("/project/{project_id}", response_model=ProjectResponse)
async def get_project(
    project_id: UUID,
    current_user: User = Depends(
        deps.require_org_role(OrgRole.ORG_ADMIN, OrgRole.RESPO_BENEVOLE, OrgRole.RESPO_COMMISSION)
    ),
    session: Session = Depends(deps.get_session),
):
    """Get a project"""
    project = session.scalar(
        select(Project)
        .where(Project.id == project_id)
        .options(
            selectinload(Project.volunteers),
            selectinload(Project.sms),
            selectinload(Project.slots).selectinload(Slot.volunteers),
            selectinload(Project.slots).selectinload(Slot.template),
            selectinload(Project.tags).selectinload(SlotTag.templates),
            selectinload(Project.templates).selectinload(SlotTemplate.tags),
            selectinload(Project.templates).selectinload(SlotTemplate.commission),
            selectinload(Project.groups).selectinload(VolunteerGroup.volunteers),
            selectinload(Project.commissions).selectinload(Commission.templates),
            selectinload(Project.commissions).selectinload(Commission.members),
        )
    )
    if project is None:
        raise HTTPException(status_code=404, detail="Project not found")
    return project


@router.post(
    "/project/{project_id}",
    response_model=ProjectListResponse,
    openapi_extra={"sse_event": "project_updated"},
)
async def update_project(
    project_id: UUID,
    edit_project: ProjectUpdateRequest,
    current_user: User = Depends(deps.require_org_role(OrgRole.ORG_ADMIN)),
    session: Session = Depends(deps.get_session),
):
    """Edit project"""
    p = get_project_or_404(session, project_id)
    p.name = edit_project.name
    p.is_public = edit_project.is_public
    session.commit()
    return p


@router.post(
    "/project/{project_id}/constraints",
    openapi_extra={"sse_event": "project_constraints_updated"},
    response_model=PlanningConstraints,
)
async def update_project_constraints(
    project_id: UUID,
    payload: ProjectConstraintUpdateRequest,
    current_user: User = Depends(deps.require_org_role(OrgRole.ORG_ADMIN, OrgRole.RESPO_BENEVOLE)),
    session: Session = Depends(deps.get_session),
):
    project = session.get(Project, project_id)
    if project is None:
        raise HTTPException(status_code=404, detail="Project not found")
    project.constraints = payload.model_dump()
    session.commit()
    session.refresh(project)
    return project.constraints


@router.post("/project/{project_id}/import-gsheet", response_model=ProjectResponse)
async def update_project_from_gsheet(
    project_id: UUID,
    gsheet: ProjectImportGsheetRequest,
    current_user: User = Depends(deps.require_org_role(OrgRole.ORG_ADMIN, OrgRole.RESPO_BENEVOLE)),
    session: Session = Depends(deps.get_session),
):
    """Edit project name"""
    p: Project = session.get(Project, project_id)
    if p is None:
        raise HTTPException(status_code=404, detail="Project not found")
    doc_id = extract_doc_uid(gsheet.sheet_url)
    if gsheet.erase_data:
        p.slots = []
        p.sms = []
        p.volunteers = []
        p.tags = []
        p.templates = []
    try:
        data = parseGsheet(doc_id, gsheet.satursday_date)
    except ParsingError as exc:
        raise HTTPException(status_code=422, detail=str(exc))

    volunteer_map: dict[str, Volunteer] = {}
    for _, row in data.contact.iterrows():
        volunteer = Volunteer(
            project_id=project_id,
            name=row["Prénom"],
            surname=row["Nom"],
            email=row["Mail"],
            phone_number=row["Tél"],
            automatic_sms=row["SMS"],
        )
        volunteer_map[row.key] = volunteer
        session.add(volunteer)

    template_map = {}
    tags_map = {tag.title: tag for tag in p.tags}

    for _, row in data.creneauData.iterrows():
        # NOTE: responsible_override stays free-text on gsheet import for now —
        # linking to a real Commission requires matching against commission
        # names/members, which the sheet doesn't carry. Revisit once the
        # gsheet format itself is updated to reference commissions.
        template = SlotTemplate(
            project_id=project_id,
            title=row.title,
            description=row.description,
            place=row.lieu,
            responsible_override=row.responsable,
        )

        for s_tag in row.tags.split(","):
            if s_tag != "":
                if s_tag in tags_map:
                    tag = tags_map[s_tag]
                else:
                    tag = SlotTag(project_id=project_id, title=s_tag)
                    session.add(tag)
                    tags_map[s_tag] = tag
                template.tags.append(tag)

        template_map[template.title] = template
        session.add(template)

    df_planning = data.planning
    date_format = "%Y/%m/%d %H:%M"
    df_planning["key"] = (
        df_planning.nom.str.strip()
        + "_"
        + df_planning.start.dt.strftime(date_format)
        + "-"
        + df_planning.end.dt.strftime(date_format)
    )
    df_slots = df_planning.groupby("key")

    for key in df_slots.groups.keys():
        group = df_slots.get_group(key)
        volunteers = group.benevole_nom.tolist()
        slot = Slot(
            project_id=project_id,
            title=group.nom.iloc[0],
            starting_time=group.start.iloc[0],
            ending_time=group.end.iloc[0],
            required_volunteers=len(volunteers),
        )
        for benevole_key in volunteers:
            if benevole_key in volunteer_map:
                slot.volunteers.append(volunteer_map[benevole_key])

        template_id = group.template_id.iloc[0]
        if template_id in template_map:
            slot.template = template_map[template_id]

        session.add(slot)
    session.commit()
    session.refresh(p)
    return p


@router.post("/project/{project_id}/create-all-sms", response_model=list[SMSResponse])
async def create_sms_batch(
    project_id: UUID,
    sms_batch: ProjectSMSBatchRequest,
    current_user: User = Depends(deps.require_org_role(OrgRole.ORG_ADMIN, OrgRole.RESPO_BENEVOLE)),
    session: Session = Depends(deps.get_session),
):
    """(docstring unchanged)"""
    assert_project_exists_or_404(session, project_id)
    slots = session.execute(select(Slot).where(Slot.project_id == project_id))
    sms_list = []
    now = datetime.now(UTC)
    for slot in slots.scalars():
        slot_content = (
            sms_batch.template.replace("{titre}", slot.title)
            .replace("{debut}", slot.starting_time.strftime("%Hh%M"))
            .replace("{fin}", slot.ending_time.strftime("%Hh%M"))
        )
        if slot.template is not None:
            slot_content = slot_content.replace("{description}", slot.template.description).replace(
                "{respo}", slot.template.effective_responsible_contact
            )

        sending_time = slot.starting_time - timedelta(minutes=sms_batch.delta_t)
        if sending_time < now:
            continue
        for volunteer in slot.volunteers:
            if not volunteer.automatic_sms:
                continue
            personalized_content = slot_content.replace("{prenom}", volunteer.name).replace(
                "{nom}", volunteer.surname
            )
            sms = Sms(
                project_id=project_id,
                volunteer_id=volunteer.id,
                content=personalized_content,
                phone_number=volunteer.phone_number,
                sending_time=sending_time,
            )
            sms_list.append(sms)
    session.add_all(sms_list)
    session.commit()

    return sms_list


@router.delete("/project/{project_id}")
async def delete_project(
    project_id: UUID,
    current_user: User = Depends(deps.require_org_role(OrgRole.ORG_ADMIN)),
    session: Session = Depends(deps.get_session),
):
    """Delete project"""
    session.execute(delete(Project).where(Project.id == project_id))
    session.commit()