from __future__ import annotations

from sqlite3 import Connection

from fastapi import APIRouter, Depends, Query

from jarvis_finance.api.dependencies import get_db
from jarvis_finance.api.schemas.positions import (
    AccountValueConfirmRequest,
    AccountValuePreviewRequest,
    AuditEntry,
    CleanupPreviewResponse,
    ConfirmResponse,
    ContainerConfirmRequest,
    ContainerPreviewRequest,
    GenericConfirmRequest,
    InstrumentSearchCandidate,
    InstrumentSearchRequest,
    PositionConfirmRequest,
    PositionPreviewRequest,
    PreviewResponse,
    PricePoint,
    ProviderSearchResponse,
    ReferenceAccount,
    RemovePositionPreviewResponse,
)
from jarvis_finance.services.manual_entry_service import (
    cleanup_review_artifacts_confirm,
    cleanup_review_artifacts_preview,
    confirm_account,
    confirm_account_value,
    confirm_deactivate_account,
    confirm_delete_wallet,
    confirm_position,
    confirm_remove_position,
    confirm_wallet,
    get_equity_position_detail,
    list_audit,
    list_reference_accounts,
    market_price_history,
    preview_account,
    preview_account_value,
    preview_position,
    preview_remove_position,
    preview_wallet,
    provider_search_instruments,
    search_instruments,
)

router = APIRouter(tags=["positions"])


@router.get("/reference/accounts", response_model=list[ReferenceAccount])
def reference_accounts(conn: Connection = Depends(get_db)) -> list[ReferenceAccount]:
    return list_reference_accounts(conn)


@router.post("/instruments/search", response_model=list[InstrumentSearchCandidate])
def instruments_search(request: InstrumentSearchRequest, conn: Connection = Depends(get_db)) -> list[InstrumentSearchCandidate]:
    return search_instruments(conn, request)


@router.post("/positions/preview", response_model=PreviewResponse)
def positions_preview(request: PositionPreviewRequest, conn: Connection = Depends(get_db)) -> PreviewResponse:
    return preview_position(conn, request)


@router.post("/positions/confirm", response_model=ConfirmResponse)
def positions_confirm(request: PositionConfirmRequest, conn: Connection = Depends(get_db)) -> ConfirmResponse:
    return confirm_position(conn, request)


@router.get("/portfolio/positions/{position_id}")
def portfolio_position_detail(position_id: str, conn: Connection = Depends(get_db)):
    return get_equity_position_detail(conn, position_id)


@router.get("/market/prices/{instrument_id}/history", response_model=list[PricePoint])
def market_history(instrument_id: str, conn: Connection = Depends(get_db)) -> list[PricePoint]:
    return market_price_history(conn, instrument_id)


@router.get("/audit", response_model=list[AuditEntry])
def audit_entries(entity_type: str | None = Query(default=None), entity_id: str | None = Query(default=None), conn: Connection = Depends(get_db)) -> list[AuditEntry]:
    return list_audit(conn, entity_type, entity_id)


@router.post("/instruments/provider-search", response_model=ProviderSearchResponse)
def instruments_provider_search(request: InstrumentSearchRequest, conn: Connection = Depends(get_db)) -> ProviderSearchResponse:
    return provider_search_instruments(conn, request)


@router.post("/cleanup/review-artifacts/preview", response_model=CleanupPreviewResponse)
def cleanup_review_artifacts_preview_route(conn: Connection = Depends(get_db)) -> CleanupPreviewResponse:
    return cleanup_review_artifacts_preview(conn)


@router.post("/cleanup/review-artifacts/confirm", response_model=ConfirmResponse)
def cleanup_review_artifacts_confirm_route(request: GenericConfirmRequest, conn: Connection = Depends(get_db)) -> ConfirmResponse:
    return cleanup_review_artifacts_confirm(conn, request)


@router.post("/positions/{position_id}/remove/preview", response_model=RemovePositionPreviewResponse)
def position_remove_preview(position_id: str, conn: Connection = Depends(get_db)) -> RemovePositionPreviewResponse:
    return preview_remove_position(conn, position_id)


@router.post("/positions/{position_id}/remove/confirm", response_model=ConfirmResponse)
def position_remove_confirm(position_id: str, request: GenericConfirmRequest, conn: Connection = Depends(get_db)) -> ConfirmResponse:
    return confirm_remove_position(conn, position_id, request)


@router.post("/wallets/preview", response_model=PreviewResponse)
def wallets_preview(request: ContainerPreviewRequest, conn: Connection = Depends(get_db)) -> PreviewResponse:
    return preview_wallet(conn, request)


@router.post("/wallets/confirm", response_model=ConfirmResponse)
def wallets_confirm(request: ContainerConfirmRequest, conn: Connection = Depends(get_db)) -> ConfirmResponse:
    return confirm_wallet(conn, request)


@router.post("/wallets/{wallet_id}/delete/confirm", response_model=ConfirmResponse)
def wallets_delete_confirm(wallet_id: str, request: GenericConfirmRequest, conn: Connection = Depends(get_db)) -> ConfirmResponse:
    return confirm_delete_wallet(conn, wallet_id, request)


@router.post("/accounts/preview", response_model=PreviewResponse)
def accounts_preview(request: ContainerPreviewRequest, conn: Connection = Depends(get_db)) -> PreviewResponse:
    return preview_account(conn, request)


@router.post("/accounts/confirm", response_model=ConfirmResponse)
def accounts_confirm(request: ContainerConfirmRequest, conn: Connection = Depends(get_db)) -> ConfirmResponse:
    return confirm_account(conn, request)


@router.post("/accounts/{account_id}/value/preview", response_model=PreviewResponse)
def account_value_preview(account_id: str, request: AccountValuePreviewRequest, conn: Connection = Depends(get_db)) -> PreviewResponse:
    return preview_account_value(conn, account_id, request)


@router.post("/accounts/{account_id}/value/confirm", response_model=ConfirmResponse)
def account_value_confirm(account_id: str, request: AccountValueConfirmRequest, conn: Connection = Depends(get_db)) -> ConfirmResponse:
    return confirm_account_value(conn, account_id, request)


@router.post("/accounts/{account_id}/deactivate/confirm", response_model=ConfirmResponse)
def accounts_deactivate_confirm(account_id: str, request: GenericConfirmRequest, conn: Connection = Depends(get_db)) -> ConfirmResponse:
    return confirm_deactivate_account(conn, account_id, request)