"""GET /v1/assets — service-token authenticated asset list endpoint."""

from __future__ import annotations

import json
import logging

from fastapi import APIRouter, Depends, HTTPException, Query, status

from app.core.auth import AuthContext, require_read
from app.repositories.factory import get_portfolio_repository_from_settings
from app.repositories.portfolio_repository import PortfolioRepository
from app.schemas.v1 import AssetItem, AssetsResponse

logger = logging.getLogger(__name__)
router = APIRouter(prefix="/v1", tags=["v1"])


def _require_service_token(auth: AuthContext = Depends(require_read)) -> AuthContext:
    if auth.token_source != "db" or auth.token_type != "service":
        raise HTTPException(
            status_code=status.HTTP_403_FORBIDDEN,
            detail="Service token required",
        )
    return auth


def _parse_strategy_params(strategy_set_config: str | None) -> dict:
    if not strategy_set_config:
        return {}
    try:
        parsed = json.loads(strategy_set_config)
        return parsed if isinstance(parsed, dict) else {}
    except (json.JSONDecodeError, TypeError):
        return {}


@router.get("/assets", response_model=AssetsResponse)
def list_assets(
    status_filter: str | None = Query(default=None, alias="status"),
    auth: AuthContext = Depends(_require_service_token),
) -> AssetsResponse:
    from app.core.config import get_settings

    settings = get_settings()
    repo = get_portfolio_repository_from_settings(settings)
    try:
        portfolios = repo.list_portfolios_with_strategies(
            owner_user_id=None,
            include_disabled=False,
        )

        # Fetch strategy_params per portfolio
        items = []
        for p in portfolios:
            # Optional status filter
            if status_filter is not None and p.status != status_filter:
                continue

            strategy_params: dict = {}
            strategy_type: str | None = None
            if p.active_strategy_id:
                try:
                    ss = repo.get_strategy_set(p.active_strategy_id)
                    if ss is not None:
                        strategy_params = _parse_strategy_params(ss.config)
                        strategy_type = ss.name
                except Exception:
                    logger.warning("strategy_set lookup failed for %s", p.active_strategy_id)
                    strategy_params = {}

            items.append(
                AssetItem(
                    asset_id=p.portfolio_id,
                    symbol=p.symbol,
                    market=p.market,
                    status=p.status,
                    cash=p.cash_balance,
                    quantity=p.asset_quantity,
                    broker_type=p.broker,
                    strategy_id=p.active_strategy_id,
                    strategy_type=strategy_type,
                    strategy_params=strategy_params,
                    updated_at=p.updated_at,
                    name=p.name,
                    price=p.price,
                    profit_buffer=p.profit_buffer,
                    tags=p.tags,
                    owner_user_id=p.owner_user_id,
                    created_at=p.created_at,
                    last_trade_at=p.last_trade_at,
                )
            )
    finally:
        if callable(getattr(type(repo), "close", None)):
            repo.close()

    return AssetsResponse(assets=items, total=len(items))