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, OpeningTransaction, OpeningTransactionUpdate
from account.models import Account
from account.resource import AccountResource

from db import SessionDep
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.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.get("/{account_id}/opening_state")
def read_account_opening_state(account_id: UUID, session: SessionDep, current_user=Depends(get_current_user)) -> OpeningTransaction:
    transaction = AccountResource.get_opening_transaction(session, account_id)
    if not transaction:
        raise HTTPException(status_code=404, detail="Account not found")
    return transaction

@router.put("/{account_id}/opening_state")
def update_account_opening_state(account_id: UUID, opening_transaction: OpeningTransactionUpdate, session: SessionDep, current_user=Depends(get_current_user)) -> OpeningTransaction:
    account = AccountResource.get(session, account_id)
    if not account:
        raise HTTPException(status_code=404, detail="Account not found")

    transaction = AccountResource.update_opening_transaction(session, account, opening_transaction)
    return transaction

@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}