import asyncio
import logging
from datetime import datetime, timedelta
from typing import Any

from openbb import obb

logger = logging.getLogger(__name__)

PROVIDER = "yfinance"


def _to_dicts(result: Any) -> list[dict[str, Any]]:
    """Convert OBBject results to list of dicts."""
    if result is None or result.results is None:
        return []
    if isinstance(result.results, list):
        return [
            item.model_dump() if hasattr(item, "model_dump") else vars(item)
            for item in result.results
        ]
    if hasattr(result.results, "model_dump"):
        return [result.results.model_dump()]
    return [vars(result.results)]


def _first_or_empty(result: Any) -> dict[str, Any]:
    """Get first result as dict, or empty dict."""
    items = _to_dicts(result)
    return items[0] if items else {}


async def get_quote(symbol: str) -> dict:
    result = await asyncio.to_thread(
        obb.equity.price.quote, symbol, provider=PROVIDER
    )
    return _first_or_empty(result)


async def get_historical(symbol: str, days: int = 365) -> list[dict]:
    start = (datetime.now() - timedelta(days=days)).strftime("%Y-%m-%d")
    result = await asyncio.to_thread(
        obb.equity.price.historical,
        symbol,
        start_date=start,
        provider=PROVIDER,
    )
    items = _to_dicts(result)
    return [
        {**item, "date": str(item["date"])}
        if "date" in item and not isinstance(item["date"], str)
        else item
        for item in items
    ]


async def get_profile(symbol: str) -> dict:
    result = await asyncio.to_thread(
        obb.equity.profile, symbol, provider=PROVIDER
    )
    return _first_or_empty(result)


async def get_metrics(symbol: str) -> dict:
    result = await asyncio.to_thread(
        obb.equity.fundamental.metrics, symbol, provider=PROVIDER
    )
    return _first_or_empty(result)


async def get_income(symbol: str) -> list[dict]:
    result = await asyncio.to_thread(
        obb.equity.fundamental.income, symbol, provider=PROVIDER
    )
    return _to_dicts(result)


async def get_balance(symbol: str) -> list[dict]:
    result = await asyncio.to_thread(
        obb.equity.fundamental.balance, symbol, provider=PROVIDER
    )
    return _to_dicts(result)


async def get_cash_flow(symbol: str) -> list[dict]:
    result = await asyncio.to_thread(
        obb.equity.fundamental.cash, symbol, provider=PROVIDER
    )
    return _to_dicts(result)


async def get_financials(symbol: str) -> dict:
    income, balance, cash_flow = await asyncio.gather(
        get_income(symbol),
        get_balance(symbol),
        get_cash_flow(symbol),
    )
    return {
        "symbol": symbol,
        "income": income,
        "balance": balance,
        "cash_flow": cash_flow,
    }


async def get_price_target(symbol: str) -> float | None:
    """Get consensus analyst price target via yfinance."""
    import yfinance as yf

    def _fetch() -> float | None:
        t = yf.Ticker(symbol)
        return t.info.get("targetMeanPrice")

    try:
        return await asyncio.to_thread(_fetch)
    except Exception:
        logger.warning("Failed to get price target for %s", symbol, exc_info=True)
    return None


async def get_news(symbol: str) -> list[dict]:
    result = await asyncio.to_thread(
        obb.news.company, symbol, provider=PROVIDER
    )
    return _to_dicts(result)


async def get_summary(symbol: str) -> dict:
    quote, profile, metrics, financials = await asyncio.gather(
        get_quote(symbol),
        get_profile(symbol),
        get_metrics(symbol),
        get_financials(symbol),
    )
    return {
        "quote": quote,
        "profile": profile,
        "metrics": metrics,
        "financials": financials,
    }


async def get_gainers() -> list[dict]:
    result = await asyncio.to_thread(
        obb.equity.discovery.gainers, provider=PROVIDER
    )
    return _to_dicts(result)


async def get_losers() -> list[dict]:
    result = await asyncio.to_thread(
        obb.equity.discovery.losers, provider=PROVIDER
    )
    return _to_dicts(result)


async def get_active() -> list[dict]:
    result = await asyncio.to_thread(
        obb.equity.discovery.active, provider=PROVIDER
    )
    return _to_dicts(result)


async def get_undervalued() -> list[dict]:
    result = await asyncio.to_thread(
        obb.equity.discovery.undervalued_large_caps, provider=PROVIDER
    )
    return _to_dicts(result)


async def get_growth() -> list[dict]:
    result = await asyncio.to_thread(
        obb.equity.discovery.growth_tech, provider=PROVIDER
    )
    return _to_dicts(result)


async def get_upgrades_downgrades(symbol: str, limit: int = 20) -> list[dict]:
    """Get analyst upgrades/downgrades via yfinance."""
    import yfinance as yf

    def _fetch() -> list[dict[str, Any]]:
        t = yf.Ticker(symbol)
        df = t.upgrades_downgrades
        if df is None or df.empty:
            return []
        df = df.head(limit).reset_index()
        return [
            {
                "date": str(row.get("GradeDate", "")),
                "company": row.get("Firm"),
                "action": row.get("Action"),
                "from_grade": row.get("FromGrade"),
                "to_grade": row.get("ToGrade"),
                "price_target_action": row.get("priceTargetAction"),
                "current_price_target": row.get("currentPriceTarget"),
                "prior_price_target": row.get("priorPriceTarget"),
            }
            for _, row in df.iterrows()
        ]

    return await asyncio.to_thread(_fetch)