import { NextRequest, NextResponse } from 'next/server';
import { exec } from 'child_process';
import { promisify } from 'util';
import { getApiUrl } from '@/lib/utils/api-url';

const execAsync = promisify(exec);

/**
 * Intelligent V1 Launch Planning
 * Analyzes ACTUAL codebase to generate specific, actionable tasks
 */
export async function GET(
  request: NextRequest,
  { params }: { params: Promise<{ projectId: string }> }
) {
  try {
    const { projectId } = await params;

    // 1. Load project context
    const contextResponse = await fetch(
      getApiUrl(`/api/projects/${projectId}/context`, request)
    );
    const context = await contextResponse.json();

    // 2. Scan actual codebase structure
    const repoPath = '/Users/markhenderson/ai-proxy';
    const { stdout: pagesOutput } = await execAsync(
      `cd "${repoPath}" && find vibn-frontend/app -name "*.tsx" | grep "page.tsx" | wc -l`
    );
    const { stdout: apiOutput } = await execAsync(
      `cd "${repoPath}" && find vibn-frontend/app/api -name "route.ts" | wc -l`
    );
    const { stdout: componentsOutput } = await execAsync(
      `cd "${repoPath}" && find vibn-frontend/components -name "*.tsx" 2>/dev/null | wc -l || echo 0`
    );

    const codebaseStats = {
      totalPages: parseInt(pagesOutput.trim()),
      totalAPIs: parseInt(apiOutput.trim()),
      totalComponents: parseInt(componentsOutput.trim())
    };

    // 3. Analyze what's ACTUALLY built vs vision
    const analysis = await analyzeRealCodebase(context, codebaseStats, repoPath);

    // 4. Generate intelligent, specific tasks
    const intelligentPlan = generateIntelligentPlan(context, analysis);

    return NextResponse.json({
      projectContext: {
        name: context.project.name,
        vision: context.project.vision
      },
      codebaseAnalysis: analysis,
      intelligentPlan,
      confidence: analysis.confidence
    });

  } catch (error) {
    console.error('Error generating intelligent plan:', error);
    return NextResponse.json(
      { 
        error: 'Failed to generate intelligent plan',
        details: error instanceof Error ? error.message : String(error)
      },
      { status: 500 }
    );
  }
}

async function analyzeRealCodebase(context: any, stats: any, repoPath: string) {
  const analysis: any = {
    builtFeatures: [],
    missingFeatures: [],
    confidence: 'high',
    specificInsights: []
  };

  // Analyze actual file structure
  const { stdout: pagesListOutput } = await execAsync(
    `cd "${repoPath}" && find vibn-frontend/app -name "page.tsx" | sed 's|vibn-frontend/app/||' | sed 's|/page.tsx||'`
  );
  const actualPages = pagesListOutput.trim().split('\n').filter(p => p);

  const { stdout: apiListOutput } = await execAsync(
    `cd "${repoPath}" && find vibn-frontend/app/api -name "route.ts" | sed 's|vibn-frontend/app/api/||' | sed 's|/route.ts||'`
  );
  const actualAPIs = apiListOutput.trim().split('\n').filter(a => a);

  // Analyze based on vision: "VIBN gets your project to v1 launch and beyond"
  const vision = context.project.vision || '';

  // Check for key features mentioned in vision
  const visionKeywords = {
    'project plan': { pages: ['plan', 'getting-started'], apis: ['plan/'] },
    'marketing automation': { pages: ['marketing'], apis: ['plan/marketing'] },
    'communication automation': { pages: ['communication', 'chat'], apis: ['ai/chat'] },
    'ai chat support': { pages: ['chat', 'v_ai_chat'], apis: ['ai/chat'] }
  };

  // Analyze what's built
  if (actualPages.some(p => p.includes('plan') || p.includes('getting-started'))) {
    analysis.builtFeatures.push({
      name: 'Project Planning System',
      evidence: actualPages.filter(p => p.includes('plan')).slice(0, 3),
      status: 'built'
    });
  }

  if (actualPages.some(p => p.includes('v_ai_chat')) && actualAPIs.some(a => a.includes('ai/chat'))) {
    analysis.builtFeatures.push({
      name: 'AI Chat Interface',
      evidence: ['v_ai_chat page', 'ai/chat API'],
      status: 'built'
    });
  }

  if (actualAPIs.some(a => a.includes('github/'))) {
    analysis.builtFeatures.push({
      name: 'GitHub Integration',
      evidence: actualAPIs.filter(a => a.includes('github/')),
      status: 'built'
    });
  }

  if (actualAPIs.some(a => a.includes('cursor/'))) {
    analysis.builtFeatures.push({
      name: 'Cursor History Import',
      evidence: actualAPIs.filter(a => a.includes('cursor/')),
      status: 'built'
    });
  }

  if (actualAPIs.some(a => a.includes('sessions/'))) {
    analysis.builtFeatures.push({
      name: 'Session Tracking',
      evidence: ['sessions/track', 'sessions/associate-project'],
      status: 'built'
    });
  }

  if (actualPages.some(p => p.includes('audit'))) {
    analysis.builtFeatures.push({
      name: 'Project Audit Report',
      evidence: ['audit page', 'audit/generate API'],
      status: 'built'
    });
  }

  // Identify gaps based on vision
  if (vision.includes('marketing automation') && !actualPages.some(p => p.includes('marketing'))) {
    analysis.missingFeatures.push({
      name: 'Marketing Automation UI',
      reason: 'Mentioned in vision but no UI found',
      priority: 'high'
    });
  }

  if (vision.includes('communication automation')) {
    const hasCommAutomation = actualAPIs.some(a => 
      a.includes('email') || a.includes('slack') || a.includes('notification')
    );
    if (!hasCommAutomation) {
      analysis.missingFeatures.push({
        name: 'Communication Automation',
        reason: 'Mentioned in vision but no APIs found',
        priority: 'high'
      });
    }
  }

  // Check for production readiness
  if (!actualAPIs.some(a => a.includes('health') || a.includes('status'))) {
    analysis.missingFeatures.push({
      name: 'Health Check Endpoint',
      reason: 'Needed for production monitoring',
      priority: 'medium'
    });
  }

  // Check for onboarding
  const hasOnboarding = actualPages.some(p => p.includes('getting-started') || p.includes('onboarding'));
  if (hasOnboarding) {
    analysis.builtFeatures.push({
      name: 'User Onboarding Flow',
      evidence: actualPages.filter(p => p.includes('getting-started')),
      status: 'built'
    });
  } else {
    analysis.missingFeatures.push({
      name: 'User Onboarding Tutorial',
      reason: 'Critical for first-time users',
      priority: 'high'
    });
  }

  // Check for task management
  const hasTaskUI = actualPages.some(p => p.includes('task') || p.includes('checklist') || p.includes('todo'));
  if (!hasTaskUI && actualAPIs.some(a => a.includes('plan/'))) {
    analysis.missingFeatures.push({
      name: 'Task Management UI',
      reason: 'Have plan APIs but no UI to track tasks',
      priority: 'high'
    });
  }

  // Specific insights from commit history
  const recentCommits = context.codebase?.topFiles || [];
  if (recentCommits.length > 0) {
    analysis.specificInsights.push(
      `Recently worked on: ${recentCommits.slice(0, 3).map((f: any) => f.filePath.split('/').pop()).join(', ')}`
    );
  }

  // Activity insights
  const topFiles = context.activity?.topEditedFiles || [];
  if (topFiles.length > 0) {
    const topFile = topFiles[0].file.split('/').pop();
    analysis.specificInsights.push(`Most edited: ${topFile} (${topFiles[0].count} times)`);
  }

  return analysis;
}

function generateIntelligentPlan(context: any, analysis: any) {
  const plan = {
    summary: `Based on ${analysis.builtFeatures.length} built features and ${analysis.missingFeatures.length} identified gaps`,
    categories: [] as any[]
  };

  // Product Completion (based on what's actually missing)
  const productTasks = [];
  for (const missing of analysis.missingFeatures) {
    if (missing.name === 'Task Management UI') {
      productTasks.push({
        id: `prod-task-ui`,
        title: 'Build Task Management UI',
        description: `You have plan/simulate API but no UI. Create a checklist interface to show and track V1 launch tasks.`,
        status: 'pending',
        priority: missing.priority,
        specificTo: 'Your codebase has the backend but missing frontend'
      });
    }
    if (missing.name === 'Marketing Automation UI') {
      productTasks.push({
        id: `prod-mkt-ui`,
        title: 'Build Marketing Automation Dashboard',
        description: `Your vision mentions marketing automation. Create UI for /plan/marketing API to manage campaigns.`,
        status: 'pending',
        priority: missing.priority,
        specificTo: 'Mentioned in your vision statement'
      });
    }
    if (missing.name === 'Communication Automation') {
      productTasks.push({
        id: `prod-comm-auto`,
        title: 'Add Communication Automation',
        description: `Build email/Slack notification system for project updates and milestones.`,
        status: 'pending',
        priority: missing.priority,
        specificTo: 'Core to your vision: "communication automation"'
      });
    }
    if (missing.name === 'User Onboarding Tutorial') {
      productTasks.push({
        id: `prod-onboard`,
        title: 'Create Interactive Onboarding',
        description: `Guide new users through: 1) New vs existing project, 2) GitHub connect, 3) Run Cursor import, 4) Define vision.`,
        status: 'pending',
        priority: missing.priority,
        specificTo: 'Your vision flow from earlier conversation'
      });
    }
  }

  if (productTasks.length > 0) {
    plan.categories.push({
      name: 'Product Completion',
      status: 'in_progress',
      description: 'Missing features identified from your codebase and vision',
      tasks: productTasks
    });
  }

  // Polish Existing Features (based on what's built but might need work)
  const polishTasks = [];
  for (const built of analysis.builtFeatures) {
    if (built.name === 'Project Planning System') {
      polishTasks.push({
        id: 'polish-plan',
        title: 'Connect Planning APIs to UI',
        description: `You have /plan/mvp, /plan/marketing, /plan/simulate APIs. Ensure they're all wired to your ${built.evidence.length} planning pages.`,
        status: 'in_progress',
        priority: 'high',
        specificTo: `Found ${built.evidence.length} planning pages in your codebase`
      });
    }
  }

  if (polishTasks.length > 0) {
    plan.categories.push({
      name: 'Polish & Integration',
      status: 'in_progress',
      description: 'Connect your existing features together',
      tasks: polishTasks
    });
  }

  // Launch Readiness (production concerns)
  const launchTasks = [
    {
      id: 'launch-monitoring',
      title: 'Add Production Monitoring',
      description: `Add health check endpoint and error tracking for your ${context.codebase?.totalCommits} commits of code.`,
      status: 'pending',
      priority: 'high',
      specificTo: 'Your 104k lines of code need monitoring'
    },
    {
      id: 'launch-docs',
      title: 'Document All Features',
      description: `Create docs for your ${analysis.builtFeatures.length} built features: ${analysis.builtFeatures.map((f: any) => f.name).join(', ')}.`,
      status: 'pending',
      priority: 'medium',
      specificTo: `Specific to your ${analysis.builtFeatures.length} features`
    },
    {
      id: 'launch-demo',
      title: 'Create Demo Video',
      description: `Show: GitHub import → Cursor analysis → AI chat → Launch plan. Highlight your unique value.`,
      status: 'pending',
      priority: 'high',
      specificTo: 'Your specific user journey'
    }
  ];

  plan.categories.push({
    name: 'Launch Preparation',
    status: 'pending',
    description: 'Get ready for public launch',
    tasks: launchTasks
  });

  return plan;
}