#!/usr/bin/env python3
"""
memory-search.py - 메모리 통합 검색 CLI 스크립트

검색 대상: memory/reports/*.md, memory/research/*.md, memory/learnings/*.md
"""

from __future__ import annotations

import argparse
import json
import re
from datetime import datetime
from pathlib import Path

_workspace_dir = Path(__file__).parent.parent

SEARCH_DIRS = {
    "report": _workspace_dir / "memory" / "reports",
    "research": _workspace_dir / "memory" / "research",
    "learnings": _workspace_dir / "memory" / "learnings",
}

MAX_LINE_LENGTH = 200
MAX_MATCHES_PER_FILE = 3


def load_team_ids(team_id: str) -> set:
    """task-timers.json에서 특정 team_id에 속한 task ID 집합 반환"""
    timers_path = _workspace_dir / "task-timers.json"
    if not timers_path.exists():
        return set()
    try:
        with open(timers_path, "r", encoding="utf-8") as f:
            data = json.load(f)
        task_ids = set()
        for task_id_key, info in data.items():
            if isinstance(info, dict) and info.get("team_id") == team_id:
                task_ids.add(task_id_key)
        return task_ids
    except Exception:
        return set()


def search_files(
    query: str, record_type: str = "all", team: str | None = None, date: str | None = None, limit: int = 50
) -> list:
    pattern = re.compile(re.escape(query), re.IGNORECASE)

    # 날짜 필터 파싱
    filter_date = None
    if date:
        try:
            filter_date = datetime.strptime(date, "%Y-%m-%d").date()
        except ValueError:
            pass

    # team 필터: 해당 team의 task ID 집합
    team_task_ids = None
    if team:
        team_task_ids = load_team_ids(team)

    # 검색 대상 디렉토리 결정
    if record_type == "all":
        dirs_to_search = list(SEARCH_DIRS.items())
    elif record_type in SEARCH_DIRS:
        dirs_to_search = [(record_type, SEARCH_DIRS[record_type])]
    else:
        dirs_to_search = []

    results = []

    for rtype, dirpath in dirs_to_search:
        if not dirpath.exists():
            continue  # learnings 등 없는 디렉토리는 무시

        for md_file in sorted(dirpath.glob("*.md")):
            # team 필터: 파일명에서 task ID 추출 (예: task-100.1.md -> task-100.1)
            if team_task_ids is not None:
                stem = md_file.stem  # task-100.1
                if stem not in team_task_ids:
                    continue

            # 날짜 필터: 파일 수정일 기준
            mtime = md_file.stat().st_mtime
            modified_dt = datetime.fromtimestamp(mtime)
            if filter_date and modified_dt.date() != filter_date:
                continue

            # 파일 내용 검색
            try:
                content = md_file.read_text(encoding="utf-8", errors="replace")
            except Exception:
                continue

            lines = content.splitlines()
            matches = []
            for line_idx, line in enumerate(lines, start=1):
                if pattern.search(line):
                    trimmed = line.strip()
                    if len(trimmed) > MAX_LINE_LENGTH:
                        trimmed = trimmed[:MAX_LINE_LENGTH]
                    matches.append({"line_number": line_idx, "text": trimmed})
                    if len(matches) >= MAX_MATCHES_PER_FILE:
                        break

            if not matches:
                continue

            # filepath: memory/<dir>/<filename>
            dir_name = dirpath.name  # reports, research, learnings
            results.append(
                {
                    "filename": md_file.name,
                    "type": rtype,
                    "filepath": f"memory/{dir_name}/{md_file.name}",
                    "matches": matches,
                    "modified": modified_dt.strftime("%Y-%m-%dT%H:%M:%S"),
                }
            )

    # 수정일 역순 정렬
    results.sort(key=lambda x: x["modified"], reverse=True)

    return results[:limit]


def main():
    parser = argparse.ArgumentParser(description="메모리 통합 검색 CLI")
    parser.add_argument("--query", required=True, help="검색 키워드 (대소문자 무관)")
    parser.add_argument(
        "--type",
        choices=["report", "research", "learnings", "all"],
        default="all",
        help="검색 대상 타입 (기본: all)",
    )
    parser.add_argument("--team", default=None, help="팀 필터 (task-timers.json의 team_id)")
    parser.add_argument("--date", default=None, help="날짜 필터 (YYYY-MM-DD, 파일 수정일 기준)")
    parser.add_argument("--limit", type=int, default=50, help="최대 결과 수 (기본: 50)")

    args = parser.parse_args()

    results = search_files(
        query=args.query,
        record_type=args.type,
        team=args.team,
        date=args.date,
        limit=args.limit,
    )

    print(json.dumps(results, ensure_ascii=False, indent=2))


if __name__ == "__main__":
    main()