interface JSONParserOptions {
  strict?: boolean; // Default: false - allows relaxed parsing
  recoveryMode?: boolean; // Default: true - attempt error recovery
  maxDepth?: number; // Default: 100 - prevent stack overflow
  allowComments?: boolean; // Default: true - strip JSON comments
  allowTrailingCommas?: boolean; // Default: true
  allowUnquotedKeys?: boolean; // Default: false
  schema?: JSONSchema; // Optional schema validation
  templateVariables?: Record<string, any>; // For template processing
  formatOptions?: FormatOptions;
}

interface ParseResult<T = any> {
  success: boolean;
  data?: T;
  formatted?: string; // Pretty-printed JSON
  errors: ParseError[];
  warnings: ParseWarning[];
  metadata: {
    originalLength: number;
    formattedLength: number;
    processingTime: number;
    depth: number;
    keyCount: number;
    recoveryAttempts: number;
  };
}

interface ParseError {
  line: number;
  column: number;
  position: number;
  message: string;
  code: ErrorCode;
  severity: 'error' | 'warning' | 'info';
  suggestion?: string;
  context?: string; // Surrounding text for context
}

interface ValidationResult {
  valid: boolean;
  errors: ValidationError[];
  warnings: ValidationWarning[];
  schema?: JSONSchema;
}

// Main parsing functions
function parseJSON<T = any>(input: string, options?: JSONParserOptions): Promise<ParseResult<T>>;
function validateJSON(input: string, schema: JSONSchema): Promise<ValidationResult>;
function formatJSON(input: string, options?: FormatOptions): Promise<string>;
function processTemplate(template: string, variables: Record<string, any>): Promise<string>;
function extractJSONFromAIResponse(response: string, modelType?: 'gpt' | 'claude' | 'perplexity'): Promise<ParseResult[]>;

// Based on existing implementations from RequestEditor.tsx and response handlers
class JSONParser {
  private options: Required<JSONParserOptions>;
  
  constructor(options: JSONParserOptions = {}) {
    this.options = {
      strict: false,
      recoveryMode: true,
      maxDepth: 100,
      allowComments: true,
      allowTrailingCommas: true,
      allowUnquotedKeys: false,
      formatOptions: { indent: 2, sortKeys: false },
      ...options
    };
  }

  public async parse<T = any>(input: string): Promise<ParseResult<T>> {
    const startTime = Date.now();
    const errors: ParseError[] = [];
    const warnings: ParseWarning[] = [];
    let recoveryAttempts = 0;

    try {
      // First attempt: Standard JSON.parse
      const data = JSON.parse(input) as T;
      const formatted = this.formatData(data);
      
      return {
        success: true,
        data,
        formatted,
        errors,
        warnings,
        metadata: this.generateMetadata(input, formatted, Date.now() - startTime, recoveryAttempts)
      };
    } catch (initialError) {
      if (this.options.strict) {
        return this.createErrorResult(input, initialError as SyntaxError, startTime);
      }

      // Recovery Mode: Try to fix common issues
      const recoveryResult = await this.attemptRecovery(input);
      recoveryAttempts = recoveryResult.attempts;
      
      if (recoveryResult.success) {
        warnings.push({
          message: 'JSON was auto-corrected during parsing',
          code: 'AUTO_RECOVERY',
          severity: 'warning',
          suggestions: recoveryResult.changes
        });
        
        return {
          success: true,
          data: recoveryResult.data,
          formatted: this.formatData(recoveryResult.data),
          errors,
          warnings,
          metadata: this.generateMetadata(input, recoveryResult.correctedInput, Date.now() - startTime, recoveryAttempts)
        };
      }

      return this.createErrorResult(input, recoveryResult.error, startTime, recoveryAttempts);
    }
  }

  private async attemptRecovery(input: string): Promise<RecoveryResult> {
    const strategies = [
      this.removeTrailingCommas.bind(this),
      this.addMissingQuotes.bind(this),
      this.fixCommonTypos.bind(this),
      this.removeComments.bind(this),
      this.extractFromCodeBlock.bind(this)
    ];

    let lastError: Error;
    const changes: string[] = [];

    for (let i = 0; i < strategies.length; i++) {
      try {
        const corrected = strategies[i](input);
        if (corrected !== input) {
          changes.push(strategies[i].name);
        }
        
        const data = JSON.parse(corrected);
        return {
          success: true,
          data,
          correctedInput: corrected,
          attempts: i + 1,
          changes
        };
      } catch (error) {
        lastError = error as Error;
        input = this.applyStrategy(strategies[i], input);
      }
    }

    return {
      success: false,
      error: lastError!,
      attempts: strategies.length,
      changes
    };
  }

  private removeTrailingCommas(input: string): string {
    // Remove trailing commas before closing braces/brackets
    return input
      .replace(/,\s*}/g, '}')
      .replace(/,\s*]/g, ']');
  }

  private addMissingQuotes(input: string): string {
    // Quote unquoted object keys (basic implementation)
    return input.replace(/([{,])\s*([a-zA-Z_$][a-zA-Z0-9_$]*)\s*:/g, '$1"$2":');
  }

  private removeComments(input: string): string {
    if (!this.options.allowComments) return input;
    
    // Remove // comments and /* */ comments
    return input
      .replace(/\/\*[\s\S]*?\*\//g, '')
      .replace(/\/\/.*$/gm, '');
  }

  private extractFromCodeBlock(input: string): string {
    // Extract JSON from markdown code blocks (common in AI responses)
    const codeBlockMatch = input.match(/```(?:json)?([\s\S]*?)```/);
    return codeBlockMatch ? codeBlockMatch[1].trim() : input;
  }

  private formatData(data: any): string {
    return JSON.stringify(data, null, this.options.formatOptions?.indent || 2);
  }

  private createErrorResult(input: string, error: SyntaxError, startTime: number, recoveryAttempts = 0): ParseResult {
    const parseError = this.createDetailedError(error, input);
    
    return {
      success: false,
      errors: [parseError],
      warnings: [],
      metadata: this.generateMetadata(input, '', Date.now() - startTime, recoveryAttempts)
    };
  }

  private createDetailedError(error: SyntaxError, input: string): ParseError {
    // Extract line and column from error message
    const match = error.message.match(/at position (\d+)/);
    const position = match ? parseInt(match[1]) : 0;
    
    const { line, column } = this.getLineColumn(input, position);
    const context = this.getContext(input, position);
    
    return {
      line,
      column,
      position,
      message: this.enhanceErrorMessage(error.message),
      code: this.getErrorCode(error.message),
      severity: 'error',
      context,
      suggestion: this.generateSuggestion(error.message, context)
    };
  }

  // AI Response Processing
  public async extractJSONFromAIResponse(response: string, modelType: string = 'unknown'): Promise<ParseResult[]> {
    const results: ParseResult[] = [];
    
    // Strategy 1: Look for code blocks
    const codeBlockRegex = /```(?:json)?\s*([\s\S]*?)```/g;
    let match;
    
    while ((match = codeBlockRegex.exec(response)) !== null) {
      const jsonCandidate = match[1].trim();
      if (jsonCandidate) {
        const result = await this.parse(jsonCandidate);
        results.push(result);
      }
    }
    
    // Strategy 2: Look for standalone JSON objects
    if (results.length === 0) {
      const objectRegex = /{[\s\S]*}/g;
      while ((match = objectRegex.exec(response)) !== null) {
        const jsonCandidate = match[0];
        const result = await this.parse(jsonCandidate);
        if (result.success) {
          results.push(result);
        }
      }
    }
    
    // Strategy 3: Try parsing the entire response
    if (results.length === 0) {
      const fullResult = await this.parse(response);
      results.push(fullResult);
    }
    
    return results;
  }

  // Template Processing
  public async processTemplate(template: string, variables: Record<string, any>): Promise<string> {
    let processed = template;
    
    // Replace {{variable}} patterns
    Object.entries(variables).forEach(([key, value]) => {
      const pattern = new RegExp(`\\{\\{\\s*${key}\\s*\\}\\}`, 'g');
      const replacement = typeof value === 'string' ? value : JSON.stringify(value);
      processed = processed.replace(pattern, replacement);
    });
    
    // Validate the processed template is valid JSON
    const result = await this.parse(processed);
    if (!result.success) {
      throw new Error(`Template processing resulted in invalid JSON: ${result.errors[0]?.message}`);
    }
    
    return result.formatted || processed;
  }

  // Schema Validation
  public async validateAgainstSchema(data: any, schema: JSONSchema): Promise<ValidationResult> {
    // Implement JSON Schema validation
    // This would typically use a library like ajv
    const errors: ValidationError[] = [];
    const warnings: ValidationWarning[] = [];
    
    try {
      // Simplified validation logic - in practice would use ajv or similar
      const isValid = this.performSchemaValidation(data, schema, errors, warnings);
      
      return {
        valid: isValid,
        errors,
        warnings,
        schema
      };
    } catch (error) {
      errors.push({
        path: '',
        message: `Schema validation failed: ${error instanceof Error ? error.message : 'Unknown error'}`,
        code: 'SCHEMA_ERROR',
        severity: 'error'
      });
      
      return {
        valid: false,
        errors,
        warnings,
        schema
      };
    }
  }
}

// Enhanced error codes
enum ErrorCode {
  SYNTAX_ERROR = 'SYNTAX_ERROR',
  UNEXPECTED_TOKEN = 'UNEXPECTED_TOKEN',
  UNEXPECTED_END = 'UNEXPECTED_END',
  INVALID_CHARACTER = 'INVALID_CHARACTER',
  MISSING_QUOTES = 'MISSING_QUOTES',
  TRAILING_COMMA = 'TRAILING_COMMA',
  SCHEMA_VIOLATION = 'SCHEMA_VIOLATION',
  TEMPLATE_ERROR = 'TEMPLATE_ERROR',
  RECOVERY_FAILED = 'RECOVERY_FAILED'
}