#!/usr/bin/env python3
"""
문서 생성 자동화 시스템
템플릿 기반 문서 자동 생성 + index.json 자동 업데이트
"""

import os
import sys
from datetime import datetime
from pathlib import Path
from typing import List, Optional

import yaml


class DocumentGenerator:
    """문서 자동 생성기"""

    def __init__(self, memory_path: str = None):
        """초기화"""
        if memory_path is None:
            memory_path = Path(__file__).parent
        self.memory_path = Path(memory_path)
        self.templates_path = self.memory_path / "templates"

        # search.py의 MemorySearchEngine import
        sys.path.insert(0, str(self.memory_path))
        from search import MemorySearchEngine

        self.search_engine = MemorySearchEngine(memory_path)

    def _generate_id(self, doc_type: str, date: str, title: str = None) -> str:
        """
        문서 ID 자동 생성

        Args:
            doc_type: 문서 타입 (daily, meeting, project)
            date: 날짜 (YYYY-MM-DD)
            title: 제목 (선택적)

        Returns:
            문서 ID
        """
        if doc_type == "daily":
            return f"{date}-daily"
        elif doc_type == "meeting":
            # 제목에서 키워드 추출
            if title:
                # 공백 제거, 특수문자 제거
                slug = title.lower().replace(" ", "-")
                slug = "".join(c for c in slug if c.isalnum() or c == "-")
                return f"{date}-{slug}-001"
            return f"{date}-meeting-001"
        elif doc_type == "project":
            # 프로젝트명-phase-N
            if title:
                slug = title.lower().replace(" ", "-")
                slug = "".join(c for c in slug if c.isalnum() or c == "-")
                return f"{slug}-phase-1"
            return f"project-phase-1"
        return f"{date}-{doc_type}-001"

    def _load_template(self, template_name: str) -> Optional[str]:
        """
        템플릿 로드

        Args:
            template_name: 템플릿 이름 (meeting, project-phase, daily)

        Returns:
            템플릿 내용
        """
        template_path = self.templates_path / f"{template_name}-template.md"

        if not template_path.exists():
            print(f"⚠️ 템플릿이 없습니다: {template_path}")
            return None

        try:
            with open(template_path, "r", encoding="utf-8") as f:
                return f.read()
        except Exception as e:
            print(f"❌ 템플릿 로드 실패: {e}")
            return None

    def _fill_template(self, template: str, metadata: dict) -> str:
        """
        템플릿 채우기

        Args:
            template: 템플릿 내용
            metadata: 메타데이터

        Returns:
            채워진 문서 내용
        """
        # YAML frontmatter 생성
        frontmatter = "---\n"
        for key, value in metadata.items():
            if isinstance(value, list):
                frontmatter += f"{key}: [{', '.join(value)}]\n"
            elif isinstance(value, str):
                frontmatter += f"{key}: {value}\n"
            else:
                frontmatter += f"{key}: {value}\n"
        frontmatter += "---\n"

        # 템플릿의 기존 frontmatter 교체
        if template.startswith("---"):
            # 기존 frontmatter 제거
            parts = template.split("---", 2)
            if len(parts) >= 3:
                content = parts[2]
            else:
                content = template
        else:
            content = template

        return frontmatter + content

    def create_meeting(
        self,
        title: str,
        date: str = None,
        host: str = "메인 관리자 (GLM-5)",
        participants: List[str] = None,
        keywords: List[str] = None,
    ) -> Optional[str]:
        """
        새 회의록 생성

        Args:
            title: 회의 제목
            date: 날짜 (YYYY-MM-DD), 없으면 오늘
            host: 주최자
            participants: 참여자 목록
            keywords: 키워드 목록

        Returns:
            생성된 파일 경로
        """
        # 날짜 설정
        if date is None:
            date = datetime.now().strftime("%Y-%m-%d")

        # 기본값 설정
        if participants is None:
            participants = ["참여자1", "참여자2"]
        if keywords is None:
            keywords = []

        # ID 생성
        doc_id = self._generate_id("meeting", date, title)

        # 파일명 생성
        slug = title.lower().replace(" ", "-")
        slug = "".join(c for c in slug if c.isalnum() or c == "-")
        filename = f"{date}-{slug}.md"

        # 메타데이터 준비
        metadata = {
            "id": doc_id,
            "date": date,
            "type": "meeting",
            "host": host,
            "participants": participants,
            "duration": "시간",
            "keywords": keywords,
            "related": [],
            "status": "planned",
        }

        # 템플릿 로드
        template = self._load_template("meeting")
        if not template:
            return None

        # 템플릿 채우기
        content = self._fill_template(template, metadata)

        # 파일 저장
        meetings_path = self.memory_path / "meetings"
        meetings_path.mkdir(exist_ok=True)

        file_path = meetings_path / filename

        try:
            with open(file_path, "w", encoding="utf-8") as f:
                f.write(content)

            print(f"✅ 회의록 생성 완료: {file_path}")

            # index.json 업데이트
            relative_path = f"meetings/{filename}"
            if self.search_engine.update_index_from_document(relative_path):
                print(f"✅ index.json 업데이트 완료")
            else:
                print(f"⚠️ index.json 업데이트 실패")

            return str(file_path)

        except Exception as e:
            print(f"❌ 파일 저장 실패: {e}")
            return None

    def create_project_phase(
        self,
        project_name: str,
        phase_number: int,
        title: str = None,
        date: str = None,
        team: str = "개발팀",
        lead: str = "팀장 (GLM-5)",
        members: List[str] = None,
        keywords: List[str] = None,
    ) -> Optional[str]:
        """
        새 프로젝트 Phase 생성

        Args:
            project_name: 프로젝트명
            phase_number: Phase 번호
            title: Phase 제목
            date: 날짜 (YYYY-MM-DD)
            team: 팀명
            lead: 팀장
            members: 팀원 목록
            keywords: 키워드 목록

        Returns:
            생성된 파일 경로
        """
        # 날짜 설정
        if date is None:
            date = datetime.now().strftime("%Y-%m-%d")

        # 제목 설정
        if title is None:
            title = f"{project_name} Phase {phase_number}"

        # 기본값 설정
        if members is None:
            members = ["팀원1 (경량 모델)", "팀원2 (경량 모델)"]
        if keywords is None:
            keywords = [project_name]

        # ID 생성
        doc_id = f"{project_name.lower().replace(' ', '-')}-phase-{phase_number}"

        # 파일명 생성
        filename = f"phase-{phase_number}-{title.lower().replace(' ', '-')}.md"

        # 메타데이터 준비
        metadata = {
            "id": doc_id,
            "date": date,
            "type": "project-phase",
            "project": project_name,
            "phase": phase_number,
            "team": team,
            "lead": lead,
            "members": members,
            "keywords": keywords,
            "related": [],
            "status": "planned",
        }

        # 템플릿 로드
        template = self._load_template("project-phase")
        if not template:
            return None

        # 템플릿 채우기
        content = self._fill_template(template, metadata)

        # 파일 저장
        projects_path = self.memory_path / "projects" / project_name.lower().replace(" ", "-") / "phases"
        projects_path.mkdir(parents=True, exist_ok=True)

        file_path = projects_path / filename

        try:
            with open(file_path, "w", encoding="utf-8") as f:
                f.write(content)

            print(f"✅ 프로젝트 Phase 생성 완료: {file_path}")

            # index.json 업데이트
            relative_path = f"projects/{project_name.lower().replace(' ', '-')}/phases/{filename}"
            if self.search_engine.update_index_from_document(relative_path):
                print(f"✅ index.json 업데이트 완료")
            else:
                print(f"⚠️ index.json 업데이트 실패")

            return str(file_path)

        except Exception as e:
            print(f"❌ 파일 저장 실패: {e}")
            return None

    def create_daily(
        self, date: str = None, author: str = "메인 관리자 (GLM-5)", keywords: List[str] = None
    ) -> Optional[str]:
        """
        일일 업무일지 생성

        Args:
            date: 날짜 (YYYY-MM-DD), 없으면 오늘
            author: 작성자
            keywords: 키워드 목록

        Returns:
            생성된 파일 경로
        """
        # 날짜 설정
        if date is None:
            date = datetime.now().strftime("%Y-%m-%d")

        # 기본값 설정
        if keywords is None:
            keywords = []

        # ID 생성
        doc_id = f"{date}-daily"

        # 파일명 생성
        filename = f"{date}.md"

        # 메타데이터 준비
        metadata = {"id": doc_id, "date": date, "type": "daily", "author": author, "keywords": keywords, "related": []}

        # 템플릿 로드
        template = self._load_template("daily")
        if not template:
            return None

        # 템플릿 채우기
        content = self._fill_template(template, metadata)

        # 파일 저장
        daily_path = self.memory_path / "daily"
        daily_path.mkdir(exist_ok=True)

        file_path = daily_path / filename

        try:
            with open(file_path, "w", encoding="utf-8") as f:
                f.write(content)

            print(f"✅ 일일 업무일지 생성 완료: {file_path}")

            # index.json 업데이트
            relative_path = f"daily/{filename}"
            if self.search_engine.update_index_from_document(relative_path):
                print(f"✅ index.json 업데이트 완료")
            else:
                print(f"⚠️ index.json 업데이트 실패")

            return str(file_path)

        except Exception as e:
            print(f"❌ 파일 저장 실패: {e}")
            return None


# 사용 예시 (테스트용)
if __name__ == "__main__":
    generator = DocumentGenerator()

    print("=" * 60)
    print("📝 문서 생성 자동화 테스트")
    print("=" * 60)

    # 1. 회의록 생성 테스트
    print("\n1️⃣ 회의록 생성 테스트")
    result = generator.create_meeting(
        title="팀장 주간 회의",
        participants=["전략기획팀장", "마케팅팀장", "개발팀장"],
        keywords=["주간 회의", "진행 상황"],
    )

    # 2. 프로젝트 Phase 생성 테스트
    print("\n2️⃣ 프로젝트 Phase 생성 테스트")
    result = generator.create_project_phase(
        project_name="InsuWiki",
        phase_number=2,
        title="Wiki CRUD 기능",
        team="개발팀",
        keywords=["InsuWiki", "Wiki", "CRUD"],
    )

    # 3. 일일 업무일지 생성 테스트
    print("\n3️⃣ 일일 업무일지 생성 테스트")
    result = generator.create_daily(keywords=["테스트", "자동화"])

    print("\n" + "=" * 60)
    print("✅ 문서 생성 자동화 준비 완료")
    print("=" * 60)