#!/usr/bin/env python3
"""
공통 유틸리티: 조직 구조에서 팀별 상세 JSON 파일 동적 생성
작성자: 카르티케야 (Kartikeya) - dev4팀 백엔드 개발자
"""

from __future__ import annotations

import json
from pathlib import Path
from typing import Any

_WORKSPACE = Path("/home/jay/workspace")
_MEMORY_DIR = _WORKSPACE / "memory"
DEFAULT_ORG_FILE = _MEMORY_DIR / "organization-structure.json"
DEFAULT_BACKUP_FILE = _MEMORY_DIR / "org-details" / "organization-structure.backup.json"
DEFAULT_OUTPUT_DIR = _MEMORY_DIR / "org-details"


def _load_json(path: Path) -> dict[str, Any] | None:
    try:
        with open(path, "r", encoding="utf-8") as f:
            return json.load(f)
    except (FileNotFoundError, json.JSONDecodeError):
        return None


def _build_lookup(data: dict[str, Any]) -> dict[str, dict[str, Any]]:
    """id → 멤버 객체 조회 테이블 구성 (모든 팀/센터 순회)."""
    lookup: dict[str, dict[str, Any]] = {}

    def _idx(obj: dict[str, Any]) -> None:
        if mid := obj.get("id"):
            lookup[mid] = obj

    structure = data.get("structure", {})
    for team in structure.get("columns", {}).get("teams", []):
        for key in ("lead", "office_lead", "direct_worker"):
            if isinstance(team.get(key), dict):
                _idx(team[key])
        for m in team.get("members", []):
            if isinstance(m, dict):
                _idx(m)
        for sub in team.get("sub_teams", []):
            if isinstance(sub, dict):
                if isinstance(sub.get("lead"), dict):
                    _idx(sub["lead"])
                for m in sub.get("members", []):
                    if isinstance(m, dict):
                        _idx(m)
    for center in structure.get("rows", {}).get("centers", []):
        if isinstance(center.get("lead"), dict):
            _idx(center["lead"])
        for m in center.get("members", []):
            if isinstance(m, dict):
                _idx(m)
    return lookup


def _enrich(base: dict[str, Any], lookup: dict[str, Any]) -> dict[str, Any]:
    """base 객체를 백업 조회 테이블 데이터로 보강 (백업 우선, base 필드 보존)."""
    mid = base.get("id")
    if not mid or mid not in lookup:
        return base
    return {**base, **lookup[mid]}


def _members_detail(
    members: list[dict[str, Any]], lookup: dict[str, Any]
) -> dict[str, dict[str, Any]]:
    return {
        (e := _enrich(m, lookup)).get("id", "unknown"): e
        for m in members
        if isinstance(m, dict)
    }


def _write_json(path: Path, data: dict[str, Any]) -> None:
    path.parent.mkdir(parents=True, exist_ok=True)
    with open(path, "w", encoding="utf-8") as f:
        json.dump(data, f, ensure_ascii=False, indent=2)


def _make_payload(
    team_id: str,
    team_name: str,
    status: str,
    team_type: str,
    lead_raw: dict[str, Any],
    members: list[dict[str, Any]],
    lookup: dict[str, Any],
) -> dict[str, Any]:
    payload: dict[str, Any] = {
        "team_id": team_id,
        "team_name": team_name,
        "extracted_from": "organization-structure.json",
        "status": status,
        "type": team_type,
    }
    lead = _enrich(lead_raw, lookup) if isinstance(lead_raw, dict) else {}
    if lead:
        payload["lead"] = lead
    payload["members_detail"] = _members_detail(members, lookup)
    return payload


def generate_all_sub_team_details(
    org_file: Path | None = None,
    backup_file: Path | None = None,
    output_dir: Path | None = None,
) -> list[str]:
    """
    Generate individual detail JSON files for all sub_teams in development-office.
    Returns list of generated file paths.
    """
    org_path = Path(org_file) if org_file else DEFAULT_ORG_FILE
    backup_path = Path(backup_file) if backup_file else DEFAULT_BACKUP_FILE
    out_dir = Path(output_dir) if output_dir else DEFAULT_OUTPUT_DIR

    main_data = _load_json(org_path)
    if main_data is None:
        raise FileNotFoundError(f"메인 조직 파일을 찾을 수 없습니다: {org_path}")

    backup_data = _load_json(backup_path)
    lookup = _build_lookup(backup_data if backup_data is not None else main_data)

    generated: list[str] = []
    structure = main_data.get("structure", {})

    for team in structure.get("columns", {}).get("teams", []):
        team_id = team.get("team_id", "")

        if team_id == "development-office":
            for sub in team.get("sub_teams") or []:
                dp = sub.get("detail_path")
                if not dp:
                    continue
                out = out_dir / Path(dp).name
                payload = _make_payload(
                    team_id=sub.get("sub_team_id", out.stem),
                    team_name=sub.get("sub_team_name", ""),
                    status=sub.get("status", "active"),
                    team_type="physical",
                    lead_raw=sub.get("lead") or {},
                    members=sub.get("members") or [],
                    lookup=lookup,
                )
                _write_json(out, payload)
                generated.append(str(out))
        else:
            dp = team.get("detail_path")
            if not dp:
                continue
            out = out_dir / Path(dp).name
            payload = _make_payload(
                team_id=team_id,
                team_name=team.get("team_name", ""),
                status=team.get("status", "active"),
                team_type=team.get("type", "logical"),
                lead_raw=team.get("lead") or {},
                members=team.get("members") or [],
                lookup=lookup,
            )
            _write_json(out, payload)
            generated.append(str(out))

    for center in structure.get("rows", {}).get("centers", []):
        dp = center.get("detail_path")
        if not dp:
            continue
        out = out_dir / Path(dp).name
        payload = _make_payload(
            team_id=center.get("center_id", out.stem),
            team_name=center.get("center_name", ""),
            status=center.get("status", "active"),
            team_type=center.get("type", "logical"),
            lead_raw=center.get("lead") or {},
            members=center.get("members") or [],
            lookup=lookup,
        )
        _write_json(out, payload)
        generated.append(str(out))

    return generated


if __name__ == "__main__":
    print("=" * 60)
    print("조직 상세 파일 생성 시작")
    print(f"  소스: {DEFAULT_BACKUP_FILE} (백업 우선)")
    print(f"  출력: {DEFAULT_OUTPUT_DIR}")
    print("=" * 60)

    files = generate_all_sub_team_details()

    print(f"\n총 {len(files)}개 파일 생성 완료:")
    for fp in sorted(files):
        size = Path(fp).stat().st_size
        print(f"  {Path(fp).name}: {size:,} bytes")
    print("\n완료!")