interface CSVParserOptions {
  delimiter?: string; // Default: ','
  hasHeader?: boolean; // Default: true
  requiredColumns?: string[];
  typeInference?: boolean; // Default: true
  skipEmptyRows?: boolean; // Default: true
  maxRows?: number; // For large file protection
  encoding?: string; // Default: 'utf-8'
  customValidators?: Record<string, ValidatorFunction>;
  customTransformers?: Record<string, TransformerFunction>;
}

interface ParseResult<T = Record<string, any>> {
  data: T[];
  headers: string[];
  errors: ParseError[];
  warnings: ParseWarning[];
  metadata: {
    totalRows: number;
    processedRows: number;
    skippedRows: number;
    processingTime: number;
  };
}

interface ParseError {
  row: number;
  column?: string;
  field?: string;
  message: string;
  code: ErrorCode;
  severity: 'error' | 'warning';
}

// Main parsing function
function parseCSV(input: string | File, options?: CSVParserOptions): Promise<ParseResult>;

// Stream-based parsing for large files
function parseCSVStream(input: ReadableStream, options?: CSVParserOptions): AsyncIterable<ParseResult>;

// Validation-only function
function validateCSV(input: string | File, schema: ValidationSchema): Promise<ValidationResult>;

// Based on existing implementation from RecordList.tsx
class CSVParser {
  private parseCSVLine(line: string, delimiter: string = ','): string[] {
    const result: string[] = [];
    let current = '';
    let inQuotes = false;
    
    for (let i = 0; i < line.length; i++) {
      const char = line[i];
      
      if (char === '"') {
        if (inQuotes && line[i + 1] === '"') {
          // Handle escaped quotes
          current += '"';
          i++;
        } else {
          // Toggle quote mode
          inQuotes = !inQuotes;
        }
      } else if (char === delimiter && !inQuotes) {
        // End of field
        result.push(current.trim());
        current = '';
      } else {
        current += char;
      }
    }
    
    result.push(current.trim());
    return result;
  }

  private inferType(value: string): { type: string; convertedValue: any } {
    if (value === '' || value === null || value === undefined) {
      return { type: 'string', convertedValue: value };
    }

    // Number detection
    const numberValue = Number(value);
    if (!isNaN(numberValue) && value !== '') {
      return { 
        type: Number.isInteger(numberValue) ? 'integer' : 'float', 
        convertedValue: numberValue 
      };
    }

    // Boolean detection
    const lowerValue = value.toLowerCase();
    if (['true', 'false', 'yes', 'no', '1', '0'].includes(lowerValue)) {
      return { 
        type: 'boolean', 
        convertedValue: ['true', 'yes', '1'].includes(lowerValue) 
      };
    }

    // Date detection (basic ISO 8601 pattern)
    if (/^\d{4}-\d{2}-\d{2}T?/.test(value) && !isNaN(Date.parse(value))) {
      return { type: 'date', convertedValue: new Date(value) };
    }

    // Email detection
    if (/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(value)) {
      return { type: 'email', convertedValue: value };
    }

    // URL detection
    if (/^https?:\/\//.test(value)) {
      try {
        new URL(value);
        return { type: 'url', convertedValue: value };
      } catch {
        // Invalid URL, treat as string
      }
    }

    return { type: 'string', convertedValue: value };
  }

  public async parse(input: string, options: CSVParserOptions = {}): Promise<ParseResult> {
    const startTime = Date.now();
    const errors: ParseError[] = [];
    const warnings: ParseWarning[] = [];
    
    try {
      // Split lines while handling quoted newlines
      const lines = input.split(/\r?\n/).filter(line => 
        options.skipEmptyRows ? line.trim() : true
      );
      
      if (lines.length === 0) {
        throw new Error('Empty CSV file');
      }

      // Parse header
      const headers = this.parseCSVLine(lines[0], options.delimiter);
      
      // Validate required columns
      if (options.requiredColumns) {
        const missingColumns = options.requiredColumns.filter(col => 
          !headers.includes(col)
        );
        if (missingColumns.length > 0) {
          errors.push({
            row: 0,
            message: `Missing required columns: ${missingColumns.join(', ')}`,
            code: 'MISSING_REQUIRED_COLUMNS',
            severity: 'error'
          });
        }
      }

      // Parse data rows
      const data: Record<string, any>[] = [];
      const maxRows = options.maxRows || lines.length;
      
      for (let i = 1; i < Math.min(lines.length, maxRows + 1); i++) {
        const line = lines[i];
        if (!line.trim() && options.skipEmptyRows) continue;

        try {
          const values = this.parseCSVLine(line, options.delimiter);
          const record: Record<string, any> = {
            id: crypto.randomUUID() // Generate unique ID for each record
          };

          headers.forEach((header, index) => {
            const rawValue = values[index] || '';
            
            if (options.typeInference) {
              const { convertedValue } = this.inferType(rawValue);
              record[header] = convertedValue;
            } else {
              record[header] = rawValue;
            }
          });

          data.push(record);
        } catch (error) {
          errors.push({
            row: i,
            message: `Failed to parse row: ${error instanceof Error ? error.message : 'Unknown error'}`,
            code: 'PARSE_ERROR',
            severity: 'error'
          });
        }
      }

      const processingTime = Date.now() - startTime;
      
      return {
        data,
        headers,
        errors,
        warnings,
        metadata: {
          totalRows: lines.length - 1, // Exclude header
          processedRows: data.length,
          skippedRows: (lines.length - 1) - data.length,
          processingTime
        }
      };
    } catch (error) {
      errors.push({
        row: -1,
        message: `Fatal parsing error: ${error instanceof Error ? error.message : 'Unknown error'}`,
        code: 'FATAL_ERROR',
        severity: 'error'
      });
      
      return {
        data: [],
        headers: [],
        errors,
        warnings,
        metadata: {
          totalRows: 0,
          processedRows: 0,
          skippedRows: 0,
          processingTime: Date.now() - startTime
        }
      };
    }
  }
}