"""CLI 메모리 검색 도구.

MemoryIndexer를 래핑하는 argparse 기반 커맨드라인 인터페이스.

사용 예시:
    python memory_search.py query "위임 규칙" --type feedback --limit 5
    python memory_search.py reindex
    python memory_search.py stats
"""

import argparse
import sys
from pathlib import Path

# 패키지 루트를 sys.path에 추가 (직접 실행 시)
_ROOT = str(Path(__file__).resolve().parent.parent)
if _ROOT not in sys.path:
    sys.path.insert(0, _ROOT)

from utils.memory_indexer import MemoryIndexer  # noqa: E402

# --------------------------------------------------------------------------- 출력 헬퍼


def _print_results(results: list, layer: str = "full") -> None:
    """검색 결과를 보기 좋게 출력."""
    if not results:
        print("검색 결과가 없습니다.")
        return

    for i, r in enumerate(results, 1):
        title = r.get("title") or "(제목 없음)"
        rtype = r.get("type") or ""
        team = r.get("team_id") or ""
        path = r.get("file_path") or ""
        snippet = r.get("snippet") or ""
        score = r.get("score", "")

        if layer == "index":
            score_str = f" score={score:.2f}" if isinstance(score, float) else ""
            type_str = f" ({rtype})" if rtype else ""
            print(f"[{i}] {title}{type_str}{score_str}")

        elif layer == "summary":
            score_str = f" score={score:.2f}" if isinstance(score, float) else ""
            type_str = f" ({rtype})" if rtype else ""
            print(f"[{i}] {title}{type_str}{score_str}")
            if snippet:
                snippet_clean = " ".join(snippet.split())
                print(f"    미리보기: {snippet_clean[:50]}")
            print()

        else:  # full
            print(f"\n[{i}] {title}")
            meta_parts = []
            if rtype:
                meta_parts.append(f"type={rtype}")
            if team:
                meta_parts.append(f"team={team}")
            if meta_parts:
                print(f"    {' | '.join(meta_parts)}")
            if path:
                print(f"    경로: {path}")
            if snippet:
                # 줄바꿈 정리 후 인덴트
                snippet_clean = " ".join(snippet.split())
                print(f"    미리보기: {snippet_clean[:300]}")

    print()


def _print_stats(stats: dict) -> None:
    """통계 정보를 포맷팅 출력."""
    print(f"\n=== 메모리 인덱스 통계 ===")
    print(f"  전체 문서 수   : {stats.get('total', 0)}")

    by_type = stats.get("by_type", {})
    if by_type:
        print("  타입별 분포    :")
        for t, cnt in sorted(by_type.items()):
            print(f"    {t:20s}: {cnt}")

    by_team = stats.get("by_team", {})
    if by_team:
        print("  팀별 분포      :")
        for team, cnt in sorted(by_team.items()):
            print(f"    {team:20s}: {cnt}")

    last = stats.get("last_indexed")
    print(f"  마지막 인덱싱  : {last or '없음'}")
    print()


# --------------------------------------------------------------------------- 서브커맨드


def cmd_query(args: argparse.Namespace) -> None:
    indexer = MemoryIndexer()
    try:
        results = indexer.search(
            query=args.query,
            type_filter=args.type,
            team_filter=args.team,
            limit=args.limit,
            layer=args.layer,
        )
        _print_results(results, layer=args.layer)
    finally:
        indexer.close()


def cmd_get(args: argparse.Namespace) -> None:
    indexer = MemoryIndexer()
    try:
        results = indexer.get_by_ids(args.ids)
        if not results:
            print("해당 ID의 메모리가 없습니다.")
            return
        for r in results:
            print(f"\n{'='*60}")
            print(f"ID: {r.get('id')} | {r.get('title', '(제목 없음)')}")
            print(f"타입: {r.get('type', '')} | 팀: {r.get('team_id', '')}")
            print(f"경로: {r.get('file_path', '')}")
            print(f"{'='*60}")
            print(r.get("content", ""))
            print()
    finally:
        indexer.close()


def cmd_reindex(args: argparse.Namespace) -> None:  # noqa: ARG001
    indexer = MemoryIndexer()
    try:
        print("전체 재인덱싱을 시작합니다...")
        stats = indexer.reindex_all()
        print(
            f"완료: 신규={stats.get('indexed', 0)}, "
            f"갱신={stats.get('updated', 0)}, "
            f"스킵={stats.get('skipped', 0)}, "
            f"오류={stats.get('errors', 0)}"
        )
    finally:
        indexer.close()


def cmd_stats(args: argparse.Namespace) -> None:  # noqa: ARG001
    indexer = MemoryIndexer()
    try:
        result = indexer.stats()
        _print_stats(result)
    finally:
        indexer.close()


# --------------------------------------------------------------------------- main


def build_parser() -> argparse.ArgumentParser:
    parser = argparse.ArgumentParser(
        prog="memory_search.py",
        description="claude 메모리 SQLite FTS5 검색 CLI",
    )
    sub = parser.add_subparsers(dest="command", metavar="{query,get,reindex,stats}")
    sub.required = True

    # query 서브커맨드
    p_query = sub.add_parser("query", help="메모리 검색")
    p_query.add_argument("query", help="검색어")
    p_query.add_argument("--type", dest="type", default=None, help="type 필터 (diary, feedback, ...)")
    p_query.add_argument("--team", dest="team", default=None, help="team_id 필터")
    p_query.add_argument("--limit", dest="limit", type=int, default=5, help="최대 결과 수 (기본 5)")
    p_query.add_argument(
        "--layer",
        dest="layer",
        default="full",
        choices=["index", "summary", "full"],
        help="출력 레이어 (index: ID/제목만, summary: +snippet 50자, full: 전체)",
    )
    p_query.set_defaults(func=cmd_query)

    # get 서브커맨드
    p_get = sub.add_parser("get", help="ID로 메모리 전체 내용 조회 (Layer 3)")
    p_get.add_argument("ids", nargs="+", type=int, help="조회할 메모리 ID 목록")
    p_get.set_defaults(func=cmd_get)

    # reindex 서브커맨드
    p_reindex = sub.add_parser("reindex", help="전체 재인덱싱")
    p_reindex.set_defaults(func=cmd_reindex)

    # stats 서브커맨드
    p_stats = sub.add_parser("stats", help="인덱스 통계")
    p_stats.set_defaults(func=cmd_stats)

    return parser


def main() -> None:
    parser = build_parser()
    args = parser.parse_args()
    args.func(args)


if __name__ == "__main__":
    main()