import uuid
from datetime import date

from fastapi import HTTPException, status
from sqlalchemy import func, select
from sqlalchemy.ext.asyncio import AsyncSession
from sqlalchemy.orm import selectinload

from app.models.transaction import Transaction, TransactionType
from app.schemas.transaction import TransactionCreate, TransactionUpdate
from app.utils import utcnow


def _month_bounds(month: str) -> tuple[date, date]:
    """Return (start_inclusive, end_exclusive) date bounds for a YYYY-MM string."""
    year, mon = map(int, month.split("-"))
    start = date(year, mon, 1)
    if mon == 12:
        end = date(year + 1, 1, 1)
    else:
        end = date(year, mon + 1, 1)
    return start, end


async def create_transaction(
    session: AsyncSession,
    user_id: uuid.UUID,
    data: TransactionCreate,
) -> Transaction:
    tx = Transaction(
        user_id=user_id,
        category_id=data.category_id,
        amount_cents=data.amount_cents,
        type=data.type,
        description=data.description,
        transaction_date=data.transaction_date,
    )
    session.add(tx)
    await session.commit()

    # Reload with category relationship
    result = await session.execute(
        select(Transaction)
        .options(selectinload(Transaction.category))
        .where(Transaction.id == tx.id)
    )
    return result.scalar_one()


async def list_transactions(
    session: AsyncSession,
    user_id: uuid.UUID,
    *,
    month: str | None = None,
    category_id: uuid.UUID | None = None,
    type_filter: TransactionType | None = None,
    page: int = 1,
    per_page: int = 20,
) -> tuple[list[Transaction], int]:
    base_query = select(Transaction).where(
        Transaction.user_id == user_id,
        Transaction.deleted_at.is_(None),
    )

    if month is not None:
        start, end = _month_bounds(month)
        base_query = base_query.where(
            Transaction.transaction_date >= start,
            Transaction.transaction_date < end,
        )
    if category_id is not None:
        base_query = base_query.where(Transaction.category_id == category_id)
    if type_filter is not None:
        base_query = base_query.where(Transaction.type == type_filter)

    # Total count (before pagination)
    count_result = await session.execute(
        select(func.count()).select_from(base_query.subquery())
    )
    total = count_result.scalar_one()

    # Paginated rows with category eager-loaded
    items_query = (
        base_query.options(selectinload(Transaction.category))
        .order_by(Transaction.transaction_date.desc(), Transaction.created_at.desc())
        .offset((page - 1) * per_page)
        .limit(per_page)
    )
    result = await session.execute(items_query)
    return list(result.scalars().all()), total


async def get_transaction(
    session: AsyncSession,
    user_id: uuid.UUID,
    transaction_id: uuid.UUID,
) -> Transaction:
    result = await session.execute(
        select(Transaction)
        .options(selectinload(Transaction.category))
        .where(
            Transaction.id == transaction_id,
            Transaction.user_id == user_id,
            Transaction.deleted_at.is_(None),
        )
    )
    tx = result.scalar_one_or_none()
    if tx is None:
        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Transaction not found")
    return tx


async def update_transaction(
    session: AsyncSession,
    user_id: uuid.UUID,
    transaction_id: uuid.UUID,
    data: TransactionUpdate,
) -> Transaction:
    tx = await get_transaction(session, user_id, transaction_id)

    if data.amount_cents is not None:
        tx.amount_cents = data.amount_cents
    if data.type is not None:
        tx.type = data.type
    if data.category_id is not None:
        tx.category_id = data.category_id
    if data.description is not None:
        tx.description = data.description
    if data.transaction_date is not None:
        tx.transaction_date = data.transaction_date
    tx.updated_at = utcnow()

    await session.commit()

    # Reload with fresh category
    result = await session.execute(
        select(Transaction)
        .options(selectinload(Transaction.category))
        .where(Transaction.id == tx.id)
    )
    return result.scalar_one()


async def delete_transaction(
    session: AsyncSession,
    user_id: uuid.UUID,
    transaction_id: uuid.UUID,
) -> None:
    tx = await get_transaction(session, user_id, transaction_id)
    tx.deleted_at = utcnow()
    tx.updated_at = utcnow()
    await session.commit()