/**
 * Log Level Audit Test
 *
 * This test scans all TypeScript files in src/ to find logger calls,
 * extracts the message text, and groups them by log level for review.
 *
 * Purpose: Help identify misclassified log messages that should be at a different level.
 *
 * Log Level Guidelines:
 * - ERROR/failure: Critical failures that require investigation (data loss, service down)
 * - WARN: Non-critical issues with fallback behavior (degraded, but functional)
 * - INFO: Normal operational events (session started, request processed)
 * - DEBUG: Detailed diagnostic information (variable values, flow tracing)
 */

import { describe, it, expect } from 'bun:test';
import { readdir, readFile } from 'fs/promises';
import { join, relative } from 'path';

const PROJECT_ROOT = join(import.meta.dir, '..');
const SRC_DIR = join(PROJECT_ROOT, 'src');

interface LoggerCall {
  file: string;
  line: number;
  level: string;
  component: string;
  message: string;
  errorParam: string | null;
  fullMatch: string;
}

/**
 * Recursively find all TypeScript files in a directory
 */
async function findTypeScriptFiles(dir: string): Promise<string[]> {
  const files: string[] = [];
  const entries = await readdir(dir, { withFileTypes: true });

  for (const entry of entries) {
    const fullPath = join(dir, entry.name);

    if (entry.isDirectory()) {
      files.push(...(await findTypeScriptFiles(fullPath)));
    } else if (entry.isFile() && /\.ts$/.test(entry.name) && !/\.d\.ts$/.test(entry.name)) {
      files.push(fullPath);
    }
  }

  return files;
}

/**
 * Extract logger calls from file content
 * Handles multiline calls and captures error parameter (4th arg)
 */
function extractLoggerCalls(content: string, filePath: string): LoggerCall[] {
  const calls: LoggerCall[] = [];
  const lines = content.split('\n');
  const seenCalls = new Set<string>();

  // Build line number index for position-to-line lookup
  const lineStarts: number[] = [0];
  for (let i = 0; i < content.length; i++) {
    if (content[i] === '\n') {
      lineStarts.push(i + 1);
    }
  }

  function getLineNumber(pos: number): number {
    for (let i = lineStarts.length - 1; i >= 0; i--) {
      if (lineStarts[i] <= pos) return i + 1;
    }
    return 1;
  }

  // Pattern that matches logger calls across multiple lines
  // Captures: method, component, message, and everything up to closing paren
  // Uses [\s\S] instead of . to match newlines
  const loggerPattern = /logger\.(error|warn|info|debug|failure|success|timing|dataIn|dataOut|happyPathError)\s*\(\s*['"]([^'"]+)['"][\s\S]*?\)/g;

  let match: RegExpExecArray | null;
  while ((match = loggerPattern.exec(content)) !== null) {
    const fullMatch = match[0];
    const method = match[1];
    const component = match[2];
    const lineNum = getLineNumber(match.index);

    // Extract message (2nd string arg) - could be single, double, or template
    const messageMatch = fullMatch.match(/['"][^'"]+['"]\s*,\s*(['"`])([\s\S]*?)\1/);
    const message = messageMatch ? messageMatch[2] : '(message not captured)';

    // Extract error parameter (4th arg) - look for "error as Error" or similar patterns
    let errorParam: string | null = null;
    const errorMatch = fullMatch.match(/,\s*(error|err|e)\s+as\s+Error\s*\)/i) ||
                       fullMatch.match(/,\s*(error|err|e)\s*\)/i) ||
                       fullMatch.match(/,\s*new\s+Error\s*\([^)]*\)\s*\)/i);
    if (errorMatch) {
      errorParam = errorMatch[0].replace(/^\s*,\s*/, '').replace(/\s*\)\s*$/, '');
    }

    const key = `${filePath}:${lineNum}:${method}:${message.substring(0, 50)}`;
    if (!seenCalls.has(key)) {
      seenCalls.add(key);
      calls.push({
        file: relative(PROJECT_ROOT, filePath),
        line: lineNum,
        level: normalizeLevel(method),
        component,
        message,
        errorParam,
        fullMatch: fullMatch.replace(/\s+/g, ' ').trim()  // Normalize whitespace for display
      });
    }
  }

  return calls;
}

/**
 * Normalize log level names to standard categories
 */
function normalizeLevel(method: string): string {
  switch (method) {
    case 'error':
    case 'failure':
      return 'ERROR';
    case 'warn':
    case 'happyPathError':
      return 'WARN';
    case 'info':
    case 'success':
    case 'timing':
    case 'dataIn':
    case 'dataOut':
      return 'INFO';
    case 'debug':
      return 'DEBUG';
    default:
      return method.toUpperCase();
  }
}

/**
 * Generate formatted audit report
 */
function generateReport(calls: LoggerCall[]): string {
  const byLevel: Record<string, LoggerCall[]> = {
    'ERROR': [],
    'WARN': [],
    'INFO': [],
    'DEBUG': []
  };

  for (const call of calls) {
    if (byLevel[call.level]) {
      byLevel[call.level].push(call);
    }
  }

  const lines: string[] = [];
  lines.push('\n=== LOG LEVEL AUDIT REPORT ===\n');
  lines.push(`Total logger calls found: ${calls.length}\n`);

  // ERROR level
  lines.push('');
  lines.push('ERROR (should be critical failures only):');
  lines.push('─'.repeat(60));
  if (byLevel['ERROR'].length === 0) {
    lines.push('  (none found)');
  } else {
    for (const call of byLevel['ERROR'].sort((a, b) => a.file.localeCompare(b.file))) {
      lines.push(`  ${call.file}:${call.line} [${call.component}]`);
      lines.push(`    message: "${formatMessage(call.message)}"`);
      if (call.errorParam) {
        lines.push(`    error: ${call.errorParam}`);
      }
      lines.push(`    full: ${call.fullMatch}`);
      lines.push('');
    }
  }
  lines.push(`  Count: ${byLevel['ERROR'].length}`);

  // WARN level
  lines.push('');
  lines.push('WARN (should be non-critical, has fallback):');
  lines.push('─'.repeat(60));
  if (byLevel['WARN'].length === 0) {
    lines.push('  (none found)');
  } else {
    for (const call of byLevel['WARN'].sort((a, b) => a.file.localeCompare(b.file))) {
      lines.push(`  ${call.file}:${call.line} [${call.component}]`);
      lines.push(`    message: "${formatMessage(call.message)}"`);
      if (call.errorParam) {
        lines.push(`    error: ${call.errorParam}`);
      }
      lines.push(`    full: ${call.fullMatch}`);
      lines.push('');
    }
  }
  lines.push(`  Count: ${byLevel['WARN'].length}`);

  // INFO level
  lines.push('');
  lines.push('INFO (informational):');
  lines.push('─'.repeat(60));
  if (byLevel['INFO'].length === 0) {
    lines.push('  (none found)');
  } else {
    for (const call of byLevel['INFO'].sort((a, b) => a.file.localeCompare(b.file))) {
      lines.push(`  ${call.file}:${call.line} [${call.component}]`);
      lines.push(`    message: "${formatMessage(call.message)}"`);
      if (call.errorParam) {
        lines.push(`    error: ${call.errorParam}`);
      }
      lines.push(`    full: ${call.fullMatch}`);
      lines.push('');
    }
  }
  lines.push(`  Count: ${byLevel['INFO'].length}`);

  // DEBUG level
  lines.push('');
  lines.push('DEBUG (detailed diagnostics):');
  lines.push('─'.repeat(60));
  if (byLevel['DEBUG'].length === 0) {
    lines.push('  (none found)');
  } else {
    for (const call of byLevel['DEBUG'].sort((a, b) => a.file.localeCompare(b.file))) {
      lines.push(`  ${call.file}:${call.line} [${call.component}]`);
      lines.push(`    message: "${formatMessage(call.message)}"`);
      if (call.errorParam) {
        lines.push(`    error: ${call.errorParam}`);
      }
      lines.push(`    full: ${call.fullMatch}`);
      lines.push('');
    }
  }
  lines.push(`  Count: ${byLevel['DEBUG'].length}`);

  // Summary
  lines.push('');
  lines.push('=== SUMMARY ===');
  lines.push(`  ERROR: ${byLevel['ERROR'].length}`);
  lines.push(`  WARN:  ${byLevel['WARN'].length}`);
  lines.push(`  INFO:  ${byLevel['INFO'].length}`);
  lines.push(`  DEBUG: ${byLevel['DEBUG'].length}`);
  lines.push(`  TOTAL: ${calls.length}`);
  lines.push('');

  return lines.join('\n');
}

/**
 * Format message for display - NO TRUNCATION
 */
function formatMessage(message: string): string {
  return message;
}

describe('Log Level Audit', () => {
  let allCalls: LoggerCall[] = [];

  it('should scan all TypeScript files and extract logger calls', async () => {
    const files = await findTypeScriptFiles(SRC_DIR);
    expect(files.length).toBeGreaterThan(0);

    for (const file of files) {
      const content = await readFile(file, 'utf-8');
      const calls = extractLoggerCalls(content, file);
      allCalls.push(...calls);
    }

    expect(allCalls.length).toBeGreaterThan(0);
  });

  it('should generate audit report for log level review', () => {
    const report = generateReport(allCalls);
    console.log(report);

    // This test always passes - it's for generating a review report
    expect(true).toBe(true);
  });

  it('should have summary statistics', () => {
    const byLevel: Record<string, number> = {
      'ERROR': 0,
      'WARN': 0,
      'INFO': 0,
      'DEBUG': 0
    };

    for (const call of allCalls) {
      if (byLevel[call.level] !== undefined) {
        byLevel[call.level]++;
      }
    }

    console.log('\n📊 Log Level Distribution:');
    console.log(`  ERROR: ${byLevel['ERROR']} (${((byLevel['ERROR'] / allCalls.length) * 100).toFixed(1)}%)`);
    console.log(`  WARN:  ${byLevel['WARN']} (${((byLevel['WARN'] / allCalls.length) * 100).toFixed(1)}%)`);
    console.log(`  INFO:  ${byLevel['INFO']} (${((byLevel['INFO'] / allCalls.length) * 100).toFixed(1)}%)`);
    console.log(`  DEBUG: ${byLevel['DEBUG']} (${((byLevel['DEBUG'] / allCalls.length) * 100).toFixed(1)}%)`);

    // Log distribution health check - not a hard failure, just informational
    // A healthy codebase typically has: DEBUG > INFO > WARN > ERROR
    expect(allCalls.length).toBeGreaterThan(0);
  });
});