from fastapi import APIRouter, Depends, HTTPException
from pydantic import BaseModel, Field
from typing import Optional
from dataclasses import asdict
from sqlalchemy.orm import Session
from app.database import get_db
from app.models.miner import Miner
from app.services.openrouter import get_ai_recommendation
from app.services import coingecko, mining_calculator

router = APIRouter(prefix="/ai", tags=["AI"])


class RecommendRequest(BaseModel):
    coin: str = Field(..., description="Coin to mine")
    electricity_price_sar: float = Field(..., gt=0)
    budget_sar: Optional[float] = Field(None, gt=0, description="Optional budget in SAR")
    miner_type: Optional[str] = Field(None, description="ASIC or GPU preference")


@router.post("/recommend")
async def ai_recommend(req: RecommendRequest, db: Session = Depends(get_db)):
    """Get AI-powered miner recommendation with profitability analysis."""

    query = db.query(Miner).filter(
        Miner.supported_coins.ilike(f"%{req.coin.upper()}%")
    )
    if req.miner_type:
        query = query.filter(Miner.type == req.miner_type.upper())

    miners = query.order_by(Miner.hashrate.desc()).limit(15).all()

    if not miners:
        raise HTTPException(
            status_code=404,
            detail=f"No miners found that support {req.coin}",
        )

    coin_price = await coingecko.get_coin_price(req.coin)
    mining_params = coingecko.get_mining_params(req.coin)

    # Build miner summaries with profitability
    miner_summaries = []
    for m in miners:
        result = mining_calculator.calculate_mining_profit(
            hashrate_ths=m.hashrate,
            power_w=m.power_consumption,
            electricity_sar_per_kwh=req.electricity_price_sar,
            coin_price_usd=coin_price,
            block_reward=mining_params["block_reward"],
            block_time_seconds=mining_params["block_time"],
            difficulty=mining_params["difficulty"],
            network_hashrate_ths=mining_params["network_hashrate"],
            miner_name=m.name,
            coin=req.coin.upper(),
        )
        miner_summaries.append({
            "id": m.id,
            "name": m.name,
            "brand": m.brand,
            "type": m.type,
            "hashrate_ths": m.hashrate,
            "power_w": m.power_consumption,
            "efficiency": m.efficiency,
            "monthly_profit_usd": result.monthly_profit_usd,
            "monthly_profit_sar": result.monthly_profit_sar,
            "monthly_electricity_cost_sar": result.monthly_electricity_cost_sar,
            "is_profitable": result.daily_profit_usd > 0,
        })

    ai_response = await get_ai_recommendation(
        coin=req.coin,
        electricity_price=req.electricity_price_sar,
        budget=req.budget_sar,
        miners=miner_summaries,
    )

    # Find top profitable miner from our own calculation
    profitable = [m for m in miner_summaries if m["is_profitable"]]
    best = max(profitable, key=lambda x: x["monthly_profit_usd"]) if profitable else None

    return {
        "coin": req.coin.upper(),
        "coin_price_usd": coin_price,
        "electricity_price_sar": req.electricity_price_sar,
        "ai_recommendation": ai_response,
        "calculated_best": best,
        "miners_analyzed": len(miner_summaries),
        "profitable_count": len(profitable),
        "all_miners": miner_summaries[:10],
    }