from datetime import 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

from app.api import deps
from app.models import Project, Slot, Sms, User
from app.schemas.requests import (
    ProjectImportGsheetRequest,
    ProjectRequest,
    ProjectSMSBatchRequest,
)
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"""
    results = session.execute(select(Project))
    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"""
    results = session.execute(select(Project).where(Project.is_public == True))
    return results.scalars().all()


@router.post("/project", response_model=ProjectResponse)
async def create_project(
    new_project: ProjectRequest,
    current_user: User = Depends(deps.get_current_user),
    session: Session = Depends(deps.get_session),
):
    """Create a new project"""
    project = Project(**new_project.dict())
    session.add(project)
    try:
        session.commit()
    except IntegrityError as e:
        raise HTTPException(422, "Project name already exist")

    session.refresh(project)

    return ProjectResponse.from_orm(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"""
    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.get_current_user),
    session: Session = Depends(deps.get_session),
):
    """Get a project"""
    project = session.get(Project, project_id)
    if project is None:
        raise HTTPException(status_code=404, detail="Project not found")
    return ProjectResponse.from_orm(project)


@router.post("/project/{project_id}", response_model=ProjectListResponse)
async def update_project(
    project_id: UUID,
    edit_project: ProjectRequest,
    current_user: User = Depends(deps.get_current_user),
    session: Session = Depends(deps.get_session),
):
    """Edit project"""
    p = session.get(Project, project_id)
    if p is None:
        raise HTTPException(status_code=404, detail="Project not found")
    p.name = edit_project.name
    p.is_public = edit_project.is_public
    session.commit()
    return p


@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.get_current_user),
    session: Session = Depends(deps.get_session),
):
    """Edit project name"""
    p = session.get(Project, project_id)
    if p is None:
        raise HTTPException(status_code=404, detail="Project not found")
    url = gsheet.sheet_url
    # TODO implement feature to import
    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.get_current_user),
    session: Session = Depends(deps.get_session),
):
    """Create SMS based on a template and the list of slots and volunteer associated to the project

    The placeholder that can be used in the template are
     - {titre} slot.title
     - {description} slot.description
     - {debut} slot.starting_time
     - {fin} slot.ending_ting
     - {prenom} volunteer.name
     - {name} volunteer.surname

    """
    p = session.get(Project, project_id)
    if p is None:
        raise HTTPException(status_code=404, detail="Project not found")
    # Get all slots
    slots = session.execute(select(Slot).where(Slot.project_id == project_id))
    sms_list = []
    for slot in slots.scalars():
        # Replace the slot placeholder by their value
        slot_content = (
            sms_batch.template.replace("{titre}", slot.title)
            .replace("{description}", slot.description)
            .replace("{debut}", str(slot.starting_time))
            .replace("{fin}", str(slot.ending_time))
        )
        sending_time = slot.starting_time - timedelta(minutes=sms_batch.delta_t)
        for volunteer in slot.volunteers:
            # Create a new SMS customized for each user attache to the slot
            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(
    id: UUID,
    current_user: User = Depends(deps.get_current_user),
    session: Session = Depends(deps.get_session),
):
    """Delete project"""
    session.execute(delete(Project).where(Project.id == project_id))
    session.commit()