// 예: 로그인 기능 구현
// src/components/LoginForm.jsx
import React, { useState } from 'react';

export default function LoginForm() {
  const [email, setEmail] = useState('');
  const [password, setPassword] = useState('');
  const [error, setError] = useState('');

  const handleSubmit = async (e) => {
    e.preventDefault();
    try {
      const response = await fetch('/api/login', {
        method: 'POST',
        headers: { 'Content-Type': 'application/json' },
        body: JSON.stringify({ email, password })
      });
      // 로그인 로직...
    } catch (err) {
      setError('로그인 실패');
    }
  };

  return (
    <form onSubmit={handleSubmit}>
      {/* 폼 필드... */}
    </form>
  );
}

// tests/e2e/login.test.js
const puppeteer = require('puppeteer');

describe('Login Feature', () => {
  let browser;
  let page;

  beforeAll(async () => {
    browser = await puppeteer.launch();
    page = await browser.newPage();
  });

  test('사용자가 올바른 자격증명으로 로그인할 수 있어야 함', async () => {
    await page.goto('http://localhost:3000/login');
    
    // 이메일 입력
    await page.type('#email', '[email protected]');
    
    // 비밀번호 입력
    await page.type('#password', 'password123');
    
    // 로그인 버튼 클릭
    await page.click('button[type="submit"]');
    
    // 대시보드로 리다이렉트 확인
    await page.waitForNavigation();
    expect(page.url()).toContain('/dashboard');
    
    // 스크린샷 저장
    await page.screenshot({ 
      path: 'verification/login-success.png' 
    });
  });

  afterAll(async () => {
    await browser.close();
  });
});

// tools/validators.js
class FeatureValidator {
  validate(code, tests) {
    const checks = {
      hasTests: tests.length > 0,
      hasDocumentation: code.includes('/**'),
      hasErrorHandling: code.includes('try') || code.includes('catch'),
      followsNaming: this.checkNamingConvention(code),
      hasTypeChecks: code.includes('PropTypes') || code.includes('TypeScript')
    };
    
    return Object.values(checks).every(Boolean);
  }
}

// tests/visual/feature-verification.js
async function verifyFeature(featureId, scenarios) {
  const browser = await puppeteer.launch({ headless: false });
  const page = await browser.newPage();
  const results = [];

  for (const scenario of scenarios) {
    try {
      // 시나리오 실행
      await scenario.run(page);
      
      // 스크린샷 저장
      const screenshotPath = `verification/feature-${featureId}-${scenario.name}.png`;
      await page.screenshot({ path: screenshotPath, fullPage: true });
      
      // 결과 기록
      results.push({
        scenario: scenario.name,
        passed: true,
        screenshot: screenshotPath
      });
    } catch (error) {
      results.push({
        scenario: scenario.name,
        passed: false,
        error: error.message
      });
    }
  }

  await browser.close();
  return results;
}

// tests/e2e-automation.js
const { chromium } = require('playwright');

async function runFeatureTest(featureId, testScenarios) {
  const browser = await chromium.launch({ headless: false });
  const context = await browser.newContext({
    viewport: { width: 1280, height: 720 },
    recordVideo: { dir: `verification/videos/feature-${featureId}/` }
  });
  const page = await context.newPage();
  
  const results = [];
  
  for (const scenario of testScenarios) {
    console.log(`Testing: ${scenario.name}`);
    
    try {
      // 시나리오 실행
      await page.goto('http://localhost:3000');
      await scenario.execute(page);
      
      // 스크린샷 캡처
      const screenshotPath = `verification/feature-${featureId}-${scenario.name}.png`;
      await page.screenshot({ 
        path: screenshotPath,
        fullPage: true 
      });
      
      // 결과 저장
      results.push({
        feature: featureId,
        scenario: scenario.name,
        passed: true,
        screenshot: screenshotPath,
        timestamp: new Date().toISOString()
      });
      
      console.log(`✓ ${scenario.name} passed`);
      
    } catch (error) {
      results.push({
        feature: featureId,
        scenario: scenario.name,
        passed: false,
        error: error.message,
        timestamp: new Date().toISOString()
      });
      
      console.error(`✗ ${scenario.name} failed: ${error.message}`);
    }
  }
  
  await context.close();
  await browser.close();
  
  // 테스트 결과 저장
  const fs = require('fs');
  fs.writeFileSync(
    `verification/feature-${featureId}-results.json`,
    JSON.stringify(results, null, 2)
  );
  
  return results.every(r => r.passed);
}

module.exports = { runFeatureTest };

// tools/progress-tracker.js
const fs = require('fs');

class ProgressTracker {
  constructor(featureListPath) {
    this.featureListPath = featureListPath;
    this.features = JSON.parse(fs.readFileSync(featureListPath, 'utf8')).features;
  }
  
  getStats() {
    const total = this.features.length;
    const completed = this.features.filter(f => f.passes).length;
    const percentage = ((completed / total) * 100).toFixed(1);
    
    return {
      total,
      completed,
      remaining: total - completed,
      percentage,
      estimatedHoursRemaining: (total - completed) * 0.75 // 기능당 45분 가정
    };
  }
  
  generateReport() {
    const stats = this.getStats();
    const byPriority = {
      high: this.features.filter(f => !f.passes && f.priority === 'high').length,
      medium: this.features.filter(f => !f.passes && f.priority === 'medium').length,
      low: this.features.filter(f => !f.passes && f.priority === 'low').length
    };
    
    return `
# 프로젝트 진행 상황

## 전체 현황
- 총 기능: ${stats.total}
- 완료: ${stats.completed} (${stats.percentage}%)
- 남은 작업: ${stats.remaining}
- 예상 소요 시간: ${stats.estimatedHoursRemaining.toFixed(1)}시간

## 우선순위별 남은 작업
- High: ${byPriority.high}
- Medium: ${byPriority.medium}
- Low: ${byPriority.low}

## 진행 바
${'█'.repeat(Math.floor(stats.percentage / 5))}${'░'.repeat(20 - Math.floor(stats.percentage / 5))} ${stats.percentage}%
    `;
  }
  
  getNextFeature() {
    // 우선순위 순으로 다음 미완료 기능 반환
    const priorities = ['high', 'medium', 'low'];
    
    for (const priority of priorities) {
      const next = this.features.find(
        f => !f.passes && f.priority === priority
      );
      if (next) return next;
    }
    
    return null;
  }
}

// 사용 예시
const tracker = new ProgressTracker('./feature_list.json');
console.log(tracker.generateReport());

const nextFeature = tracker.getNextFeature();
if (nextFeature) {
  console.log(`\n다음 작업: Feature #${nextFeature.id} - ${nextFeature.title}`);
} else {
  console.log('\n🎉 모든 기능이 완료되었습니다!');
}

// tools/session-validator.js
const fs = require('fs');
const path = require('path');

class SessionValidator {
  constructor(projectDir) {
    this.projectDir = projectDir;
    this.requiredFiles = [
      'feature_list.json',
      'app_spec.txt',
      'claude-progress.txt',
      'init.sh'
    ];
  }
  
  validateSessionStart() {
    const errors = [];
    const warnings = [];
    
    // 1. 필수 파일 존재 확인
    for (const file of this.requiredFiles) {
      const filePath = path.join(this.projectDir, file);
      if (!fs.existsSync(filePath)) {
        errors.push(`필수 파일 누락: ${file}`);
      }
    }
    
    // 2. feature_list.json 무결성 검사
    try {
      const featureList = JSON.parse(
        fs.readFileSync(path.join(this.projectDir, 'feature_list.json'))
      );
      
      if (!Array.isArray(featureList.features)) {
        errors.push('feature_list.json의 features가 배열이 아닙니다');
      }
      
      // 중복 ID 확인
      const ids = featureList.features.map(f => f.id);
      const duplicates = ids.filter((id, index) => ids.indexOf(id) !== index);
      if (duplicates.length > 0) {
        errors.push(`중복된 feature ID: ${duplicates.join(', ')}`);
      }
      
      // passes:true인데 커밋이 없는 경우
      const { execSync } = require('child_process');
      const gitLog = execSync('git log --oneline', { 
        cwd: this.projectDir 
      }).toString();
      
      for (const feature of featureList.features) {
        if (feature.passes && !gitLog.includes(`#${feature.id}`)) {
          warnings.push(
            `Feature #${feature.id}가 passes:true이지만 Git 커밋이 없습니다`
          );
        }
      }
      
    } catch (error) {
      errors.push(`feature_list.json 파싱 실패: ${error.message}`);
    }
    
    // 3. Git 상태 확인
    try {
      const { execSync } = require('child_process');
      const status = execSync('git status --porcelain', {
        cwd: this.projectDir
      }).toString();
      
      if (status.trim()) {
        warnings.push('이전 세션의 미커밋 변경사항이 있습니다');
      }
    } catch (error) {
      errors.push('Git 저장소 확인 실패');
    }
    
    return { errors, warnings, valid: errors.length === 0 };
  }
  
  generateSessionReport() {
    const validation = this.validateSessionStart();
    
    let report = '# 세션 검증 보고서\n\n';
    
    if (validation.valid) {
      report += '✅ 모든 검증 통과\n\n';
    } else {
      report += '❌ 검증 실패\n\n';
      report += '## 에러\n';
      validation.errors.forEach(error => {
        report += `- ${error}\n`;
      });
      report += '\n';
    }
    
    if (validation.warnings.length > 0) {
      report += '## 경고\n';
      validation.warnings.forEach(warning => {
        report += `- ${warning}\n`;
      });
    }
    
    return report;
  }
}

module.exports = SessionValidator;

// tools/priority-adjuster.js
class DynamicPriorityAdjuster {
  constructor(featureListPath) {
    this.featureListPath = featureListPath;
    this.features = this.loadFeatures();
  }
  
  loadFeatures() {
    const fs = require('fs');
    const data = JSON.parse(fs.readFileSync(this.featureListPath, 'utf8'));
    return data.features;
  }
  
  adjustPriorities() {
    // 1. 의존성 분석
    const dependencyGraph = this.buildDependencyGraph();
    
    // 2. 차단된 기능 우선순위 상승
    for (const feature of this.features) {
      if (!feature.passes) {
        const blockingCount = this.countBlockedFeatures(feature.id, dependencyGraph);
        
        if (blockingCount > 5) {
          feature.priority = 'high';
          feature.adjustmentReason = `${blockingCount}개 기능을 차단 중`;
        }
      }
    }
    
    // 3. 빠른 승리(Quick Wins) 식별
    for (const feature of this.features) {
      if (!feature.passes && feature.estimatedMinutes < 30) {
        if (feature.priority === 'low') {
          feature.priority = 'medium';
          feature.adjustmentReason = '빠른 승리 가능';
        }
      }
    }
    
    // 4. 장기 미완료 기능 우선순위 상승
    const now = new Date();
    for (const feature of this.features) {
      if (feature.createdAt) {
        const daysSinceCreation = (now - new Date(feature.createdAt)) / (1000 * 60 * 60 * 24);
        
        if (daysSinceCreation > 7 && !feature.passes) {
          feature.priority = 'high';
          feature.adjustmentReason = `${Math.floor(daysSinceCreation)}일째 미완료`;
        }
      }
    }
    
    this.saveFeatures();
  }
  
  buildDependencyGraph() {
    const graph = {};
    
    for (const feature of this.features) {
      graph[feature.id] = {
        dependsOn: feature.dependsOn || [],
        blockedBy: []
      };
    }
    
    // 역방향 의존성 계산
    for (const feature of this.features) {
      if (feature.dependsOn) {
        for (const depId of feature.dependsOn) {
          if (graph[depId]) {
            graph[depId].blockedBy.push(feature.id);
          }
        }
      }
    }
    
    return graph;
  }
  
  countBlockedFeatures(featureId, graph) {
    if (!graph[featureId]) return 0;
    
    let count = graph[featureId].blockedBy.length;
    
    // 재귀적으로 간접 차단된 기능도 카운트
    for (const blockedId of graph[featureId].blockedBy) {
      count += this.countBlockedFeatures(blockedId, graph);
    }
    
    return count;
  }
  
  saveFeatures() {
    const fs = require('fs');
    const data = { features: this.features };
    fs.writeFileSync(
      this.featureListPath,
      JSON.stringify(data, null, 2)
    );
  }
}

// 사용 예시
const adjuster = new DynamicPriorityAdjuster('./feature_list.json');
adjuster.adjustPriorities();
console.log('우선순위 조정 완료');

// tests/debug-test.js
const puppeteer = require('puppeteer');

async function debugTest() {
  // 헤드리스 모드 끄기
  const browser = await puppeteer.launch({ 
    headless: false,
    slowMo: 250,  // 동작을 천천히
    devtools: true  // DevTools 자동 열기
  });
  
  const page = await browser.newPage();
  
  // 콘솔 메시지 캡처
  page.on('console', msg => console.log('PAGE LOG:', msg.text()));
  
  // 에러 캡처
  page.on('pageerror', error => console.log('PAGE ERROR:', error.message));
  
  try {
    await page.goto('http://localhost:3000', {
      waitUntil: 'networkidle2',
      timeout: 30000
    });
    
    // 단계별 스크린샷
    await page.screenshot({ path: 'debug-1-initial.png' });
    
    // 요소가 나타날 때까지 대기
    await page.waitForSelector('#login-form', { timeout: 10000 });
    await page.screenshot({ path: 'debug-2-form-visible.png' });
    
    // 입력
    await page.type('#email', '[email protected]');
    await page.screenshot({ path: 'debug-3-email-entered.png' });
    
    await page.type('#password', 'password123');
    await page.screenshot({ path: 'debug-4-password-entered.png' });
    
    // 제출
    await page.click('button[type="submit"]');
    await page.waitForNavigation({ timeout: 10000 });
    await page.screenshot({ path: 'debug-5-after-submit.png' });
    
    console.log('✓ 테스트 성공');
    
  } catch (error) {
    console.error('✗ 테스트 실패:', error.message);
    await page.screenshot({ path: 'debug-error.png' });
  }
  
  // 브라우저를 자동으로 닫지 않음
  // await browser.close();
}

debugTest();

// tools/cache-system.js
const fs = require('fs');
const crypto = require('crypto');
const path = require('path');

class CacheSystem {
  constructor(cacheDir = '.cache') {
    this.cacheDir = cacheDir;
    this.ensureCacheDir();
  }
  
  ensureCacheDir() {
    if (!fs.existsSync(this.cacheDir)) {
      fs.mkdirSync(this.cacheDir, { recursive: true });
    }
  }
  
  generateKey(input) {
    // 입력값으로 캐시 키 생성
    return crypto
      .createHash('sha256')
      .update(JSON.stringify(input))
      .digest('hex');
  }
  
  get(key) {
    const cachePath = path.join(this.cacheDir, `${key}.json`);
    
    if (fs.existsSync(cachePath)) {
      const cached = JSON.parse(fs.readFileSync(cachePath, 'utf8'));
      
      // 만료 시간 확인 (24시간)
      const age = Date.now() - cached.timestamp;
      if (age < 24 * 60 * 60 * 1000) {
        console.log(`✓ 캐시 히트: ${key}`);
        return cached.data;
      }
    }
    
    console.log(`✗ 캐시 미스: ${key}`);
    return null;
  }
  
  set(key, data) {
    const cachePath = path.join(this.cacheDir, `${key}.json`);
    const cached = {
      timestamp: Date.now(),
      data: data
    };
    
    fs.writeFileSync(cachePath, JSON.stringify(cached, null, 2));
    console.log(`✓ 캐시 저장: ${key}`);
  }
  
  // 특정 작업을 캐시와 함께 실행
  async cached(key, operation) {
    const cacheKey = this.generateKey(key);
    const cached = this.get(cacheKey);
    
    if (cached !== null) {
      return cached;
    }
    
    const result = await operation();
    this.set(cacheKey, result);
    return result;
  }
  
  clear() {
    // 캐시 디렉토리 전체 삭제
    if (fs.existsSync(this.cacheDir)) {
      fs.rmSync(this.cacheDir, { recursive: true });
      this.ensureCacheDir();
      console.log('✓ 캐시 클리어 완료');
    }
  }
}

// 사용 예시
const cache = new CacheSystem();

// 무거운 테스트를 캐시
async function runHeavyTest(featureId) {
  return await cache.cached(
    { type: 'test', featureId },
    async () => {
      console.log('실제 테스트 실행 중...');
      // 실제 테스트 로직
      return { passed: true, duration: 45 };
    }
  );
}

module.exports = CacheSystem;

// tools/incremental-testing.js
const { execSync } = require('child_process');
const fs = require('fs');

class IncrementalTesting {
  constructor(projectDir) {
    this.projectDir = projectDir;
  }
  
  getChangedFiles() {
    // Git으로 변경된 파일 목록 가져오기
    try {
      const output = execSync(
        'git diff --name-only HEAD',
        { cwd: this.projectDir }
      ).toString();
      
      return output.split('\n').filter(Boolean);
    } catch (error) {
      return [];
    }
  }
  
  identifyAffectedTests(changedFiles) {
    const affectedTests = new Set();
    
    // 파일 변경에 따른 테스트 매핑
    const testMapping = {
      'src/components/Login': ['tests/e2e/login.test.js', 'tests/unit/login.test.js'],
      'src/api/auth': ['tests/api/auth.test.js'],
      'src/components/': ['tests/e2e/ui.test.js']
    };
    
    for (const file of changedFiles) {
      for (const [pattern, tests] of Object.entries(testMapping)) {
        if (file.includes(pattern)) {
          tests.forEach(test => affectedTests.add(test));
        }
      }
    }
    
    return Array.from(affectedTests);
  }
  
  runIncrementalTests() {
    const changedFiles = this.getChangedFiles();
    
    if (changedFiles.length === 0) {
      console.log('변경사항 없음 - 모든 테스트 스킵');
      return true;
    }
    
    console.log(`변경된 파일: ${changedFiles.length}개`);
    
    const affectedTests = this.identifyAffectedTests(changedFiles);
    
    if (affectedTests.length === 0) {
      console.log('영향받는 테스트 없음');
      return true;
    }
    
    console.log(`실행할 테스트: ${affectedTests.length}개`);
    
    for (const test of affectedTests) {
      console.log(`실행 중: ${test}`);
      try {
        execSync(`npm test ${test}`, {
          cwd: this.projectDir,
          stdio: 'inherit'
        });
      } catch (error) {
        console.error(`✗ 실패: ${test}`);
        return false;
      }
    }
    
    console.log('✓ 모든 증분 테스트 통과');
    return true;
  }
}

module.exports = IncrementalTesting;

// tools/safe-executor.js
class SafeCommandExecutor {
  constructor() {
    // 허용된 명령어 화이트리스트
    this.allowedCommands = [
      'npm', 'node', 'git', 'cat', 'ls', 'pwd',
      'mkdir', 'touch', 'cp', 'mv', 'rm'
    ];
    
    // 금지된 패턴
    this.blockedPatterns = [
      /rm\s+-rf\s+\//, // rm -rf /
      /sudo/, // sudo 명령
      /chmod\s+777/, // 과도한 권한
      /eval\(/, // eval 함수
      />\s*\/dev\//, // 시스템 디바이스 접근
      /curl.*\|\s*bash/, // 파이프라인 실행
    ];
  }
  
  isCommandSafe(command) {
    // 기본 명령어 추출
    const baseCommand = command.trim().split(/\s+/)[0];
    
    // 1. 화이트리스트 확인
    if (!this.allowedCommands.includes(baseCommand)) {
      return {
        safe: false,
        reason: `명령어 '${baseCommand}'는 허용되지 않습니다`
      };
    }
    
    // 2. 위험한 패턴 확인
    for (const pattern of this.blockedPatterns) {
      if (pattern.test(command)) {
        return {
          safe: false,
          reason: `위험한 패턴 감지: ${pattern}`
        };
      }
    }
    
    // 3. 파일 시스템 접근 범위 확인
    if (command.includes('..')) {
      return {
        safe: false,
        reason: '상위 디렉토리 접근 금지'
      };
    }
    
    return { safe: true };
  }
  
  execute(command, options = {}) {
    const safety = this.isCommandSafe(command);
    
    if (!safety.safe) {
      console.error(`❌ 명령어 차단: ${safety.reason}`);
      console.error(`차단된 명령어: ${command}`);
      throw new Error(safety.reason);
    }
    
    console.log(`✓ 안전한 명령어 실행: ${command}`);
    
    const { execSync } = require('child_process');
    return execSync(command, {
      ...options,
      timeout: 30000, // 30초 타임아웃
      maxBuffer: 10 * 1024 * 1024 // 10MB 버퍼
    });
  }
}

module.exports = SafeCommandExecutor;

// tools/dashboard.js
const blessed = require('blessed');
const contrib = require('blessed-contrib');

class ProgressDashboard {
  constructor(featureListPath) {
    this.featureListPath = featureListPath;
    this.screen = blessed.screen();
    this.setupUI();
    this.startUpdates();
  }
  
  setupUI() {
    const grid = new contrib.grid({ rows: 12, cols: 12, screen: this.screen });
    
    // 전체 진행률 게이지
    this.progressGauge = grid.set(0, 0, 2, 6, contrib.gauge, {
      label: '전체 진행률',
      stroke: 'green',
      fill: 'white'
    });
    
    // 우선순위별 현황
    this.priorityDonut = grid.set(0, 6, 4, 6, contrib.donut, {
      label: '우선순위별 남은 작업',
      radius: 8,
      arcWidth: 3,
      remainColor: 'black',
      yPadding: 2
    });
    
    // 최근 완료 기능 로그
    this.logBox = grid.set(4, 0, 8, 12, contrib.log, {
      fg: 'green',
      selectedFg: 'green',
      label: '최근 활동'
    });
    
    // 남은 작업 목록
    this.todoTable = grid.set(2, 0, 2, 6, contrib.table, {
      keys: true,
      fg: 'white',
      selectedFg: 'white',
      selectedBg: 'blue',
      interactive: false,
      label: '다음 작업',
      width: '50%',
      height: '30%',
      columnSpacing: 3,
      columnWidth: [4, 30, 10]
    });
    
    this.screen.key(['escape', 'q', 'C-c'], () => {
      return process.exit(0);
    });
    
    this.screen.render();
  }
  
  update() {
    const fs = require('fs');
    const data = JSON.parse(fs.readFileSync(this.featureListPath, 'utf8'));
    const features = data.features;
    
    // 진행률 계산
    const total = features.length;
    const completed = features.filter(f => f.passes).length;
    const percentage = Math.round((completed / total) * 100);
    
    this.progressGauge.setPercent(percentage);
    
    // 우선순위별 현황
    const remaining = features.filter(f => !f.passes);
    const byPriority = {
      high: remaining.filter(f => f.priority === 'high').length,
      medium: remaining.filter(f => f.priority === 'medium').length,
      low: remaining.filter(f => f.priority === 'low').length
    };
    
    this.priorityDonut.setData([
      { percent: byPriority.high / remaining.length, label: 'High', color: 'red' },
      { percent: byPriority.medium / remaining.length, label: 'Medium', color: 'yellow' },
      { percent: byPriority.low / remaining.length, label: 'Low', color: 'green' }
    ]);
    
    // 다음 작업 목록
    const nextFeatures = remaining.slice(0, 5);
    this.todoTable.setData({
      headers: ['ID', 'Title', 'Priority'],
      data: nextFeatures.map(f => [
        f.id.toString(),
        f.title.substring(0, 28),
        f.priority
      ])
    });
    
    // Git 로그 읽기
    const { execSync } = require('child_process');
    try {
      const gitLog = execSync('git log --oneline -10', { encoding: 'utf8' });
      const lines = gitLog.split('\n').filter(Boolean);
      lines.forEach(line => this.logBox.log(line));
    } catch (error) {
      // Git 히스토리가 없을 수 있음
    }
    
    this.screen.render();
  }
  
  startUpdates() {
    this.update();
    setInterval(() => this.update(), 5000); // 5초마다 업데이트
  }
}

// 사용 예시
const dashboard = new ProgressDashboard('./feature_list.json');