from fastapi import APIRouter, Depends, HTTPException
from sqlalchemy.orm import Session
from pydantic import BaseModel
from datetime import datetime
from typing import Optional, List

from backend.database import get_db
from backend.models import Emitter

router = APIRouter()


# Pydantic schemas for request/response validation
class EmitterReport(BaseModel):
    unit: str
    unit_type: str
    timestamp: str
    file: str
    status: str


class EmitterResponse(BaseModel):
    id: str
    unit_type: str
    last_seen: datetime
    last_file: str
    status: str
    notes: Optional[str] = None

    class Config:
        from_attributes = True


@router.post("/emitters/report", status_code=200)
def report_emitter(report: EmitterReport, db: Session = Depends(get_db)):
    """
    Endpoint for emitters to report their status.
    Creates a new emitter if it doesn't exist, or updates an existing one.
    """
    try:
        # Parse the timestamp
        timestamp = datetime.fromisoformat(report.timestamp.replace('Z', '+00:00'))
    except ValueError:
        raise HTTPException(status_code=400, detail="Invalid timestamp format")

    # Check if emitter already exists
    emitter = db.query(Emitter).filter(Emitter.id == report.unit).first()

    if emitter:
        # Update existing emitter
        emitter.unit_type = report.unit_type
        emitter.last_seen = timestamp
        emitter.last_file = report.file
        emitter.status = report.status
    else:
        # Create new emitter
        emitter = Emitter(
            id=report.unit,
            unit_type=report.unit_type,
            last_seen=timestamp,
            last_file=report.file,
            status=report.status
        )
        db.add(emitter)

    db.commit()
    db.refresh(emitter)

    return {
        "message": "Emitter report received",
        "unit": emitter.id,
        "status": emitter.status
    }


@router.get("/fleet/status", response_model=List[EmitterResponse])
def get_fleet_status(db: Session = Depends(get_db)):
    """
    Returns a list of all emitters and their current status.
    """
    emitters = db.query(Emitter).all()
    return emitters

# series3v1.1 Standardized Heartbeat Schema (multi-unit)
from fastapi import Request

@router.post("/api/series3/heartbeat", status_code=200)
async def series3_heartbeat(request: Request, db: Session = Depends(get_db)):
    """
    Accepts a full telemetry payload from the Series3 emitter.
    Updates or inserts each unit into the database.
    """
    payload = await request.json()

    source = payload.get("source_id")
    units = payload.get("units", [])

    print("\n=== Series 3 Heartbeat ===")
    print("Source:", source)
    print("Units received:", len(units))
    print("==========================\n")

    results = []

    for u in units:
        uid = u.get("unit_id")
        last_event_time = u.get("last_event_time")
        event_meta = u.get("event_metadata", {})
        age_minutes = u.get("age_minutes")

        try:
            if last_event_time:
                ts = datetime.fromisoformat(last_event_time.replace("Z", "+00:00"))
            else:
                ts = None
        except:
            ts = None

        # Pull from DB
        emitter = db.query(Emitter).filter(Emitter.id == uid).first()

        # File name (from event_metadata)
        last_file = event_meta.get("file_name")
        status = "Unknown"

        # Determine status based on age
        if age_minutes is None:
            status = "Missing"
        elif age_minutes > 24 * 60:
            status = "Missing"
        elif age_minutes > 12 * 60:
            status = "Pending"
        else:
            status = "OK"

        if emitter:
            # Update existing
            emitter.last_seen = ts
            emitter.last_file = last_file
            emitter.status = status
        else:
            # Insert new
            emitter = Emitter(
                id=uid,
                unit_type="series3",
                last_seen=ts,
                last_file=last_file,
                status=status
            )
            db.add(emitter)

        results.append({"unit": uid, "status": status})

    db.commit()

    return {
        "message": "Heartbeat processed",
        "source": source,
        "units_processed": len(results),
        "results": results
    }