"""Portfolio service orchestration."""

from __future__ import annotations

import json

from fastapi import Depends

from app.core.config import Settings, get_settings
from app.domain.models import LedgerEntry, Portfolio, StrategySet
from app.domain.services import (
    apply_buy,
    apply_delete,
    apply_invest,
    apply_reset,
    apply_sell,
    apply_transfer,
    get_portfolio_status,
)
from app.repositories.factory import get_portfolio_repository_from_settings
from app.repositories.portfolio_repository import PortfolioRepository
from app.schemas.portfolio import (
    BuyRequest,
    CreatePortfolioRequest,
    InvestRequest,
    PortfolioDetailResponse,
    PortfolioListItem,
    ResetPortfolioRequest,
    SellRequest,
    TransferRequest,
    UpdatePortfolioRequest,
)


def _infer_symbol(portfolio_id: str) -> str:
    parts = [part.strip() for part in portfolio_id.split(":") if part.strip()]
    return parts[0] if parts else ""


def _to_portfolio_summary(portfolio: Portfolio):
    from app.schemas.portfolio import PortfolioSummary

    return PortfolioSummary(
        portfolio_id=portfolio.portfolio_id,
        broker=portfolio.broker,
        status=portfolio.status,
        symbol=portfolio.symbol,
        strategy_name=portfolio.strategy_name,
        strategy_params=portfolio.strategy_params,
        cash_balance=portfolio.cash_balance,
        asset_quantity=portfolio.asset_quantity,
        price=portfolio.price,
        profit_buffer=portfolio.profit_buffer,
        current_strategy_set_id=portfolio.current_strategy_set_id,
        created_at=portfolio.created_at,
        updated_at=portfolio.updated_at,
        last_trade_at=portfolio.last_trade_at,
    )


def _to_strategy_set_response(strategy_set: StrategySet | None):
    from app.schemas.portfolio import StrategySetResponse

    if strategy_set is None:
        return None
    return StrategySetResponse(
        id=strategy_set.id,
        strategy_name=strategy_set.strategy_name,
        strategy_config=strategy_set.strategy_config,
        created_at=strategy_set.created_at,
    )


def _to_ledger_entry_response(entry: LedgerEntry):
    from app.schemas.portfolio import LedgerEntryResponse

    return LedgerEntryResponse(
        portfolio_id=entry.portfolio_id,
        recorded_at=entry.recorded_at,
        action=entry.action,
        price=entry.price,
        quantity=entry.quantity,
        fee_amount=entry.fee_amount,
        tax_amount=entry.tax_amount,
        cash_balance_after=entry.cash_balance_after,
        asset_quantity_after=entry.asset_quantity_after,
        total_value_after=entry.total_value_after,
        profit_buffer_after=entry.profit_buffer_after,
        strategy_set_id=entry.strategy_set_id,
        note=entry.note,
    )


def _to_detail_response(status_result) -> PortfolioDetailResponse:
    return PortfolioDetailResponse(
        portfolio=_to_portfolio_summary(status_result.portfolio),
        recent_entries=[_to_ledger_entry_response(entry) for entry in status_result.recent_entries],
        strategy_set=_to_strategy_set_response(status_result.strategy_set),
        live_quantity=status_result.live_quantity,
    )


def get_portfolio_repository(settings: Settings = Depends(get_settings)) -> PortfolioRepository:
    return get_portfolio_repository_from_settings(settings)


class PortfolioService:
    def __init__(self, repository: PortfolioRepository) -> None:
        self._repository = repository

    def list_portfolios(self, *, broker: str | None = None, status: str | None = None) -> list[PortfolioListItem]:
        portfolios = self._repository.list_portfolios(broker=broker, status=status)
        return [
            PortfolioListItem(
                **_to_portfolio_summary(portfolio).model_dump(),
                total_value=float(portfolio.cash_balance) + float(portfolio.asset_quantity) * float(portfolio.price),
            )
            for portfolio in portfolios
        ]

    def get_portfolio_status(self, *, portfolio_id: str, recent_trades: int = 5) -> PortfolioDetailResponse:
        status_result = get_portfolio_status(self._repository, portfolio_id, recent_trades=recent_trades)
        return _to_detail_response(status_result)

    def create_portfolio(self, payload: CreatePortfolioRequest) -> PortfolioDetailResponse:
        strategy_set = self._repository.get_or_create_strategy_set(
            payload.strategy_name,
            json.dumps(payload.strategy_params, sort_keys=True, ensure_ascii=True),
        )
        portfolio = self._repository.create_portfolio(
            payload.portfolio_id,
            broker=payload.broker,
            status=payload.status,
            symbol=payload.symbol,
            strategy_name=payload.strategy_name,
            strategy_params=payload.strategy_params,
            cash_balance=payload.cash_balance,
            asset_quantity=payload.asset_quantity,
            asset_price=payload.asset_price,
            profit_buffer=payload.profit_buffer,
        )
        portfolio = self._repository.update_portfolio(
            payload.portfolio_id,
            current_strategy_set_id=strategy_set.id,
        )
        return self.get_portfolio_status(portfolio_id=portfolio.portfolio_id, recent_trades=5)

    def update_portfolio(self, portfolio_id: str, payload: UpdatePortfolioRequest) -> PortfolioDetailResponse:
        fields = payload.model_dump(exclude_none=True)
        if "strategy_name" in fields or "strategy_params" in fields:
            current = self._repository.get(portfolio_id)
            strategy_name = fields.get("strategy_name", current.strategy_name)
            strategy_params = fields.get("strategy_params", current.strategy_params)
            strategy_set = self._repository.get_or_create_strategy_set(
                strategy_name,
                json.dumps(strategy_params, sort_keys=True, ensure_ascii=True),
            )
            fields["current_strategy_set_id"] = strategy_set.id
        self._repository.update_portfolio(portfolio_id, **fields)
        return self.get_portfolio_status(portfolio_id=portfolio_id, recent_trades=5)

    def buy(self, portfolio_id: str, payload: BuyRequest) -> PortfolioDetailResponse:
        apply_buy(
            self._repository,
            portfolio_id,
            quantity=payload.quantity,
            price=payload.price,
            fee=payload.fee,
            tax=payload.tax,
            note=payload.note,
        )
        return self.get_portfolio_status(portfolio_id=portfolio_id, recent_trades=5)

    def sell(self, portfolio_id: str, payload: SellRequest) -> PortfolioDetailResponse:
        apply_sell(
            self._repository,
            portfolio_id,
            quantity=payload.quantity,
            price=payload.price,
            fee=payload.fee,
            tax=payload.tax,
            note=payload.note,
        )
        return self.get_portfolio_status(portfolio_id=portfolio_id, recent_trades=5)

    def invest(self, portfolio_id: str, payload: InvestRequest) -> PortfolioDetailResponse:
        apply_invest(
            self._repository,
            portfolio_id,
            movement_type=payload.movement_type,
            amount=payload.amount,
            note=payload.note,
        )
        return self.get_portfolio_status(portfolio_id=portfolio_id, recent_trades=5)

    def transfer(self, portfolio_id: str, payload: TransferRequest) -> PortfolioDetailResponse:
        apply_transfer(
            self._repository,
            portfolio_id,
            direction=payload.direction,
            amount=payload.amount,
            note=payload.note,
        )
        return self.get_portfolio_status(portfolio_id=portfolio_id, recent_trades=5)

    def reset(self, portfolio_id: str, payload: ResetPortfolioRequest) -> PortfolioDetailResponse:
        infer_symbol = payload.infer_symbol or _infer_symbol(portfolio_id)
        apply_reset(self._repository, portfolio_id, infer_symbol=lambda _: infer_symbol)
        return self.get_portfolio_status(portfolio_id=portfolio_id, recent_trades=5)

    def delete(self, portfolio_id: str, *, keep_ledger: bool = False) -> None:
        apply_delete(self._repository, portfolio_id, clear_ledger=not keep_ledger)


def get_portfolio_service(
    repository: PortfolioRepository = Depends(get_portfolio_repository),
) -> PortfolioService:
    return PortfolioService(repository)