# app/web/pages/group/history.py
from __future__ import annotations
from datetime import date, datetime
import re
from fastapi import APIRouter, Request, Query
from fastapi.responses import HTMLResponse
from app.web.deps import (
    templates, sb, COMPANY_ORDER, TODAY,
    _date_display_and_compare, _to_int_safe,
    _normalize_multiline, _norm_company_label,
)

router = APIRouter()

# -------- 공석 판별 --------
VACANCY_PAT = re.compile(r"^\s*\(?공석\)?\s*$")
def _is_vacant_name(name: str | None) -> bool:
    if not name:
        return False
    s = str(name).strip()
    if VACANCY_PAT.match(s):
        return True
    return s in {"결원", "-"}

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

def _to_date(v) -> date | None:
    """int(yyyymmdd) | 'YYYY-MM-DD' | date | datetime -> date | None"""
    if v is None:
        return None
    if isinstance(v, date) and not isinstance(v, datetime):
        return v
    if isinstance(v, datetime):
        return v.date()
    if isinstance(v, int):
        y = v // 10000
        m = (v // 100) % 100
        d = v % 100
        try:
            return date(y, m, d)
        except Exception:
            return None
    if isinstance(v, str):
        s = v.strip()
        if not s:
            return None
        try:
            y, m, d = s[:10].split("-")  # tolerate 'YYYY-MM-DD...'
            return date(int(y), int(m), int(d))
        except Exception:
            return None
    return None

def _fmt_date(d: date | None) -> str:
    return f"{d:%Y-%m-%d}" if d else "-"

def _fmt_date_kor(d: date | None) -> str | None:
    if not d:
        return None
    return f"{d.year}년 {d.month:02d}월 {d.day:02d}일"

@router.get("/group/history", response_class=HTMLResponse)
async def group_history(request: Request, company: str | None = Query(default=None)):
    # 1) 데이터 로드
    try:
        res = sb.table("kepco_history").select("*").limit(20000).execute()
        raw: list[dict] = res.data or []
    except Exception:
        raw = []

    tabs = COMPANY_ORDER[:]
    current = company if company in COMPANY_ORDER else tabs[0]
    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

    cur_rows = [r for r in raw if _matches(r.get("department"))]
    if not cur_rows and raw:
        cur_rows = [r for r in raw if _key(current) in _key(r.get("department"))]

    # ✅ (새 규칙) history 페이지에서 공석 숨김 (단, current=True는 표시)
    cur_rows = [
        r for r in cur_rows
        if (not _is_vacant_name(r.get("name"))) or bool(r.get("current"))
    ]

    # 2) 표시/정렬용 가공 (DB 값 기준)
    enriched: list[dict] = []
    for r in cur_rows:
        task = (r.get("task") or r.get("title") or r.get("position") or "-").strip() or "-"

        start_disp, start_cmp = _date_display_and_compare(r.get("start"))
        end_disp, end_cmp = _date_display_and_compare(r.get("end"))
        posted_disp, posted_cmp = _date_display_and_compare(r.get("posted_at"))
        actual_end_disp, actual_end_cmp = _date_display_and_compare(r.get("actual_end"))

        start_d      = _to_date(start_cmp)   or _to_date(r.get("start"))
        end_d        = _to_date(end_cmp)     or _to_date(r.get("end"))
        posted_d     = _to_date(posted_cmp)  or _to_date(r.get("posted_at"))
        actual_end_d = _to_date(actual_end_cmp) or _to_date(r.get("actual_end"))

        item = {
            **r,
            "_task": task,
            "_start_str": start_disp or _fmt_date(start_d),
            "_end_str": end_disp or _fmt_date(end_d),
            "_posted_str": posted_disp or _fmt_date(posted_d),
            "_start_date": start_d,
            "_end_date": end_d,
            "_posted_date": posted_d,
            "_career_str": _normalize_multiline(r.get("career")),
            "_actual_end_str": (actual_end_disp or _fmt_date(actual_end_d)) if actual_end_d else None,
            "_actual_end_reason": None,  # reason 컬럼 제거됨
        }

        # inactive(회색 음영) = current=False
        item["_inactive"] = not bool(r.get("current"))

        enriched.append(item)

    # 3) 직책명 변경 배지 (동일 (dept,name,start,end) 그룹 내 이전 task와 비교)
    groups: dict[tuple, list[dict]] = {}
    for p in enriched:
        gkey = (_key(p.get("department")), _key(p.get("name")),
                p.get("_start_date"), p.get("_end_date"))
        groups.setdefault(gkey, []).append(p)

    for _, items in groups.items():
        # 공시일 오름차순으로 정렬 후 변화 탐지
        items.sort(key=lambda x: (x.get("_posted_date") or date.min, _to_int_safe(x.get("id"))))
        prev_task = None
        first_start = items[0].get("_start_date") if items else None
        for idx, it in enumerate(items):
            cur_task = it.get("_task") or "-"
            if idx == 0:
                prev_task = cur_task
                continue
            pd = it.get("_posted_date")
            sd = first_start
            if pd and sd and pd > sd and prev_task and prev_task != cur_task:
                it["_title_change_from"] = prev_task
                it["_title_change_at"] = _fmt_date(pd)
            prev_task = cur_task

        # 3.5) 연장 배지 툴팁에 쓸 "기존 종료일" 계산
        #  - 규칙: 동일 인물에서 extended=False였던 과거 레코드 중 가장 가까운 과거의 end를 사용
        for i, cur in enumerate(items):
            if not cur.get("extended"):
                continue
            prev_end_date = None
            # 바로 이전들 역순으로 검색
            for j in range(i - 1, -1, -1):
                prev = items[j]
                if prev.get("extended"):
                    continue  # 연장건은 건너뛰고
                if prev.get("_end_date"):
                    prev_end_date = prev.get("_end_date")
                    break
            cur["_extended_prev_end_kor"] = _fmt_date_kor(prev_end_date)

    # 4) 출력 정렬: 공시일 ↓, id 보조
    enriched.sort(
        key=lambda x: (x.get("_posted_date") or date.min, _to_int_safe(x.get("id"))),
        reverse=True,
    )

    return templates.TemplateResponse(
        "group/history.html",
        {"request": request, "tabs": tabs, "current": current, "rows": enriched},
    )