from __future__ import annotations
from fastapi import APIRouter, Depends, HTTPException
from sqlalchemy.orm import Session

from app.database import get_db
from app.auth import get_current_user
from app.models.version import (
    VersionConfig, VersionUpgrade, VersionHighlight, VersionCompare,
    VersionTimeline, VersionTimelineChange, VersionPhilosophy,
)
from app.schemas.version import (
    VersionConfigSchema, VersionUpgradeSchema, VersionHighlightSchema,
    VersionCompareSchema, VersionTimelineSchema, VersionTimelineResponse,
    VersionPhilosophySchema,
)

router = APIRouter(prefix="/api/versions", tags=["版本历史"], dependencies=[Depends(get_current_user)])


def _get_config(db: Session) -> VersionConfig:
    config = db.query(VersionConfig).first()
    if not config:
        config = VersionConfig()
        db.add(config)
        db.flush()
    return config


@router.get("/config", response_model=VersionConfigSchema)
def get_config(db: Session = Depends(get_db)):
    c = _get_config(db)
    return VersionConfigSchema(
        stats_iterations=c.stats_iterations, stats_years=c.stats_years,
        stats_guests=c.stats_guests, quote_text=c.quote_text, quote_author=c.quote_author,
    )


@router.put("/config")
def update_config(req: VersionConfigSchema, db: Session = Depends(get_db)):
    c = _get_config(db)
    for key, val in req.model_dump().items():
        setattr(c, key, val)
    db.commit()
    return {"message": "更新成功"}


@router.get("/upgrades", response_model=list[VersionUpgradeSchema])
def get_upgrades(db: Session = Depends(get_db)):
    c = _get_config(db)
    items = db.query(VersionUpgrade).filter_by(config_id=c.id).order_by(VersionUpgrade.sort_order).all()
    return [VersionUpgradeSchema(tag=u.tag, name=u.name, description=u.description, reason=u.reason) for u in items]


@router.put("/upgrades")
def update_upgrades(req: list[VersionUpgradeSchema], db: Session = Depends(get_db)):
    c = _get_config(db)
    db.query(VersionUpgrade).filter_by(config_id=c.id).delete()
    for i, u in enumerate(req):
        db.add(VersionUpgrade(config_id=c.id, tag=u.tag, name=u.name, description=u.description, reason=u.reason, sort_order=i))
    db.commit()
    return {"message": "更新成功"}


@router.get("/highlights", response_model=list[VersionHighlightSchema])
def get_highlights(db: Session = Depends(get_db)):
    c = _get_config(db)
    items = db.query(VersionHighlight).filter_by(config_id=c.id).order_by(VersionHighlight.sort_order).all()
    return [VersionHighlightSchema(label=h.label, text=h.text) for h in items]


@router.put("/highlights")
def update_highlights(req: list[VersionHighlightSchema], db: Session = Depends(get_db)):
    c = _get_config(db)
    db.query(VersionHighlight).filter_by(config_id=c.id).delete()
    for i, h in enumerate(req):
        db.add(VersionHighlight(config_id=c.id, label=h.label, text=h.text, sort_order=i))
    db.commit()
    return {"message": "更新成功"}


@router.get("/compare", response_model=VersionCompareSchema)
def get_compare(db: Session = Depends(get_db)):
    c = _get_config(db)
    cmp = db.query(VersionCompare).filter_by(config_id=c.id).first()
    if not cmp:
        return VersionCompareSchema()
    return VersionCompareSchema(headers=cmp.headers or [], rows=cmp.rows or [])


@router.put("/compare")
def update_compare(req: VersionCompareSchema, db: Session = Depends(get_db)):
    c = _get_config(db)
    cmp = db.query(VersionCompare).filter_by(config_id=c.id).first()
    if not cmp:
        cmp = VersionCompare(config_id=c.id)
        db.add(cmp)
    cmp.headers = req.headers
    cmp.rows = req.rows
    db.commit()
    return {"message": "更新成功"}


@router.get("/timeline", response_model=list[VersionTimelineResponse])
def get_timeline(db: Session = Depends(get_db)):
    c = _get_config(db)
    items = db.query(VersionTimeline).filter_by(config_id=c.id).order_by(VersionTimeline.sort_order).all()
    return [
        VersionTimelineResponse(
            id=t.id, version=t.version, date=t.date, title=t.title, reason=t.reason, sort_order=t.sort_order,
            changes=[{"type": ch.type, "text": ch.text} for ch in t.changes],
        )
        for t in items
    ]


@router.post("/timeline", response_model=VersionTimelineResponse, status_code=201)
def create_timeline(req: VersionTimelineSchema, db: Session = Depends(get_db)):
    c = _get_config(db)
    t = VersionTimeline(config_id=c.id, version=req.version, date=req.date, title=req.title, reason=req.reason)
    db.add(t)
    db.flush()
    for i, ch in enumerate(req.changes):
        db.add(VersionTimelineChange(timeline_id=t.id, type=ch.type, text=ch.text, sort_order=i))
    db.commit()
    db.refresh(t)
    return VersionTimelineResponse(
        id=t.id, version=t.version, date=t.date, title=t.title, reason=t.reason, sort_order=t.sort_order,
        changes=[{"type": ch.type, "text": ch.text} for ch in t.changes],
    )


@router.put("/timeline/{t_id}")
def update_timeline(t_id: int, req: VersionTimelineSchema, db: Session = Depends(get_db)):
    t = db.query(VersionTimeline).get(t_id)
    if not t:
        raise HTTPException(status_code=404, detail="时间线条目不存在")
    t.version = req.version
    t.date = req.date
    t.title = req.title
    t.reason = req.reason
    db.query(VersionTimelineChange).filter_by(timeline_id=t.id).delete()
    for i, ch in enumerate(req.changes):
        db.add(VersionTimelineChange(timeline_id=t.id, type=ch.type, text=ch.text, sort_order=i))
    db.commit()
    return {"message": "更新成功"}


@router.delete("/timeline/{t_id}")
def delete_timeline(t_id: int, db: Session = Depends(get_db)):
    t = db.query(VersionTimeline).get(t_id)
    if not t:
        raise HTTPException(status_code=404, detail="时间线条目不存在")
    db.delete(t)
    db.commit()
    return {"message": "删除成功"}


@router.get("/philosophy", response_model=list[VersionPhilosophySchema])
def get_philosophy(db: Session = Depends(get_db)):
    c = _get_config(db)
    items = db.query(VersionPhilosophy).filter_by(config_id=c.id).order_by(VersionPhilosophy.sort_order).all()
    return [VersionPhilosophySchema(label=p.label, text=p.text) for p in items]


@router.put("/philosophy")
def update_philosophy(req: list[VersionPhilosophySchema], db: Session = Depends(get_db)):
    c = _get_config(db)
    db.query(VersionPhilosophy).filter_by(config_id=c.id).delete()
    for i, p in enumerate(req):
        db.add(VersionPhilosophy(config_id=c.id, label=p.label, text=p.text, sort_order=i))
    db.commit()
    return {"message": "更新成功"}