import { createMCPServer } from '@jhgaylor/candidate-mcp-server';
import { analyzeCodeQuality } from '@/lib/code/qualityAnalyzer';
import { findBugs } from '@/lib/code/bugDetector';
import { optimizePerformance } from '@/lib/code/performanceOptimizer';
import { analyzeRepository } from '@/lib/code/repositoryAnalyzer';

// Severity levels
const SEVERITY_LEVELS = {
CRITICAL: 'critical',
HIGH: 'high',
MEDIUM: 'medium',
LOW: 'low',
INFO: 'info'
};

// Review focus areas
const FOCUS_AREAS = {
QUALITY: 'quality',
BUGS: 'bugs',
PERFORMANCE: 'performance',
SECURITY: 'security',
STYLE: 'style',
ARCHITECTURE: 'architecture',
ALL: 'all'
};

// Code Review Tool definitions
const codeReviewTools = [
{
name: 'reviewCode',
description: 'Review code snippet for quality, bugs, and performance issues',
parameters: {
type: 'object',
properties: {
code: {
type: 'string',
description: 'The code snippet to review'
},
language: {
type: 'string',
description: 'Programming language of the code'
},
focusAreas: {
type: 'array',
items: {
type: 'string',
enum: Object.values(FOCUS_AREAS)
},
description: 'Areas to focus on during the review'
},
severity: {
type: 'string',
description: 'Minimum severity level to report',
enum: Object.values(SEVERITY_LEVELS)
}
},
required: ['code', 'language']
},
handler: async ({ code, language, focusAreas, severity }, context) => {
// Determine which analyses to run based on focus areas
const focus = focusAreas || [FOCUS_AREAS.ALL];
const minSeverity = severity || SEVERITY_LEVELS.LOW;

    let qualityIssues = [];
    let bugs = [];
    let performanceIssues = [];

    if (focus.includes(FOCUS_AREAS.ALL) || focus.includes(FOCUS_AREAS.QUALITY) || focus.includes(FOCUS_AREAS.STYLE)) {
      qualityIssues = await analyzeCodeQuality(code, language, minSeverity);
    }

    if (focus.includes(FOCUS_AREAS.ALL) || focus.includes(FOCUS_AREAS.BUGS) || focus.includes(FOCUS_AREAS.SECURITY)) {
      bugs = await findBugs(code, language, minSeverity);
    }

    if (focus.includes(FOCUS_AREAS.ALL) || focus.includes(FOCUS_AREAS.PERFORMANCE)) {
      performanceIssues = await optimizePerformance(code, language, minSeverity);
    }

    // Combine all issues and sort by severity
    const allIssues = [...qualityIssues, ...bugs, ...performanceIssues].sort((a, b) => {
      const severityOrder = {
        [SEVERITY_LEVELS.CRITICAL]: 0,
        [SEVERITY_LEVELS.HIGH]: 1,
        [SEVERITY_LEVELS.MEDIUM]: 2,
        [SEVERITY_LEVELS.LOW]: 3,
        [SEVERITY_LEVELS.INFO]: 4
      };

      return severityOrder[a.severity] - severityOrder[b.severity];
    });

    return {
      summary: {
        totalIssues: allIssues.length,
        criticalCount: allIssues.filter(i => i.severity === SEVERITY_LEVELS.CRITICAL).length,
        highCount: allIssues.filter(i => i.severity === SEVERITY_LEVELS.HIGH).length,
        mediumCount: allIssues.filter(i => i.severity === SEVERITY_LEVELS.MEDIUM).length,
        lowCount: allIssues.filter(i => i.severity === SEVERITY_LEVELS.LOW).length,
        infoCount: allIssues.filter(i => i.severity === SEVERITY_LEVELS.INFO).length,
        qualityIssuesCount: qualityIssues.length,
        bugsCount: bugs.length,
        performanceIssuesCount: performanceIssues.length
      },
      issues: allIssues,
      overallAssessment: generateOverallAssessment(allIssues, language),
      bestPractices: generateBestPractices(language)
    };
  }

},
{
name: 'reviewRepository',
description: 'Review a GitHub repository for code quality issues',
parameters: {
type: 'object',
properties: {
repoUrl: {
type: 'string',
description: 'GitHub repository URL'
},
branch: {
type: 'string',
description: 'Branch to analyze (defaults to main/master)'
},
filePatterns: {
type: 'array',
items: {
type: 'string'
},
description: 'File patterns to include (e.g., "_.js", "src/**/_.ts")'
},
excludePatterns: {
type: 'array',
items: {
type: 'string'
},
description: 'File patterns to exclude (e.g., "node_modules/**", "dist/**")'
},
focusAreas: {
type: 'array',
items: {
type: 'string',
enum: Object.values(FOCUS_AREAS)
},
description: 'Areas to focus on during the review'
},
maxFiles: {
type: 'number',
description: 'Maximum number of files to analyze'
}
},
required: ['repoUrl']
},
handler: async ({ repoUrl, branch, filePatterns, excludePatterns, focusAreas, maxFiles }, context) => {
const repoAnalysis = await analyzeRepository(
repoUrl,
branch || 'main',
filePatterns || ['**/*.{js,ts,jsx,tsx,py,java,rb,cs,go,rs}'],
excludePatterns || ['**/node_modules/**', '**/dist/**', '**/build/**'],
focusAreas || [FOCUS_AREAS.ALL],
maxFiles || 10
);

    return {
      repoSummary: {
        url: repoUrl,
        branch: branch || 'main',
        filesAnalyzed: repoAnalysis.filesAnalyzed,
        totalIssues: repoAnalysis.totalIssues,
        languagesDetected: repoAnalysis.languagesDetected,
        overallScore: repoAnalysis.overallScore
      },
      filesSummary: repoAnalysis.filesSummary,
      criticalIssues: repoAnalysis.criticalIssues,
      topIssues: repoAnalysis.topIssues,
      patternsDetected: repoAnalysis.patternsDetected,
      recommendations: repoAnalysis.recommendations,
      architectureAssessment: repoAnalysis.architectureAssessment
    };
  }

},
{
name: 'suggestFix',
description: 'Suggest a fix for a code issue',
parameters: {
type: 'object',
properties: {
issueId: {
type: 'string',
description: 'ID of the issue to fix'
},
originalCode: {
type: 'string',
description: 'The original code containing the issue'
},
language: {
type: 'string',
description: 'Programming language of the code'
},
explanation: {
type: 'boolean',
description: 'Whether to include a detailed explanation'
}
},
required: ['issueId', 'originalCode', 'language']
},
handler: async ({ issueId, originalCode, language, explanation }, context) => {
// This is a simplified implementation
// In a real system, you would look up the issue and generate a specific fix

    // Mock implementation for demonstration
    const fixedCode = originalCode.replace(
      'function getData() {',
      'async function getData() {'
    ).replace(
      'return data;',
      'return await data;'
    );

    return {
      fixedCode,
      explanation: explanation ?
        "The function is using asynchronous operations but wasn't declared as async. Added the async keyword to the function declaration and await to the returned promise." :
        null,
      diff: "- function getData() {
+ async function getData() {
  ...
- return data;
+ return await data;",
      additionalNotes: "Make sure to properly handle errors with try/catch when using await."
    };
  }

},
{
name: 'explainCodePattern',
description: 'Explain a code pattern or best practice',
parameters: {
type: 'object',
properties: {
pattern: {
type: 'string',
description: 'The name of the pattern or practice to explain'
},
language: {
type: 'string',
description: 'Programming language context'
},
detailLevel: {
type: 'string',
description: 'Level of detail in the explanation',
enum: ['basic', 'intermediate', 'advanced']
}
},
required: ['pattern']
},
handler: async ({ pattern, language, detailLevel }, context) => {
// This is a simplified implementation
// In a real system, you would have a database of pattern explanations

    // Mock implementation for demonstration
    if (pattern.toLowerCase().includes('dependency injection')) {
      return {
        pattern: "Dependency Injection",
        summary: "A design pattern that implements inversion of control for resolving dependencies.",
        description: "Dependency Injection is a technique where an object receives other objects that it depends on. These other objects are called dependencies. Instead of creating its dependencies, an object has them 'injected' at creation time.",
        benefits: [
          "Makes testing easier by allowing mocks or stubs of dependencies",
          "Reduces coupling between classes",
          "Increases modularity and reusability",
          "Makes code more maintainable and extensible"
        ],
        examples: [
          {
            language: "TypeScript",
            code: `// Without Dependency Injection

class UserService {
private userRepository = new UserRepository();

getUserById(id: string) {
return this.userRepository.findById(id);
}
}

// With Dependency Injection
class UserService {
constructor(private userRepository: UserRepository) {}

getUserById(id: string) {
return this.userRepository.findById(id);
}
}

// Usage
const repository = new UserRepository();
const service = new UserService(repository);`
}
],
antiPatterns: [
"Creating dependencies inside the class",
"Using global state or service locators"
],
frameworks: [
"Angular (built-in DI system)",
"NestJS (built-in DI system)",
"Spring (Java)",
"ASP.NET Core (C#)"
]
};
}

    return {
      pattern: pattern,
      summary: "A design pattern or best practice in software development.",
      description: "This would contain a detailed explanation of the requested pattern.",
      examples: [
        {
          language: language || "JavaScript",
          code: "// Example code showing the pattern would go here"
        }
      ]
    };
  }

}
];

// Helper function to generate overall assessment
function generateOverallAssessment(issues, language) {
// This would be more sophisticated in a real implementation

const criticalIssues = issues.filter(i => i.severity === SEVERITY_LEVELS.CRITICAL).length;
const highIssues = issues.filter(i => i.severity === SEVERITY_LEVELS.HIGH).length;

if (criticalIssues > 0) {
return "The code has critical issues that should be addressed immediately.";
} else if (highIssues > 3) {
return "The code has several high-priority issues that should be addressed soon.";
} else if (highIssues > 0) {
return "The code has a few high-priority issues but is generally sound.";
} else if (issues.length > 5) {
return "The code has some minor issues but follows most best practices.";
} else {
return "The code is generally well-written and follows best practices.";
}
}

// Helper function to generate best practices
function generateBestPractices(language) {
const commonPractices = [
"Write meaningful variable and function names",
"Keep functions small and focused on a single responsibility",
"Add appropriate comments and documentation",
"Handle errors properly",
"Write unit tests for critical functionality"
];

const languageSpecificPractices = {
javascript: [
"Use const and let instead of var",
"Use async/await for asynchronous code instead of raw promises",
"Destructure objects and arrays for cleaner code",
"Use template literals for string interpolation"
],
typescript: [
"Use proper type annotations",
"Leverage interfaces for object shapes",
"Use union types for variables that can have multiple types",
"Enable strict mode in tsconfig.json"
],
python: [
"Follow PEP 8 style guidelines",
"Use list comprehensions for simple transformations",
"Use virtual environments for project dependencies",
"Write docstrings for functions and classes"
]
};

return [
...commonPractices,
...(languageSpecificPractices[language.toLowerCase()] || [])
];
}

export function createCodeReviewServer(candidateData) {
return createMCPServer({
  candidateName: candidateData.name,
  resumeText: candidateData.resumeText,
  tools: codeReviewTools,
  links: {
    linkedin: candidateData.linkedinUrl,
    github: candidateData.githubUrl,
    website: candidateData.websiteUrl,
  },
  contactInfo: {
    email: candidateData.contactEmail,
  }
});
}

import { NextRequest, NextResponse } from 'next/server';
import { getCandidateData } from '@/lib/redis';
import { createCodeReviewServer } from '@/services/codeReview';

export async function GET(
request: NextRequest,
{ params }: { params: { username: string } }
) {
const { username } = params;

// Fetch candidate profile from Redis
const candidateData = await getCandidateData(username);

if (!candidateData) {
  return NextResponse.json({ error: 'Candidate not found' }, { status: 404 });
}

// Create MCP server instance with candidate data
const server = createCodeReviewServer(candidateData);

try {
  const method = request.method;
  const headers = Object.fromEntries(request.headers);
  const url = new URL(request.url);
  
  let body = null;
  if (method !== 'GET' && method !== 'HEAD') {
    body = await request.text();
  }
  
  const mcpResponse = await server.handleRequest({
    method,
    headers,
    url: url.toString(),
    body,
  });
  
  const response = new NextResponse(mcpResponse.body, {
    status: mcpResponse.status,
    headers: mcpResponse.headers,
  });
  
  return response;
} catch (error) {
  console.error('MCP server error:', error);
  return NextResponse.json({ error: 'Internal server error' }, { status: 500 });
}
}

// Also implement POST, PUT, DELETE methods as needed
export async function POST(request: NextRequest, { params }: { params: { username: string } }) {
return GET(request, { params });
}