from __future__ import annotations
from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
from contextlib import asynccontextmanager
import sqlite3
import uuid
from datetime import datetime

DB_PATH = "landvex.db"


def init_db():
    conn = sqlite3.connect(DB_PATH)
    conn.execute("""
        CREATE TABLE IF NOT EXISTS claims (
            id TEXT PRIMARY KEY,
            model_id TEXT NOT NULL,
            manufacturer_name TEXT NOT NULL,
            contact_email TEXT NOT NULL,
            status TEXT NOT NULL DEFAULT 'pending',
            created_at TEXT NOT NULL,
            approved_at TEXT
        )
    """)
    conn.commit()
    conn.close()


@asynccontextmanager
async def lifespan(app: FastAPI):
    init_db()
    yield


app = FastAPI(title="LandveX Claims API", lifespan=lifespan)


class ClaimCreate(BaseModel):
    model_id: str
    manufacturer_name: str
    contact_email: str


class Claim(BaseModel):
    id: str
    model_id: str
    manufacturer_name: str
    contact_email: str
    status: str
    created_at: str
    approved_at: str | None


def get_db():
    return sqlite3.connect(DB_PATH)


@app.post("/v0/claims", response_model=Claim)
def create_claim(payload: ClaimCreate):
    claim_id = str(uuid.uuid4())
    now = datetime.utcnow().isoformat()
    conn = get_db()
    conn.execute(
        "INSERT INTO claims (id, model_id, manufacturer_name, contact_email, status, created_at) VALUES (?, ?, ?, ?, ?, ?)",
        (claim_id, payload.model_id, payload.manufacturer_name, payload.contact_email, "pending", now),
    )
    conn.commit()
    row = conn.execute("SELECT * FROM claims WHERE id = ?", (claim_id,)).fetchone()
    conn.close()
    return Claim(
        id=row[0],
        model_id=row[1],
        manufacturer_name=row[2],
        contact_email=row[3],
        status=row[4],
        created_at=row[5],
        approved_at=row[6],
    )


@app.get("/v0/claims/{claim_id}", response_model=Claim)
def get_claim(claim_id: str):
    conn = get_db()
    row = conn.execute("SELECT * FROM claims WHERE id = ?", (claim_id,)).fetchone()
    conn.close()
    if not row:
        raise HTTPException(status_code=404, detail="Claim not found")
    return Claim(
        id=row[0],
        model_id=row[1],
        manufacturer_name=row[2],
        contact_email=row[3],
        status=row[4],
        created_at=row[5],
        approved_at=row[6],
    )


@app.post("/v0/claims/{claim_id}/approve", response_model=Claim)
def approve_claim(claim_id: str):
    conn = get_db()
    row = conn.execute("SELECT * FROM claims WHERE id = ?", (claim_id,)).fetchone()
    if not row:
        conn.close()
        raise HTTPException(status_code=404, detail="Claim not found")
    if row[4] == "approved":
        conn.close()
        raise HTTPException(status_code=400, detail="Claim already approved")
    now = datetime.utcnow().isoformat()
    conn.execute(
        "UPDATE claims SET status = ?, approved_at = ? WHERE id = ?",
        ("approved", now, claim_id),
    )
    conn.commit()
    row = conn.execute("SELECT * FROM claims WHERE id = ?", (claim_id,)).fetchone()
    conn.close()
    return Claim(
        id=row[0],
        model_id=row[1],
        manufacturer_name=row[2],
        contact_email=row[3],
        status=row[4],
        created_at=row[5],
        approved_at=row[6],
    )