#!/usr/bin/env python3
"""보고서 파서 유틸리티

보고서 md 파일을 파싱하여 핵심 정보를 추출하고,
텔레그램용 원라인 요약을 생성합니다.
"""

import os
import re


def parse_report(filepath: str) -> dict:
    """보고서 md 파일을 파싱하여 핵심 정보를 dict로 반환합니다.

    Returns:
        dict with keys: task_id, team, summary, test_total, test_passed,
                        test_failed, bug_count, duration, files
    """
    with open(filepath, "r", encoding="utf-8") as f:
        content = f.read()

    result = {
        "task_id": None,
        "team": None,
        "summary": None,
        "test_total": 0,
        "test_passed": 0,
        "test_failed": 0,
        "bug_count": 0,
        "duration": None,
        "files": [],
        "merge_needed": False,
        "merge_branch": None,
        "merge_worktree": None,
    }

    # --- task_id ---
    # 표준 템플릿: "- **작업 ID**: task-9.2"
    m = re.search(r"\*\*작업 ?ID\*\*\s*[:：]\s*(\S+)", content)
    if m:
        result["task_id"] = m.group(1)
    else:
        # 제목에서 추출: "# task-9.1 ..."
        m = re.search(r"#\s+(task-[\d.]+)", content)
        if m:
            result["task_id"] = m.group(1)
        else:
            # 파일명에서 추출
            basename = os.path.splitext(os.path.basename(filepath))[0]
            if re.match(r"task-[\d.]+", basename):
                result["task_id"] = basename

    # --- team ---
    m = re.search(r"[-*]*\s*\*{0,2}팀\*{0,2}\s*[:：]\s*(.+)", content)
    if m:
        raw = m.group(1).strip()
        tm = re.search(r"(dev\d+)", raw)
        result["team"] = tm.group(1) if tm else raw

    # --- summary (작업 요약 / 작업) ---
    m = re.search(r"\*\*?작업 ?요약\*?\*?\s*[:：]\s*(.+)", content)
    if m:
        result["summary"] = m.group(1).strip()
    else:
        m = re.search(r"\*\*?작업\*?\*?\s*[:：]\s*(.+)", content)
        if m:
            result["summary"] = m.group(1).strip()

    # --- duration (소요 시간 / 소요시간) ---
    m = re.search(r"[-*]*\s*\*{0,2}소요\s*시간\*{0,2}\s*[:：]\s*(.+)", content)
    if m:
        result["duration"] = m.group(1).strip()

    # --- files ---
    # 패턴: `/path/to/file` 또는 `/path/to/file.py`
    file_matches = re.findall(r"`(/home/[^`]+)`", content)
    result["files"] = file_matches

    # --- test results ---
    # 표준 템플릿: "- **총 테스트**: 23"
    m = re.search(r"\*\*총 ?테스트\*\*\s*[:：]\s*(\d+)", content)
    if m:
        result["test_total"] = int(m.group(1))
        m2 = re.search(r"\*\*통과\*\*\s*[:：]\s*(\d+)", content)
        if m2:
            result["test_passed"] = int(m2.group(1))
        m3 = re.search(r"\*\*실패\*\*\s*[:：]\s*(\d+)", content)
        if m3:
            result["test_failed"] = int(m3.group(1))
    else:
        # 비표준: "전체 9개 테스트 통과, 실패 0건"
        m = re.search(r"전체\s*(\d+)\s*개?\s*테스트\s*통과.*?실패\s*(\d+)", content)
        if m:
            result["test_total"] = int(m.group(1))
            result["test_passed"] = int(m.group(1))
            result["test_failed"] = int(m.group(2))
        else:
            # "Ran 23 tests ... OK" 패턴
            m = re.search(r"Ran\s+(\d+)\s+tests?", content)
            if m:
                total = int(m.group(1))
                result["test_total"] = total
                # OK면 전부 통과
                if re.search(r"—\s*OK|--\s*OK|\bOK\b", content):
                    result["test_passed"] = total
                    result["test_failed"] = 0
            else:
                # "모든 N개 테스트 통과" 패턴
                m = re.search(r"모든\s*(\d+)\s*개?\s*테스트\s*통과", content)
                if m:
                    total = int(m.group(1))
                    result["test_total"] = total
                    result["test_passed"] = total
                    result["test_failed"] = 0
                else:
                    # 개별 테스트 라인 카운트: "| ... | 통과 |"
                    pass_count = len(re.findall(r"\|\s*통과\s*\|", content))
                    fail_count = len(re.findall(r"\|\s*실패\s*\|", content))
                    if pass_count + fail_count > 0:
                        result["test_total"] = pass_count + fail_count
                        result["test_passed"] = pass_count
                        result["test_failed"] = fail_count

    # --- bug count ---
    # 표준: "- **발견 버그**: 1건"
    m = re.search(r"\*\*발견\s*버그\*\*\s*[:：]\s*(\d+)\s*건", content)
    if m:
        result["bug_count"] = int(m.group(1))
    else:
        # "버그 1건 발견" 패턴
        m = re.search(r"버그\s*(\d+)\s*건\s*발견", content)
        if m:
            result["bug_count"] = int(m.group(1))

    # --- merge detection ---
    # 부정 표현 패턴: "필요 없음", "필요없음", "불필요"
    _MERGE_NEGATIVE = re.compile(
        r"(머지|merge)\s*(필요\s*없음|필요없음|불필요)",
        re.IGNORECASE,
    )
    # 긍정 표현 패턴 (부정 제외)
    _MERGE_POSITIVE = re.compile(
        r"(merge\s*판단|머지\s*판단|merge\s*필요(?!\s*없음|없음)|머지\s*필요(?!\s*없음|없음)|아누에게\s*위임|아누\s*판단)",
        re.IGNORECASE,
    )

    if _MERGE_NEGATIVE.search(content):
        result["merge_needed"] = False
    elif _MERGE_POSITIVE.search(content):
        result["merge_needed"] = True

    # --- merge_branch 추출: task/task-\d+\.\d+-dev\d+ 패턴 ---
    mb = re.search(r"(task/task-\d+\.\d+-dev\d+)", content)
    if mb:
        result["merge_branch"] = mb.group(1)

    # --- merge_worktree 추출: 백틱/따옴표 안의 .worktrees 경로 ---
    mw = re.search(r"[`'\"](/home/jay/projects/[^`'\"]+/\.worktrees/[^`'\"]+)[`'\"]", content)
    if mw:
        result["merge_worktree"] = mw.group(1)

    return result


def summarize_oneline(report_dict: dict) -> str:
    """파싱된 보고서 dict를 텔레그램용 원라인 문자열로 변환합니다.

    Examples:
        '✅ task-9.2 완료 (dev2, 52초) | 테스트 23/23 통과 | 버그 없음'
        '❌ task-9.3 완료 (dev3, 2분16초) | 테스트 5/6 실패 | 버그 1건 수정'
    """
    d = report_dict
    task_id = d.get("task_id") or "???"
    team = d.get("team") or "???"
    duration = d.get("duration") or "?"
    test_total = d.get("test_total", 0)
    test_passed = d.get("test_passed", 0)
    test_failed = d.get("test_failed", 0)
    bug_count = d.get("bug_count", 0)

    # 성공/실패 아이콘
    has_failure = test_failed > 0
    icon = "❌" if has_failure else "✅"

    # 테스트 파트
    if test_total > 0:
        if has_failure:
            test_str = f"테스트 {test_failed}/{test_total} 실패"
        else:
            test_str = f"테스트 {test_passed}/{test_total} 통과"
    else:
        test_str = "테스트 없음"

    # 버그 파트
    bug_str = f"버그 {bug_count}건 수정" if bug_count > 0 else "버그 없음"

    base = f"{icon} {task_id} 완료 ({team}, {duration}) | {test_str} | {bug_str}"
    if d.get("merge_needed"):
        base += " | 🔀 머지 필요"
    return base


def summarize_progress(active_tasks: list, completed_tasks: list, total_tasks: int) -> str:
    """전체 진행 상황을 원라인 문자열로 요약합니다.

    Args:
        active_tasks: [{'team': 'dev1', 'task_id': 'task-6'}, ...]
        completed_tasks: ['task-1', 'task-2', ...]
        total_tasks: 전체 작업 수

    Returns:
        '📊 진행: 5/8 완료 | 🔄 dev1: task-6, dev2: task-7 작업중 | ⏳ 대기: 1건'

    Examples:
        >>> summarize_progress(
        ...     [{'team': 'dev1', 'task_id': 'task-6'}, {'team': 'dev2', 'task_id': 'task-7'}],
        ...     ['task-1', 'task-2', 'task-3', 'task-4', 'task-5'],
        ...     8
        ... )
        '📊 진행: 5/8 완료 | 🔄 dev1: task-6, dev2: task-7 작업중 | ⏳ 대기: 1건'
    """
    completed_count = len(completed_tasks)
    active_count = len(active_tasks)
    waiting_count = total_tasks - completed_count - active_count

    # 진행 파트
    progress_str = f"📊 진행: {completed_count}/{total_tasks} 완료"

    # 작업중 파트
    if active_tasks:
        active_parts = [f"{t['team']}: {t['task_id']}" for t in active_tasks]
        active_str = f"🔄 {', '.join(active_parts)} 작업중"
    else:
        active_str = "🔄 작업중 없음"

    # 대기 파트
    wait_str = f"⏳ 대기: {waiting_count}건"

    return f"{progress_str} | {active_str} | {wait_str}"


if __name__ == "__main__":
    import glob
    import sys

    if len(sys.argv) > 1:
        files = sys.argv[1:]
    else:
        # 기본: reports 디렉토리의 모든 보고서
        reports_dir = os.path.join(os.path.dirname(__file__), "memory", "reports")
        files = sorted(glob.glob(os.path.join(reports_dir, "task-*.md")))

    print("=" * 70)
    print("보고서 원라인 요약 테스트")
    print("=" * 70)

    for f in files:
        report = parse_report(f)
        oneline = summarize_oneline(report)
        print(oneline)

    print()
    print("-" * 70)
    print("진행 상황 요약 테스트")
    print("-" * 70)

    # 예시 진행 상황
    active = [
        {"team": "dev1", "task_id": "task-11.1"},
        {"team": "dev2", "task_id": "task-11.2"},
    ]
    completed = ["task-9.1", "task-9.2", "task-9.3", "task-10.1", "task-10.2"]
    print(summarize_progress(active, completed, 8))
