// formatter.ts
import Anthropic from '@anthropic-ai/sdk';
import * as fs from 'fs';
import * as path from 'path';

const client = new Anthropic();

const FORMATTING_SYSTEM_PROMPT = `You are a TypeScript code formatter. When given TypeScript code, you:

1. Convert var to const/let appropriately
2. Replace .then()/.catch() chains with async/await
3. Add explicit return types to functions missing them
4. Replace string concatenation with template literals
5. Convert traditional function expressions to arrow functions where appropriate
6. Add trailing commas in multiline arrays and objects
7. Sort imports: node built-ins first, then external packages, then internal

Return ONLY the formatted code. No explanations. No markdown code fences.
Preserve all comments. Do not change logic or variable names.`;

async function formatTypeScript(sourceCode: string): Promise<string> {
  const message = await client.messages.create({
    model: 'claude-opus-4-6',
    max_tokens: 8096,
    system: FORMATTING_SYSTEM_PROMPT,
    messages: [
      {
        role: 'user',
        content: `Format this TypeScript code:\n\n${sourceCode}`,
      },
    ],
  });

  const textContent = message.content.find((block) => block.type === 'text');
  if (!textContent || textContent.type !== 'text') {
    throw new Error('No text response from Claude');
  }

  return textContent.text;
}

async function formatFile(filePath: string, dryRun = false): Promise<void> {
  const source = fs.readFileSync(filePath, 'utf-8');
  const formatted = await formatTypeScript(source);

  if (dryRun) {
    console.log(`--- ${filePath} (formatted) ---`);
    console.log(formatted);
    return;
  }

  fs.writeFileSync(filePath, formatted, 'utf-8');
  console.log(`Formatted: ${filePath}`);
}

// CLI entry point
const args = process.argv.slice(2);
const dryRun = args.includes('--dry-run');
const files = args.filter((a) => !a.startsWith('--'));

for (const file of files) {
  await formatFile(file, dryRun);
}

// diff-formatter.ts
import { diffLines } from 'diff';

interface FormatResult {
  file: string;
  changed: boolean;
  diff?: string;
  formatted?: string;
}

async function formatWithDiff(filePath: string): Promise<FormatResult> {
  const original = fs.readFileSync(filePath, 'utf-8');
  const formatted = await formatTypeScript(original);

  if (original === formatted) {
    return { file: filePath, changed: false };
  }

  const diff = diffLines(original, formatted)
    .map((part) => {
      const prefix = part.added ? '+' : part.removed ? '-' : ' ';
      return part.value
        .split('\n')
        .filter((line) => line.length > 0)
        .map((line) => `${prefix} ${line}`)
        .join('\n');
    })
    .join('\n');

  return { file: filePath, changed: true, diff, formatted };
}

// Batch process with concurrency limit
async function formatDirectory(
  dir: string,
  options: { fix: boolean; concurrency: number } = { fix: false, concurrency: 3 }
): Promise<void> {
  const files = fs
    .readdirSync(dir, { recursive: true })
    .filter((f): f is string => typeof f === 'string')
    .filter((f) => f.endsWith('.ts') || f.endsWith('.tsx'))
    .map((f) => path.join(dir, f));

  // Process in chunks to avoid rate limits
  for (let i = 0; i < files.length; i += options.concurrency) {
    const chunk = files.slice(i, i + options.concurrency);
    const results = await Promise.all(chunk.map((f) => formatWithDiff(f)));

    for (const result of results) {
      if (result.changed) {
        console.log(`\nChanges in ${result.file}:`);
        console.log(result.diff);

        if (options.fix && result.formatted) {
          fs.writeFileSync(result.file, result.formatted, 'utf-8');
        }
      }
    }
  }
}

// cached-formatter.ts
import * as crypto from 'crypto';

const CACHE_FILE = '.formatter-cache.json';

function loadCache(): Record<string, string> {
  if (fs.existsSync(CACHE_FILE)) {
    return JSON.parse(fs.readFileSync(CACHE_FILE, 'utf-8'));
  }
  return {};
}

function saveCache(cache: Record<string, string>): void {
  fs.writeFileSync(CACHE_FILE, JSON.stringify(cache, null, 2));
}

async function formatWithCache(source: string): Promise<string> {
  const cache = loadCache();
  const hash = crypto.createHash('sha256').update(source).digest('hex');

  if (cache[hash]) {
    return cache[hash];
  }

  const formatted = await formatTypeScript(source);
  cache[hash] = formatted;
  saveCache(cache);

  return formatted;
}

// chunked-formatter.ts
interface CodeChunk {
  startLine: number;
  endLine: number;
  source: string;
}

function splitIntoFunctions(source: string): CodeChunk[] {
  const lines = source.split('\n');
  const chunks: CodeChunk[] = [];
  let chunkStart = 0;
  let braceDepth = 0;
  let inFunction = false;

  for (let i = 0; i < lines.length; i++) {
    const line = lines[i];
    // Track function declarations
    if (/^(export\s+)?(async\s+)?function\s+\w+/.test(line) ||
        /^\s+(async\s+)?\w+\s*\(.*\)\s*\{/.test(line)) {
      if (!inFunction) {
        inFunction = true;
        chunkStart = i;
      }
    }
    // Count braces
    braceDepth += (line.match(/\{/g) || []).length;
    braceDepth -= (line.match(/\}/g) || []).length;

    // Flush chunk when function closes
    if (inFunction && braceDepth === 0) {
      chunks.push({
        startLine: chunkStart,
        endLine: i,
        source: lines.slice(chunkStart, i + 1).join('\n'),
      });
      inFunction = false;
    }
  }

  return chunks;
}

async function formatLargeFile(filePath: string): Promise<string> {
  const source = fs.readFileSync(filePath, 'utf-8');
  const chunks = splitIntoFunctions(source);

  const formattedChunks = await Promise.all(
    chunks.map((chunk) => formatWithCache(chunk.source))
  );

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

const SYSTEM_WITH_EXAMPLES = `You are a TypeScript formatter. Apply these rules:

BEFORE:
function greet(name) {
  return 'Hello, ' + name + '!';
}

AFTER:
function greet(name: string): string {
  return \`Hello, \${name}!\`;
}

Apply the same transformations (type hints, template literals) to all functions.`;