from fastapi import APIRouter, Depends, HTTPException, BackgroundTasks
from sqlalchemy.orm import Session
from typing import List, Optional
from decimal import Decimal
from datetime import date as date_type

from ..database import get_db
from ..models import BulkSale, FuelRate, SystemSetting
from ..schemas import BulkSaleCreate, BulkSaleOut
from ..dependencies import get_current_user, require_owner

router = APIRouter()


def _get_setting(db: Session, key: str, default: str = '') -> str:
    s = db.query(SystemSetting).filter(SystemSetting.setting_key == key).first()
    return s.setting_value if s else default


@router.get("/bulk-sales", response_model=List[BulkSaleOut])
def list_bulk_sales(
    date_from: Optional[str] = None,
    date_to: Optional[str] = None,
    fuel_type: Optional[str] = None,
    db: Session = Depends(get_db),
    _=Depends(get_current_user),
):
    q = db.query(BulkSale)
    if date_from:
        q = q.filter(BulkSale.sale_date >= date_from)
    if date_to:
        q = q.filter(BulkSale.sale_date <= date_to)
    if fuel_type:
        q = q.filter(BulkSale.fuel_type == fuel_type)
    return q.order_by(BulkSale.sale_date.desc(), BulkSale.id.desc()).all()


@router.post("/bulk-sales", response_model=BulkSaleOut)
def create_bulk_sale(
    body: BulkSaleCreate,
    background_tasks: BackgroundTasks,
    db: Session = Depends(get_db),
    user=Depends(get_current_user),
):
    # Fetch current fuel rate
    rate_row = (
        db.query(FuelRate)
        .filter(
            FuelRate.fuel_type == body.fuel_type,
            FuelRate.effective_from <= body.sale_date,
        )
        .order_by(FuelRate.effective_from.desc())
        .first()
    )
    standard_rate = Decimal(str(rate_row.rate)) if rate_row else body.custom_rate

    amount = (body.liters * body.custom_rate).quantize(Decimal('0.01'))
    variance_pct = None
    requires_approval = False

    if standard_rate > 0:
        variance_pct = (
            (standard_rate - body.custom_rate) / standard_rate * Decimal('100')
        ).quantize(Decimal('0.01'))
        threshold = Decimal(_get_setting(db, 'price_override_alert_pct', '5.00'))
        if variance_pct > threshold:
            requires_approval = True

    sale = BulkSale(
        sale_date=body.sale_date,
        fuel_type=body.fuel_type,
        liters=body.liters,
        custom_rate=body.custom_rate,
        standard_rate=standard_rate,
        amount=amount,
        rate_variance_pct=variance_pct,
        customer_id=body.customer_id,
        vehicle_no=body.vehicle_no,
        shift_id=body.shift_id,
        notes=body.notes,
        requires_approval=requires_approval,
        created_by=user.id,
    )
    db.add(sale)
    db.flush()
    from .audit import log_audit
    log_audit(db, user.id, 'CREATE', 'bulk_sales', sale.id,
              f"Bulk sale: {float(body.liters):.0f}L {body.fuel_type} at Rs {float(body.custom_rate):.2f}")
    db.commit()
    db.refresh(sale)

    if requires_approval:
        from ..services.notification_service import create_notification
        background_tasks.add_task(
            create_notification,
            db=db,
            type='PRICE_OVERRIDE',
            title=f"Bulk Sale Price Override — {body.fuel_type}",
            message=(
                f"{float(body.liters):.0f}L at Rs{float(body.custom_rate):.2f} "
                f"({float(variance_pct):.1f}% below standard). Needs approval."
            ),
            link=f"/bulk-sales",
            target_role='OWNER',
        )

    return sale


@router.delete("/bulk-sales/{sale_id}")
def delete_bulk_sale(
    sale_id: int,
    db: Session = Depends(get_db),
    current_user=Depends(require_owner),
):
    sale = db.query(BulkSale).filter(BulkSale.id == sale_id).first()
    if not sale:
        raise HTTPException(404, "Bulk sale not found")
    from .audit import log_audit
    log_audit(db, current_user.id, 'DELETE', 'bulk_sales', sale_id,
              f"Deleted bulk sale: {float(sale.liters):.0f}L {sale.fuel_type}")
    db.delete(sale)
    db.commit()
    return {"ok": True}