from typing import Optional
from uuid import UUID

from fastapi import APIRouter, HTTPException, Depends
from fastapi_filter import FilterDepends
from fastapi_filter.contrib.sqlalchemy import Filter
from fastapi_pagination import Page
from fastapi_pagination.ext.sqlmodel import paginate

from account.schemas import AccountCreate, AccountRead, AccountUpdate
from account.models import Account
from account.resource import AccountResource

from db import SessionDep
from transaction.models import TransactionRead
from transaction.resource import TransactionResource
from user.manager import get_current_user


class AccountFilters(Filter):
    name__like: Optional[str] = None
    order_by: Optional[list[str]] = None

    class Constants(Filter.Constants):
        model = Account
        search_model_fields = ["name"]

router = APIRouter()

@router.post("")
def create_account(account: AccountCreate, session: SessionDep, current_user=Depends(get_current_user)) -> AccountRead:
    result = AccountResource.create(account, session)
    return result

@router.get("")
def read_accounts(session: SessionDep,
                    filters: AccountFilters = FilterDepends(AccountFilters),
                    current_user=Depends(get_current_user)) -> Page[AccountRead]:
    return paginate(session, AccountResource.list_accounts(filters))

@router.get("/assets")
def read_assets(session: SessionDep,
                    filters: AccountFilters = FilterDepends(AccountFilters),
                    current_user=Depends(get_current_user)) -> Page[AccountRead]:
    return paginate(session, AccountResource.list_assets(filters))

@router.get("/liabilities")
def read_liabilities(session: SessionDep, 
                    filters: AccountFilters = FilterDepends(AccountFilters),
                    current_user=Depends(get_current_user)) -> Page[AccountRead]:
    return paginate(session, AccountResource.list_liabilities(filters))

@router.get("/{account_id}")
def read_account(account_id: UUID, session: SessionDep, current_user=Depends(get_current_user)) -> AccountRead:
    account = AccountResource.get(session, account_id)
    if not account:
        raise HTTPException(status_code=404, detail="Account not found")
    return account

@router.get("/{account_id}/opening_state")
def read_account_opening_state(account_id: UUID, session: SessionDep, current_user=Depends(get_current_user)) -> TransactionRead:
    transaction = TransactionResource.get_opening_transaction(session, account_id)
    if not transaction:
        raise HTTPException(status_code=404, detail="Account not found")
    return transaction

@router.put("/{account_id}")
def update_account(account_id: UUID, account: AccountUpdate, session: SessionDep, current_user=Depends(get_current_user)) -> AccountRead:
    db_account = AccountResource.get(session, account_id)
    if not db_account:
        raise HTTPException(status_code=404, detail="Account not found")

    account_data = account.model_dump(exclude_unset=True)
    account = AccountResource.update(session, db_account, account_data)
    return account

@router.delete("/{account_id}")
def delete_account(account_id: UUID, session: SessionDep, current_user=Depends(get_current_user)):
    account = AccountResource.get(session, account_id)
    if not account:
        raise HTTPException(status_code=404, detail="Account not found")

    AccountResource.delete(session, account)
    return {"ok": True}