#!/usr/bin/env python3
"""
Red Team Orchestrator - 레드팀 통합 관리자

모든 검토자를 통합 관리하고 라우팅하는 orchestrator
의존성 주입 방식 (DIP 준수)
"""

import json
import sys
from pathlib import Path
from typing import Any, Dict, Mapping

# 로깅 설정
try:
    from base_reviewer import ReviewerInterface
    from code_reviewer import CodeReviewer
    from logging_config import log_error, log_execution, setup_logging
except ImportError:
    sys.path.insert(0, str(Path(__file__).parent.parent))
    from base_reviewer import ReviewerInterface
    from code_reviewer import CodeReviewer
    from logging_config import log_error, log_execution, setup_logging


class RedTeamOrchestrator:
    """레드팀 통합 관리자"""

    def __init__(self, reviewers: Mapping[str, ReviewerInterface]):
        """
        검토자 초기화 (의존성 주입)

        Args:
            reviewers: {
                "strategy": StrategyReviewer(),
                "marketing": MarketingReviewer(),
                "insurance": InsuranceReviewer(),
                "code": CodeReviewer()
            }
        """
        self.reviewers = reviewers
        self.logger = setup_logging("red_team.orchestrator")
        log_execution(self.logger, "RedTeamOrchestrator initialized", {"reviewer_types": list(reviewers.keys())})

    def review(self, doc_type: str, doc: str) -> Dict[str, Any]:
        """
        문서 검토 (라우팅)

        Args:
            doc_type: "strategy"|"marketing"|"insurance"|"code"
            doc: 문서 내용 또는 파일 경로

        Returns:
            검토 결과 (해당 reviewer의 출력)

        Raises:
            ValueError: 알 수 없는 doc_type인 경우
        """
        try:
            log_execution(
                self.logger, "Review requested", {"doc_type": doc_type, "doc": doc[:100]}  # Truncate for logging
            )

            reviewer = self.reviewers.get(doc_type)
            if not reviewer:
                error_msg = f"Unknown doc_type: {doc_type}"
                log_error(
                    self.logger,
                    ValueError(error_msg),
                    {"doc_type": doc_type, "available_types": list(self.reviewers.keys())},
                )
                return {"error": error_msg, "available_types": list(self.reviewers.keys()), "risk_level": "unknown"}

            result = reviewer.review(doc)
            log_execution(
                self.logger,
                "Review completed",
                {"doc_type": doc_type, "risk_level": result.get("risk_level", "unknown")},
            )

            return result

        except Exception as e:
            log_error(self.logger, e, {"doc_type": doc_type, "doc": doc[:100]})
            return {"error": str(e), "risk_level": "critical", "passed": False}

    def get_available_types(self) -> list:
        """
        사용 가능한 검토 타입 반환

        Returns:
            ["strategy", "marketing", "insurance", "code"]
        """
        return list(self.reviewers.keys())


def main():
    """CLI 인터페이스"""
    if len(sys.argv) < 2:
        print(
            json.dumps({"error": "Usage: python3 red_team_orchestrator.py <command>", "commands": ["types", "review"]})
        )
        sys.exit(1)

    command = sys.argv[1]

    # 의존성 주입 (DIP 준수)
    reviewers = {
        # 현재는 코드 검토만 구현됨
        # "strategy": StrategyReviewer(),
        # "marketing": MarketingReviewer(),
        # "insurance": InsuranceReviewer(),
        "code": CodeReviewer()
    }

    orchestrator = RedTeamOrchestrator(reviewers)

    if command == "test":
        # 실행 테스트용
        print(
            json.dumps(
                {
                    "status": "loaded",
                    "orchestrator": "RedTeamOrchestrator",
                    "available_types": orchestrator.get_available_types(),
                    "reviewers_loaded": len(reviewers),
                }
            )
        )

    elif command == "types":
        # 사용 가능한 타입 확인
        print(
            json.dumps(
                {
                    "available_types": orchestrator.get_available_types(),
                    "note": "현재 코드 검토만 지원. 전략/마케팅/보험은 추후 확장 예정",
                },
                indent=2,
                ensure_ascii=False,
            )
        )

    elif command == "review":
        # 검토 실행
        if len(sys.argv) < 4:
            print(
                json.dumps(
                    {
                        "error": "review command requires doc_type and doc",
                        "usage": "python3 red_team_orchestrator.py review <type> <doc>",
                        "available_types": orchestrator.get_available_types(),
                    }
                )
            )
            sys.exit(1)

        doc_type = sys.argv[2]
        doc = sys.argv[3]

        result = orchestrator.review(doc_type, doc)
        print(json.dumps(result, indent=2, ensure_ascii=False))

    else:
        print(json.dumps({"error": f"Unknown command: {command}", "commands": ["types", "review"]}))
        sys.exit(1)


if __name__ == "__main__":
    main()