from __future__ import annotations
from datetime import date
from typing import Any, Dict, List
from fastapi import APIRouter, Request, Query
from fastapi.responses import HTMLResponse

from app.web.deps import (
    templates, sb, COMPANY_ORDER,
    _norm_company_label, _parse_date_parts, _parts_to_date
)

router = APIRouter()

def _parse_dt(any_s: Any) -> date:
    y, m, d = _parse_date_parts(str(any_s) if any_s is not None else "")
    return _parts_to_date(y, m, d, assume_last=True) or date.min

def _posted_or_created(row: Dict[str, Any]) -> Any:
    return row.get("posted_at") or row.get("created_at")

@router.get("/group/timeline", response_class=HTMLResponse)
async def group_timeline(request: Request, company: str | None = Query(default=None)):
    """
    상단: 기관별 최신 1건만 보여주는 스냅샷 테이블
    하단: 회사(기관) 탭별 전체 이력 테이블 (최신이 위)
    """
    # 전체 로드
    try:
        res = (
            sb.table("kepco_id")
              .select("department,posted_at,pdf_url,created_at")
              .limit(3000)
              .execute()
        )
        all_rows: List[Dict[str, Any]] = res.data or []
    except Exception:
        all_rows = []

    # --- 상단 메인표: 기관별 최신 1건만 선별 ---
    latest_map: Dict[str, Dict[str, Any]] = {}
    for r in all_rows:
        dep = r.get("department")
        key = _norm_company_label(dep) or (dep or "").strip()
        if not key:
            continue
        cur = latest_map.get(key)
        if cur is None:
            latest_map[key] = r
        else:
            # posted_at(없으면 created_at) 기준 최신 선택
            if _parse_dt(_posted_or_created(r)) > _parse_dt(_posted_or_created(cur)):
                latest_map[key] = r

    rows_main = list(latest_map.values())

    # 정렬: 회사 고정 순서 → 공시일 내림차순
    order_map = {name: i for i, name in enumerate(COMPANY_ORDER)}

    def dept_order(dep: str | None) -> int:
        label = _norm_company_label(dep)
        return order_map.get(label or "", 999)

    rows_main.sort(
        key=lambda r: (
            dept_order(r.get("department")),
            -_parse_dt(_posted_or_created(r)).toordinal(),
        )
    )

    # --- 하단: 탭 + 이력 목록 ---
    tabs = COMPANY_ORDER[:]
    current = company if (company in tabs) else (tabs[0] if tabs else "")

    def _key(s: str | None) -> str:
        return (s or "").replace(" ", "").strip()

    cur_key = _key(current)

    def _matches(dep: str | None) -> bool:
        if not dep:
            return False
        dep_key = _key(dep)
        if dep_key == cur_key:
            return True
        norm = _norm_company_label(dep)
        if norm and _key(norm) == cur_key:
            return True
        # 느슨 매칭(괄호/공백 차이 보정)
        return cur_key in dep_key or dep_key in cur_key

    comp_rows = [r for r in all_rows if _matches(r.get("department"))]
    # 최신이 위
    comp_rows.sort(key=lambda r: -_parse_dt(_posted_or_created(r)).toordinal())

    return templates.TemplateResponse(
        "group/timeline.html",
        {
            "request": request,
            "rows_main": rows_main,   # 상단: 기관별 최신 1건
            "tabs": tabs,             # 하단 탭
            "current": current,       # 현재 탭
            "comp_rows": comp_rows,   # 현재 탭 이력
        },
    )