/**
 * 기획서 자동 생성 엔진
 * 템플릿과 요구사항을 바탕으로 완성된 기획서 생성
 */

const fs = require('fs').promises;
const path = require('path');

class ProposalGenerator {
  constructor() {
    this.template = null;
    this.projectInfo = null;
  }

  /**
   * 템플릿 로드
   */
  async loadTemplate(templatePath) {
    try {
      const templateContent = await fs.readFile(templatePath, 'utf8');
      this.template = JSON.parse(templateContent);
      console.log(`📋 템플릿 로드: ${this.template.template_info.name}`);
      return this.template;
    } catch (error) {
      console.error("❌ 템플릿 로드 실패:", error);
      throw error;
    }
  }

  /**
   * 프로젝트 정보 설정
   */
  setProjectInfo(projectInfo) {
    this.projectInfo = {
      name: projectInfo.name || "새 프로젝트",
      type: projectInfo.type || "web_service",
      company: projectInfo.company || "Company Name",
      author: projectInfo.author || "작성자",
      description: projectInfo.description || "",
      requirements: projectInfo.requirements || [],
      features: projectInfo.features || [],
      target_users: projectInfo.target_users || [],
      ...projectInfo
    };
    console.log(`🎯 프로젝트 설정: ${this.projectInfo.name}`);
  }

  /**
   * 기획서 생성
   */
  async generate() {
    if (!this.template || !this.projectInfo) {
      throw new Error("템플릿과 프로젝트 정보가 필요합니다.");
    }

    console.log("📝 기획서 생성 중...");

    const proposal = {
      metadata: this.generateMetadata(),
      cover: this.generateCover(),
      document_history: this.generateDocumentHistory(),
      menu_structure: this.generateMenuStructure(),
      common_guidelines: this.generateCommonGuidelines(),
      detail_screens: this.generateDetailScreens()
    };

    return proposal;
  }

  /**
   * 메타데이터 생성
   */
  generateMetadata() {
    return {
      title: this.projectInfo.name,
      subtitle: `${this.projectInfo.type} 프로젝트 기획서`,
      version: "D1.0",
      created_date: new Date().toISOString().split('T')[0].replace(/-/g, '.'),
      author: this.projectInfo.author,
      company: this.projectInfo.company,
      total_pages: this.estimatePageCount(),
      template_used: this.template.template_info.name
    };
  }

  /**
   * 표지 생성
   */
  generateCover() {
    return {
      type: "cover",
      title: this.projectInfo.name,
      subtitle: this.generateSubtitle(),
      date: new Date().toISOString().split('T')[0].replace(/-/g, '.'),
      version: "D1.0",
      company: this.projectInfo.company,
      author: this.projectInfo.author,
      description: this.projectInfo.description
    };
  }

  /**
   * 부제목 자동 생성
   */
  generateSubtitle() {
    const typeMapping = {
      'mobile_app': '모바일 애플리케이션',
      'web_service': '웹 서비스',
      'erp_system': 'ERP 시스템',
      'ecommerce': '이커머스 플랫폼',
      'cms': '콘텐츠 관리 시스템',
      'crm': '고객관계관리 시스템'
    };

    return `${typeMapping[this.projectInfo.type] || '시스템'} 기획서`;
  }

  /**
   * 문서 히스토리 생성
   */
  generateDocumentHistory() {
    const today = new Date().toISOString().split('T')[0].replace(/-/g, '.');

    return {
      type: "document_history",
      table: [
        {
          date: today,
          version: "D1.0",
          main_content: "초안 작성",
          detailed_content: `${this.projectInfo.name} 프로젝트 기획서 초안 작성`,
          mark: ""
        }
      ]
    };
  }

  /**
   * 메뉴 구조 생성
   */
  generateMenuStructure() {
    let menuStructure;

    if (this.projectInfo.requirements && this.projectInfo.requirements.length > 0) {
      // 요구사항에서 메뉴 구조 추출
      menuStructure = this.extractMenuFromRequirements();
    } else {
      // 기본 구조 사용
      menuStructure = this.getDefaultMenuStructure();
    }

    return {
      type: "menu_structure",
      title: "Menu Structure",
      structure: menuStructure
    };
  }

  /**
   * 요구사항에서 메뉴 구조 추출
   */
  extractMenuFromRequirements() {
    const requirements = this.projectInfo.requirements;
    const menuMap = new Map();

    // 요구사항을 카테고리별로 분류
    requirements.forEach(req => {
      const category = req.category || this.guessCategory(req.title);
      if (!menuMap.has(category)) {
        menuMap.set(category, []);
      }
      menuMap.get(category).push({
        name: req.title,
        description: req.description,
        priority: req.priority || 'medium'
      });
    });

    // 계층 구조로 변환
    const structure = {
      root: this.projectInfo.name,
      children: []
    };

    for (const [category, items] of menuMap) {
      structure.children.push({
        name: category,
        children: items.map(item => ({
          name: item.name,
          leaf: true,
          description: item.description
        }))
      });
    }

    return structure;
  }

  /**
   * 카테고리 추측
   */
  guessCategory(title) {
    const categoryKeywords = {
      '사용자관리': ['사용자', '회원', '계정', '인증', '로그인'],
      '콘텐츠관리': ['게시글', '콘텐츠', '글', '포스트', '댓글'],
      '결제관리': ['결제', '구매', '주문', '결제수단', '카드'],
      '상품관리': ['상품', '제품', '상품목록', '카탈로그'],
      '시스템관리': ['설정', '관리자', '백오피스', '시스템'],
      '통계/분석': ['통계', '분석', '리포트', '대시보드', '차트']
    };

    for (const [category, keywords] of Object.entries(categoryKeywords)) {
      if (keywords.some(keyword => title.includes(keyword))) {
        return category;
      }
    }

    return '기타기능';
  }

  /**
   * 기본 메뉴 구조
   */
  getDefaultMenuStructure() {
    const defaultStructures = {
      'mobile_app': {
        root: "모바일 앱",
        children: [
          { name: "인증", children: ["로그인", "회원가입", "비밀번호 찾기"] },
          { name: "메인", children: ["홈", "검색", "카테고리"] },
          { name: "사용자", children: ["프로필", "설정", "알림"] },
          { name: "콘텐츠", children: ["목록", "상세", "작성"] }
        ]
      },
      'web_service': {
        root: "웹 서비스",
        children: [
          { name: "사용자관리", children: ["회원가입", "로그인", "프로필관리"] },
          { name: "콘텐츠관리", children: ["작성", "편집", "삭제", "검색"] },
          { name: "시스템관리", children: ["설정", "통계", "백업"] }
        ]
      }
    };

    return defaultStructures[this.projectInfo.type] || defaultStructures['web_service'];
  }

  /**
   * 공통 가이드라인 생성
   */
  generateCommonGuidelines() {
    return {
      type: "common_guidelines",
      sections: [
        {
          title: "사용자 인터랙션",
          content: this.generateInteractionGuidelines()
        },
        {
          title: "반응형 디자인",
          content: this.generateResponsiveGuidelines()
        },
        {
          title: "화면 템플릿",
          content: this.generateScreenTemplateGuidelines()
        },
        {
          title: "알림 시스템",
          content: this.generateNotificationGuidelines()
        }
      ]
    };
  }

  /**
   * 인터랙션 가이드라인 생성
   */
  generateInteractionGuidelines() {
    const interactions = [
      { type: "Tap", description: "일정영역을 사용자가 터치합니다.", apply: "Yes" },
      { type: "Scroll Up/Down", description: "상하 스크롤 동작", apply: "Yes" },
      { type: "Swipe Left/Right", description: "좌우 스와이프 동작", apply: "Yes" },
      { type: "Drag & Drop", description: "드래그 앤 드롭 기능", apply: "Yes" }
    ];

    return {
      type: "interaction_table",
      data: interactions
    };
  }

  /**
   * 반응형 가이드라인 생성
   */
  generateResponsiveGuidelines() {
    return {
      type: "responsive_guide",
      breakpoints: [
        { device: "모바일", range: "< 640px", note: "기본" },
        { device: "태블릿", range: "768px ~ 1023px", note: "md" },
        { device: "데스크탑", range: "1024px+", note: "lg" },
        { device: "대형 모니터", range: "1280px+", note: "xl" }
      ]
    };
  }

  /**
   * 화면 템플릿 가이드라인 생성
   */
  generateScreenTemplateGuidelines() {
    return {
      type: "screen_template",
      elements: [
        { name: "Header", description: "상단 네비게이션 및 타이틀" },
        { name: "Content", description: "주요 콘텐츠 영역" },
        { name: "Footer", description: "하단 정보 및 링크" },
        { name: "Sidebar", description: "사이드 메뉴 (PC 버전)" }
      ]
    };
  }

  /**
   * 알림 시스템 가이드라인 생성
   */
  generateNotificationGuidelines() {
    return {
      type: "notification_guide",
      types: [
        { name: "알림 Alert", description: "사용자에게 상황을 알려주기 위한 팝업" },
        { name: "확인 Alert", description: "사용자에게 확인이 필요할 경우 제공되는 팝업" },
        { name: "토스트 메시지", description: "단순 Notify (2~3)초 후 페이지 내에서 Fade out" }
      ]
    };
  }

  /**
   * 상세 화면 생성
   */
  generateDetailScreens() {
    const screens = [];

    if (this.projectInfo.features && this.projectInfo.features.length > 0) {
      // 기능 목록에서 화면 생성
      this.projectInfo.features.forEach((feature, index) => {
        screens.push(this.generateScreenFromFeature(feature, index));
      });
    } else if (this.projectInfo.requirements && this.projectInfo.requirements.length > 0) {
      // 요구사항에서 화면 생성
      this.projectInfo.requirements.forEach((req, index) => {
        screens.push(this.generateScreenFromRequirement(req, index));
      });
    } else {
      // 기본 화면들 생성
      screens.push(...this.generateDefaultScreens());
    }

    return {
      type: "detail_screens",
      screens: screens
    };
  }

  /**
   * 기능에서 화면 생성
   */
  generateScreenFromFeature(feature, index) {
    return {
      page_number: 10 + index, // 기본 페이지 이후
      screen_info: {
        task_name: this.projectInfo.name,
        version: "D1.0",
        route: this.generateRoute(feature.name),
        screen_name: feature.name,
        screen_id: this.generateScreenId(feature.name)
      },
      wireframe: {
        type: "feature_screen",
        description: `${feature.name} 화면 구성`,
        elements: this.generateUIElements(feature)
      },
      descriptions: this.generateFeatureDescriptions(feature)
    };
  }

  /**
   * 요구사항에서 화면 생성
   */
  generateScreenFromRequirement(requirement, index) {
    return {
      page_number: 10 + index,
      screen_info: {
        task_name: this.projectInfo.name,
        version: "D1.0",
        route: this.generateRoute(requirement.title),
        screen_name: requirement.title,
        screen_id: this.generateScreenId(requirement.title)
      },
      wireframe: {
        type: "requirement_screen",
        description: `${requirement.title} 화면`,
        elements: this.generateUIElementsFromRequirement(requirement)
      },
      descriptions: this.generateRequirementDescriptions(requirement)
    };
  }

  /**
   * 기본 화면들 생성
   */
  generateDefaultScreens() {
    const defaultScreens = [
      {
        name: "메인 화면",
        route: "/main",
        features: ["네비게이션", "주요 콘텐츠", "검색"]
      },
      {
        name: "로그인",
        route: "/auth/login",
        features: ["이메일 입력", "비밀번호 입력", "로그인 버튼"]
      },
      {
        name: "목록 화면",
        route: "/list",
        features: ["검색 필터", "목록 표시", "페이지네이션"]
      }
    ];

    return defaultScreens.map((screen, index) => ({
      page_number: 10 + index,
      screen_info: {
        task_name: this.projectInfo.name,
        version: "D1.0",
        route: screen.route,
        screen_name: screen.name,
        screen_id: this.generateScreenId(screen.name)
      },
      wireframe: {
        type: "default_screen",
        description: `${screen.name} 구성`,
        elements: screen.features
      },
      descriptions: this.generateDefaultDescriptions(screen)
    }));
  }

  /**
   * 라우트 생성
   */
  generateRoute(screenName) {
    return '/' + screenName
      .toLowerCase()
      .replace(/\s+/g, '_')
      .replace(/[^a-z0-9_]/g, '');
  }

  /**
   * 화면 ID 생성
   */
  generateScreenId(screenName) {
    return screenName
      .toLowerCase()
      .replace(/\s+/g, '_')
      .replace(/[^a-z0-9_]/g, '');
  }

  /**
   * UI 요소 생성
   */
  generateUIElements(feature) {
    // 기능 타입에 따른 UI 요소 자동 생성
    const elementMap = {
      'login': ['이메일 입력', '비밀번호 입력', '로그인 버튼', '회원가입 링크'],
      'list': ['검색바', '필터', '목록 아이템', '페이지네이션'],
      'form': ['입력 필드', '제출 버튼', '취소 버튼', '유효성 검사'],
      'detail': ['제목', '내용', '수정 버튼', '삭제 버튼', '목록으로 버튼']
    };

    const featureType = this.guessFeatureType(feature.name);
    return elementMap[featureType] || ['헤더', '메인 콘텐츠', '푸터'];
  }

  /**
   * 기능 타입 추측
   */
  guessFeatureType(featureName) {
    const typeKeywords = {
      'login': ['로그인', '인증', '로그인'],
      'list': ['목록', '리스트', '조회'],
      'form': ['등록', '작성', '입력', '수정'],
      'detail': ['상세', '세부', '정보']
    };

    for (const [type, keywords] of Object.entries(typeKeywords)) {
      if (keywords.some(keyword => featureName.includes(keyword))) {
        return type;
      }
    }

    return 'default';
  }

  /**
   * 기능 설명 생성
   */
  generateFeatureDescriptions(feature) {
    const descriptions = [];

    if (feature.elements) {
      feature.elements.forEach((element, index) => {
        descriptions.push({
          number: index + 1,
          title: element,
          description: `${element} 기능 구현`
        });
      });
    }

    return descriptions;
  }

  /**
   * 페이지 수 추정
   */
  estimatePageCount() {
    let pageCount = 5; // 기본 페이지 (표지, 히스토리, 구조, 가이드라인)

    if (this.projectInfo.features) {
      pageCount += this.projectInfo.features.length;
    } else if (this.projectInfo.requirements) {
      pageCount += this.projectInfo.requirements.length;
    } else {
      pageCount += 3; // 기본 화면 수
    }

    return pageCount;
  }

  /**
   * Markdown 형태로 기획서 출력
   */
  async exportToMarkdown(proposal, outputPath) {
    const markdown = this.generateMarkdown(proposal);

    const outputDir = path.dirname(outputPath);
    await fs.mkdir(outputDir, { recursive: true });

    await fs.writeFile(outputPath, markdown, 'utf8');
    console.log(`📄 Markdown 기획서 생성: ${outputPath}`);

    return outputPath;
  }

  /**
   * Markdown 생성
   */
  generateMarkdown(proposal) {
    let markdown = '';

    // 표지
    markdown += `# ${proposal.cover.title}\n`;
    markdown += `## ${proposal.cover.subtitle}\n\n`;
    markdown += `**버전**: ${proposal.cover.version}  \n`;
    markdown += `**작성일**: ${proposal.cover.date}  \n`;
    markdown += `**작성자**: ${proposal.cover.author}  \n`;
    markdown += `**회사**: ${proposal.cover.company}  \n\n`;

    if (proposal.cover.description) {
      markdown += `**프로젝트 설명**: ${proposal.cover.description}\n\n`;
    }

    markdown += `---\n\n`;

    // 문서 히스토리
    markdown += `## Document History\n\n`;
    markdown += `| 날짜 | 버전 | 주요 내용 | 상세 내용 | 비고 |\n`;
    markdown += `|------|------|-----------|-----------|------|\n`;

    proposal.document_history.table.forEach(row => {
      markdown += `| ${row.date} | ${row.version} | ${row.main_content} | ${row.detailed_content} | ${row.mark} |\n`;
    });

    markdown += `\n---\n\n`;

    // 메뉴 구조
    markdown += `## Menu Structure\n\n`;
    markdown += this.generateMenuMarkdown(proposal.menu_structure.structure);
    markdown += `\n---\n\n`;

    // 공통 가이드라인
    markdown += `## 공통 가이드라인\n\n`;
    proposal.common_guidelines.sections.forEach(section => {
      markdown += `### ${section.title}\n\n`;
      markdown += this.generateSectionMarkdown(section.content);
      markdown += `\n`;
    });

    markdown += `---\n\n`;

    // 상세 화면들
    markdown += `## 상세 화면 설계\n\n`;
    proposal.detail_screens.screens.forEach((screen, index) => {
      markdown += `### 슬라이드 ${screen.page_number}: ${screen.screen_info.screen_name}\n\n`;

      markdown += `**화면 정보**:\n`;
      markdown += `- 단위업무명: ${screen.screen_info.task_name}\n`;
      markdown += `- 경로: ${screen.screen_info.route}\n`;
      markdown += `- 화면 ID: ${screen.screen_info.screen_id}\n`;
      markdown += `- 버전: ${screen.screen_info.version}\n\n`;

      markdown += `**화면 구성**:\n`;
      if (Array.isArray(screen.wireframe.elements)) {
        screen.wireframe.elements.forEach((element, idx) => {
          markdown += `${idx + 1}. ${element}\n`;
        });
      }

      markdown += `\n**기능 설명**:\n`;
      if (screen.descriptions && screen.descriptions.length > 0) {
        screen.descriptions.forEach(desc => {
          markdown += `${desc.number}. **${desc.title}**: ${desc.description}\n`;
        });
      }

      markdown += `\n---\n\n`;
    });

    return markdown;
  }

  /**
   * 메뉴 구조 Markdown 생성
   */
  generateMenuMarkdown(structure, depth = 0) {
    let markdown = '';
    const indent = '  '.repeat(depth);

    if (structure.root && depth === 0) {
      markdown += `- **${structure.root}**\n`;
    }

    if (structure.children) {
      structure.children.forEach(child => {
        if (typeof child === 'string') {
          markdown += `${indent}- ${child}\n`;
        } else {
          markdown += `${indent}- **${child.name}**\n`;
          if (child.children) {
            child.children.forEach(subChild => {
              const subIndent = '  '.repeat(depth + 1);
              if (typeof subChild === 'string') {
                markdown += `${subIndent}- ${subChild}\n`;
              } else {
                markdown += `${subIndent}- ${subChild.name}\n`;
              }
            });
          }
        }
      });
    }

    return markdown;
  }

  /**
   * 섹션 Markdown 생성
   */
  generateSectionMarkdown(content) {
    if (content.type === 'interaction_table') {
      let markdown = `| Type | Description | Apply |\n|------|-------------|-------|\n`;
      content.data.forEach(item => {
        markdown += `| ${item.type} | ${item.description} | ${item.apply} |\n`;
      });
      return markdown;
    }

    if (content.type === 'responsive_guide') {
      let markdown = `**브레이크 포인트**:\n`;
      content.breakpoints.forEach(bp => {
        markdown += `- ${bp.device}: ${bp.range} (${bp.note})\n`;
      });
      return markdown;
    }

    return JSON.stringify(content, null, 2);
  }

  // 요구사항에서 UI 요소 생성
  generateUIElementsFromRequirement(requirement) {
    // 요구사항 설명에서 UI 요소 추출 (간단한 키워드 매칭)
    const description = requirement.description || requirement.title;
    const elements = [];

    // 일반적인 UI 패턴 매칭
    if (description.includes('로그인') || description.includes('인증')) {
      elements.push('이메일 입력', '비밀번호 입력', '로그인 버튼');
    }
    if (description.includes('목록') || description.includes('조회')) {
      elements.push('검색바', '필터', '목록 아이템');
    }
    if (description.includes('등록') || description.includes('작성')) {
      elements.push('입력 폼', '제출 버튼', '취소 버튼');
    }

    // 기본 요소가 없으면 일반적인 화면 구성 추가
    if (elements.length === 0) {
      elements.push('헤더', '메인 콘텐츠', '네비게이션');
    }

    return elements;
  }

  // 요구사항 설명 생성
  generateRequirementDescriptions(requirement) {
    const descriptions = [];

    descriptions.push({
      number: 1,
      title: requirement.title,
      description: requirement.description || `${requirement.title} 기능 구현`
    });

    // 우선순위가 있으면 추가
    if (requirement.priority) {
      descriptions.push({
        number: 2,
        title: "우선순위",
        description: `개발 우선순위: ${requirement.priority}`
      });
    }

    return descriptions;
  }

  // 기본 설명 생성
  generateDefaultDescriptions(screen) {
    const descriptions = [];

    screen.features.forEach((feature, index) => {
      descriptions.push({
        number: index + 1,
        title: feature,
        description: `${feature} 구현 및 사용자 인터랙션 처리`
      });
    });

    return descriptions;
  }
}

// 명령줄 실행 지원
async function main() {
  const args = process.argv.slice(2);

  if (args.includes('--help')) {
    console.log(`
📝 기획서 생성기 사용법:

기본 사용:
  node proposal-generator.js

프로젝트 정보로 생성:
  node proposal-generator.js --project project.json --output proposal.md

템플릿 지정:
  node proposal-generator.js --template template.json --project project.json

예시:
  node proposal-generator.js --project "모바일 앱" --type mobile_app --output mobile_proposal.md
    `);
    return;
  }

  try {
    const generator = new ProposalGenerator();

    // 템플릿 로드
    const templatePath = '.claude/skills/proposal-skill/templates/erp_storyboard_template.json';
    await generator.loadTemplate(templatePath);

    // 샘플 프로젝트 정보
    const sampleProject = {
      name: "모바일 쇼핑몰 앱",
      type: "mobile_app",
      company: "Sample Company",
      author: "기획팀",
      description: "사용자 친화적인 모바일 쇼핑 경험을 제공하는 앱",
      requirements: [
        {
          title: "사용자 로그인",
          description: "이메일/비밀번호를 통한 사용자 인증 기능",
          category: "사용자관리",
          priority: "high"
        },
        {
          title: "상품 목록 조회",
          description: "카테고리별 상품 목록 및 검색 기능",
          category: "상품관리",
          priority: "high"
        },
        {
          title: "장바구니",
          description: "상품 선택 및 장바구니 관리 기능",
          category: "결제관리",
          priority: "medium"
        }
      ]
    };

    generator.setProjectInfo(sampleProject);

    const proposal = await generator.generate();
    const outputPath = 'output/sample_proposal.md';

    await generator.exportToMarkdown(proposal, outputPath);

    console.log("✅ 샘플 기획서 생성 완료!");
    console.log(`📄 출력 파일: ${outputPath}`);

  } catch (error) {
    console.error("❌ 기획서 생성 실패:", error);
  }
}

if (require.main === module) {
  main();
}

module.exports = { ProposalGenerator };