from datetime import datetime, timedelta

import pytz
from fastapi import APIRouter, Depends, HTTPException, Body
from sqlalchemy import and_, select
from sqlalchemy.ext.asyncio import AsyncSession

from backend.database import get_db, Task, Event, WeeklyTaskException, EventException
from backend.models import TaskCreate, EventCreate, ScheduleResponse, ScheduleItem, UpdateRequest
from backend.utils import check_event_overlap, get_weekday_from_date, materialize_weekly_tasks, materialize_events

router = APIRouter()

TZ = pytz.timezone("Europe/Moscow")


@router.get("/schedule", response_model=ScheduleResponse)
async def get_schedule(
    from_date: str,
    to_date: str,
    db: AsyncSession = Depends(get_db)
):
    """Получить расписание в диапазоне дат."""
    try:
        from_dt = datetime.strptime(from_date, "%Y-%m-%d").date()
        to_dt = datetime.strptime(to_date, "%Y-%m-%d").date()
    except ValueError:
        raise HTTPException(status_code=400, detail="Invalid date format. Use YYYY-MM-DD")

    if to_dt < from_dt:
        raise HTTPException(status_code=400, detail="to_date must be greater than or equal to from_date")

    items = []

    result = await db.execute(
        select(Task).where(
            and_(
                Task.date >= from_date,
                Task.date <= to_date,
                Task.repeat_weekly == False
            )
        )
    )
    tasks = result.scalars().all()
    for task in tasks:
        items.append(ScheduleItem(
            kind="task",
            id=task.id,
            date=task.date,
            source_date=task.date,
            title=task.title,
            repeat_weekly=False
        ))

    items.extend(await materialize_weekly_tasks(db, from_date, to_date))
    items.extend(await materialize_events(db, from_date, to_date))

    return ScheduleResponse(items=items)


@router.post("/events")
async def create_item(
    kind: str,
    data: dict = Body(...),
    db: AsyncSession = Depends(get_db)
):
    """Создать task или event."""
    if kind == "task":
        try:
            task = TaskCreate(**data)
        except Exception as exc:
            raise HTTPException(status_code=400, detail=f"Invalid task data: {exc}")

        new_task = Task(
            date=task.date,
            title=task.title,
            repeat_weekly=task.repeat_weekly
        )
        if task.repeat_weekly:
            new_task.weekday = get_weekday_from_date(task.date)

        db.add(new_task)
        await db.commit()
        await db.refresh(new_task)

        if task.copy_to_weekdays and not task.repeat_weekly:
            base_date = datetime.strptime(task.date, "%Y-%m-%d").date()
            base_weekday = base_date.weekday()
            for target_weekday in task.copy_to_weekdays:
                days_diff = target_weekday - base_weekday
                if days_diff <= 0:
                    continue
                target_date = base_date + timedelta(days=days_diff)
                db.add(Task(
                    date=target_date.strftime("%Y-%m-%d"),
                    title=task.title,
                    repeat_weekly=False
                ))
            await db.commit()

        return {"id": new_task.id, "kind": "task"}

    if kind == "event":
        try:
            event = EventCreate(**data)
        except Exception as exc:
            raise HTTPException(status_code=400, detail=f"Invalid event data: {exc}")

        overlap = await check_event_overlap(db, event.date, event.start_time, event.duration_min, None)
        if overlap:
            raise HTTPException(status_code=400, detail="Нельзя добавить: пересечение по времени")

        new_event = Event(
            date=event.date,
            start_time=event.start_time,
            duration_min=event.duration_min,
            title=event.title,
            repeat_weekly=event.repeat_weekly
        )
        if event.repeat_weekly:
            new_event.weekday = get_weekday_from_date(event.date)

        db.add(new_event)
        await db.commit()
        await db.refresh(new_event)

        return {"id": new_event.id, "kind": "event"}

    raise HTTPException(status_code=400, detail="Invalid kind. Use 'task' or 'event'")


@router.put("/events/{item_id}")
async def update_item(
    item_id: int,
    update: UpdateRequest,
    db: AsyncSession = Depends(get_db)
):
    """Обновить task или event."""
    result = await db.execute(select(Task).where(Task.id == item_id))
    task = result.scalar_one_or_none()

    if task:
        if task.repeat_weekly and update.scope == "one_date":
            occurrence_date = update.occurrence_date or task.date
            result = await db.execute(
                select(WeeklyTaskException).where(
                    and_(
                        WeeklyTaskException.task_id == task.id,
                        WeeklyTaskException.date == occurrence_date
                    )
                )
            )
            for existing_exception in result.scalars().all():
                await db.delete(existing_exception)
            exception = WeeklyTaskException(
                task_id=task.id,
                weekday=get_weekday_from_date(occurrence_date),
                date=occurrence_date,
                action="replace",
                replacement_title=update.title or task.title,
                replacement_date=update.date or occurrence_date
            )
            db.add(exception)
            await db.commit()
            return {"success": True, "action": "exception_created"}

        if update.title:
            task.title = update.title
        if update.date:
            task.date = update.date
            if task.repeat_weekly:
                task.weekday = get_weekday_from_date(update.date)

        await db.commit()
        return {"success": True}

    result = await db.execute(select(Event).where(Event.id == item_id))
    event = result.scalar_one_or_none()
    if not event:
        raise HTTPException(status_code=404, detail="Item not found")

    if event.repeat_weekly and update.scope == "one_date":
        occurrence_date = update.occurrence_date or event.date
        replacement_date = update.date or occurrence_date
        replacement_start_time = update.start_time or event.start_time
        replacement_duration = update.duration_min or event.duration_min

        overlap = await check_event_overlap(
            db,
            replacement_date,
            replacement_start_time,
            replacement_duration,
            item_id,
            occurrence_date=occurrence_date
        )
        if overlap:
            raise HTTPException(status_code=400, detail="Нельзя изменить: пересечение по времени")

        result = await db.execute(
            select(EventException).where(
                and_(
                    EventException.event_id == event.id,
                    EventException.date == occurrence_date
                )
            )
        )
        for existing_exception in result.scalars().all():
            await db.delete(existing_exception)

        db.add(EventException(
            event_id=event.id,
            date=occurrence_date,
            action="replace",
            replacement_title=update.title or event.title,
            replacement_date=replacement_date,
            replacement_start_time=replacement_start_time,
            replacement_duration_min=replacement_duration
        ))
        await db.commit()
        return {"success": True, "action": "exception_created"}

    new_date = update.date or event.date
    new_start_time = update.start_time or event.start_time
    new_duration = update.duration_min or event.duration_min

    overlap = await check_event_overlap(db, new_date, new_start_time, new_duration, item_id)
    if overlap:
        raise HTTPException(status_code=400, detail="Нельзя изменить: пересечение по времени")

    if update.title:
        event.title = update.title
    if update.date:
        event.date = update.date
        if event.repeat_weekly:
            event.weekday = get_weekday_from_date(update.date)
    if update.start_time:
        event.start_time = update.start_time
    if update.duration_min:
        event.duration_min = update.duration_min

    await db.commit()
    return {"success": True}


@router.delete("/events/{item_id}")
async def delete_item(
    item_id: int,
    scope: str = None,
    occurrence_date: str = None,
    db: AsyncSession = Depends(get_db)
):
    """Удалить task или event."""
    result = await db.execute(select(Task).where(Task.id == item_id))
    task = result.scalar_one_or_none()

    if task:
        if task.repeat_weekly and scope == "one_date":
            delete_date = occurrence_date or task.date
            result = await db.execute(
                select(WeeklyTaskException).where(
                    and_(
                        WeeklyTaskException.task_id == task.id,
                        WeeklyTaskException.date == delete_date
                    )
                )
            )
            for existing_exception in result.scalars().all():
                await db.delete(existing_exception)
            db.add(WeeklyTaskException(
                task_id=task.id,
                weekday=get_weekday_from_date(delete_date),
                date=delete_date,
                action="delete"
            ))
            await db.commit()
            return {"success": True, "action": "exception_created"}

        if task.repeat_weekly and scope == "series":
            result = await db.execute(select(WeeklyTaskException).where(WeeklyTaskException.task_id == task.id))
            for exception in result.scalars().all():
                await db.delete(exception)

        await db.delete(task)
        await db.commit()
        return {"success": True}

    result = await db.execute(select(Event).where(Event.id == item_id))
    event = result.scalar_one_or_none()
    if not event:
        raise HTTPException(status_code=404, detail="Item not found")

    if event.repeat_weekly and scope == "one_date":
        delete_date = occurrence_date or event.date
        result = await db.execute(
            select(EventException).where(
                and_(
                    EventException.event_id == event.id,
                    EventException.date == delete_date
                )
            )
        )
        for existing_exception in result.scalars().all():
            await db.delete(existing_exception)
        db.add(EventException(
            event_id=event.id,
            date=delete_date,
            action="delete"
        ))
        await db.commit()
        return {"success": True, "action": "exception_created"}

    if event.repeat_weekly and scope == "series":
        result = await db.execute(select(EventException).where(EventException.event_id == event.id))
        for exception in result.scalars().all():
            await db.delete(exception)

    await db.delete(event)
    await db.commit()
    return {"success": True}


@router.get("/backup")
async def backup_database():
    """Создать backup базы данных."""
    import os
    import shutil

    db_path = os.getenv("DATABASE_PATH", "data/schedule.db")
    backup_path = f"{db_path}.backup.{datetime.now().strftime('%Y%m%d_%H%M%S')}"

    if os.path.exists(db_path):
        shutil.copy2(db_path, backup_path)
        return {"success": True, "backup_path": backup_path}
    return {"success": False, "error": "Database not found"}