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.market import EquityCandlesResponse, MarketBatchUpdateResponse, MarketChartResponse, MarketQuoteResponse, MarketStatusResponse, QuoteRefreshRequest
from jarvis_finance.services.market_service import (
    get_crypto_chart,
    get_crypto_quote,
    get_equity_candles,
    get_equity_chart,
    get_equity_quote,
    get_market_status,
    refresh_crypto_quote,
    refresh_crypto_quotes_batch,
    refresh_equity_fx,
    refresh_equity_quote,
    refresh_equity_quotes_batch,
)

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


@router.get("/market/status", response_model=MarketStatusResponse)
def market_status(conn: Connection = Depends(get_db)) -> MarketStatusResponse:
    return get_market_status(conn)


@router.post("/market/equity/update-quotes", response_model=MarketQuoteResponse | MarketBatchUpdateResponse)
def market_equity_update_quote(request: QuoteRefreshRequest, instrument_id: str | None = Query(default=None), conn: Connection = Depends(get_db)) -> MarketQuoteResponse | MarketBatchUpdateResponse:
    if instrument_id:
        return refresh_equity_quote(conn, instrument_id, request)
    return refresh_equity_quotes_batch(conn, request)


@router.post("/market/equity/update-quotes/dry-run", response_model=MarketBatchUpdateResponse)
def market_equity_update_quotes_dry_run(request: QuoteRefreshRequest, conn: Connection = Depends(get_db)) -> MarketBatchUpdateResponse:
    """Call every eligible provider without persisting quotes or valuations."""
    return refresh_equity_quotes_batch(conn, request.model_copy(update={"dry_run": True, "only_missing": False}))


@router.post("/market/equity/update-fx")
def market_equity_update_fx(instrument_id: str, conn: Connection = Depends(get_db)) -> dict[str, object]:
    return refresh_equity_fx(conn, instrument_id)


@router.post("/market/crypto/update-live-stats", response_model=MarketQuoteResponse | MarketBatchUpdateResponse)
def market_crypto_update_live_stats(request: QuoteRefreshRequest, asset_id: str | None = Query(default=None), conn: Connection = Depends(get_db)) -> MarketQuoteResponse | MarketBatchUpdateResponse:
    if asset_id:
        return refresh_crypto_quote(conn, asset_id, request)
    return refresh_crypto_quotes_batch(conn, request)


@router.get("/equity/{instrument_id}/quote", response_model=MarketQuoteResponse)
def equity_quote(instrument_id: str, conn: Connection = Depends(get_db)) -> MarketQuoteResponse:
    return get_equity_quote(conn, instrument_id)


@router.get("/equity/{instrument_id}/chart", response_model=MarketChartResponse)
def equity_chart(instrument_id: str, range: str = "1d", interval: str = "5m", conn: Connection = Depends(get_db)) -> MarketChartResponse:
    return get_equity_chart(conn, instrument_id, range=range, interval=interval)


@router.get("/equity/{instrument_id}/candles", response_model=EquityCandlesResponse)
def equity_candles(instrument_id: str, range: str = "1d", interval: str = "5m", refresh: bool = False, conn: Connection = Depends(get_db)) -> EquityCandlesResponse:
    return get_equity_candles(conn, instrument_id, range=range, interval=interval, refresh=refresh)


@router.get("/crypto/{asset_id}/live-stats", response_model=MarketQuoteResponse)
def crypto_live_stats(asset_id: str, currency: str = "CHF", conn: Connection = Depends(get_db)) -> MarketQuoteResponse:
    return get_crypto_quote(conn, asset_id, currency=currency)


@router.get("/crypto/{asset_id}/chart", response_model=MarketChartResponse)
def crypto_chart(asset_id: str, range: str = "1d", interval: str = "5m", currency: str = "CHF", conn: Connection = Depends(get_db)) -> MarketChartResponse:
    return get_crypto_chart(conn, asset_id, range=range, interval=interval, currency=currency)