from fastapi import APIRouter, Depends, Query, HTTPException
from sqlalchemy.orm import Session
from sqlalchemy import or_
from pydantic import BaseModel
from typing import Optional
from app.database import get_db
from app.models.miner import Miner

router = APIRouter(prefix="/miners", tags=["Miners"])


class MinerResponse(BaseModel):
    id: int
    name: str
    brand: str
    type: str
    hashrate: float
    hashrate_unit: str
    power_consumption: int
    efficiency: Optional[float]
    supported_coins: Optional[str]

    class Config:
        from_attributes = True


@router.get("/", response_model=list[MinerResponse])
async def list_miners(
    search: Optional[str] = Query(None, description="Search by name or brand"),
    miner_type: Optional[str] = Query(None, description="Filter: ASIC or GPU"),
    coin: Optional[str] = Query(None, description="Filter by supported coin"),
    page: int = Query(1, ge=1),
    limit: int = Query(50, ge=1, le=200),
    db: Session = Depends(get_db),
):
    query = db.query(Miner)

    if search:
        term = f"%{search.lower()}%"
        query = query.filter(
            or_(Miner.name.ilike(term), Miner.brand.ilike(term))
        )

    if miner_type:
        query = query.filter(Miner.type == miner_type.upper())

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

    query = query.order_by(Miner.hashrate.desc())
    total = query.count()
    miners = query.offset((page - 1) * limit).limit(limit).all()

    return miners


@router.get("/search", response_model=list[MinerResponse])
async def search_miners(
    q: str = Query(..., min_length=1, description="Search term"),
    limit: int = Query(10, ge=1, le=50),
    db: Session = Depends(get_db),
):
    """Autocomplete search for miner names."""
    term = f"%{q.lower()}%"
    miners = (
        db.query(Miner)
        .filter(or_(Miner.name.ilike(term), Miner.brand.ilike(term)))
        .order_by(Miner.hashrate.desc())
        .limit(limit)
        .all()
    )
    return miners


@router.get("/{miner_id}", response_model=MinerResponse)
async def get_miner(miner_id: int, db: Session = Depends(get_db)):
    miner = db.query(Miner).filter(Miner.id == miner_id).first()
    if not miner:
        raise HTTPException(status_code=404, detail="Miner not found")
    return miner


@router.get("/stats/summary")
async def miners_summary(db: Session = Depends(get_db)):
    total = db.query(Miner).count()
    asic_count = db.query(Miner).filter(Miner.type == "ASIC").count()
    gpu_count = db.query(Miner).filter(Miner.type == "GPU").count()
    top_miner = db.query(Miner).order_by(Miner.hashrate.desc()).first()

    return {
        "total_miners": total,
        "asic_count": asic_count,
        "gpu_count": gpu_count,
        "top_miner": top_miner.to_dict() if top_miner else None,
    }