import type { CodePatch, CodePatchSet } from './types'

function stripCodeFence(text: string): string {
  return text
    .replace(/^```(?:json|text)?\s*/i, '')
    .replace(/\s*```$/i, '')
    .trim()
}

function trimPatchBoundary(text: string): string {
  return text
    .replace(/^\s*\r?\n/, '')
    .replace(/\r?\n\s*$/, '')
    .replace(/\r\n/g, '\n')
}

const PATCH_START = '[[PATCH]]'
const SEARCH_START = '[[SEARCH]]'
const REPLACE_START = '[[REPLACE]]'
const PATCH_END = '[[END]]'
const CONTROL_MARKERS = [PATCH_START, SEARCH_START, REPLACE_START, PATCH_END]

function assertNoControlMarkers(text: string, label: string): void {
  for (const marker of CONTROL_MARKERS) {
    if (text.includes(marker)) {
      throw new Error(`Code retry patch ${label} contains nested ${marker} marker`)
    }
  }
}

export function parsePatchResponse(text: string): CodePatchSet {
  const normalized = stripCodeFence(text)
  if (!normalized) {
    throw new Error('Code retry patch response was empty')
  }

  if (/^\s*<!DOCTYPE\s+html/i.test(normalized) || /^\s*<html/i.test(normalized)) {
    throw new Error('Code retry patch response was HTML, not patch text')
  }

  if (!normalized.includes(PATCH_START)) {
    throw new Error('Code retry patch response did not contain any [[PATCH]] blocks')
  }

  const patches: CodePatch[] = []
  let cursor = 0

  while (true) {
    const patchStart = normalized.indexOf(PATCH_START, cursor)
    if (patchStart < 0) {
      break
    }

    let hunkCursor = patchStart + PATCH_START.length
    let hunkCount = 0

    while (true) {
      const searchStart = normalized.indexOf(SEARCH_START, hunkCursor)
      const blockEnd = normalized.indexOf(PATCH_END, hunkCursor)

      if (blockEnd >= 0 && (searchStart < 0 || blockEnd < searchStart)) {
        if (hunkCount === 0) {
          throw new Error('Code retry patch block missing [[SEARCH]] marker')
        }
        cursor = blockEnd + PATCH_END.length
        break
      }

      if (searchStart < 0) {
        throw new Error('Code retry patch block missing [[END]] marker')
      }

      const replaceStart = normalized.indexOf(REPLACE_START, searchStart + SEARCH_START.length)
      if (replaceStart < 0 || (blockEnd >= 0 && blockEnd < replaceStart)) {
        throw new Error('Code retry patch block missing [[REPLACE]] marker')
      }

      const afterReplace = replaceStart + REPLACE_START.length
      const nextSearch = normalized.indexOf(SEARCH_START, afterReplace)
      const nextEnd = normalized.indexOf(PATCH_END, afterReplace)
      const nextPatch = normalized.indexOf(PATCH_START, afterReplace)

      if (nextPatch >= 0 && (nextEnd < 0 || nextPatch < nextEnd) && (nextSearch < 0 || nextPatch < nextSearch)) {
        throw new Error('Code retry patch block missing [[END]] marker')
      }

      const replacementEnd = nextEnd >= 0 && (nextSearch < 0 || nextEnd < nextSearch)
        ? nextEnd
        : nextSearch

      if (replacementEnd < 0) {
        throw new Error('Code retry patch block missing [[END]] marker')
      }

      const originalSnippet = trimPatchBoundary(
        normalized.slice(searchStart + SEARCH_START.length, replaceStart)
      )
      const replacementSnippet = trimPatchBoundary(
        normalized.slice(afterReplace, replacementEnd)
      )

      if (!originalSnippet) {
        throw new Error('Code retry patch block missing SEARCH content')
      }

      assertNoControlMarkers(originalSnippet, 'SEARCH content')
      assertNoControlMarkers(replacementSnippet, 'REPLACE content')

      if (originalSnippet === replacementSnippet) {
        throw new Error('Code retry patch produced no change')
      }

      patches.push({ originalSnippet, replacementSnippet })
      hunkCount += 1
      hunkCursor = replacementEnd
    }
  }

  if (patches.length === 0) {
    throw new Error('Code retry patch response missing patches')
  }

  return { patches }
}

function getLineNumberAtIndex(text: string, index: number): number {
  return text.slice(0, index).split('\n').length
}

export function extractTargetLine(errorMessage: string): number | undefined {
  const match = errorMessage.match(/line\s+(\d+)/i) || errorMessage.match(/:(\d+)(?::\d+)?/)
  if (!match) {
    return undefined
  }

  const line = Number.parseInt(match[1], 10)
  return Number.isFinite(line) && line > 0 ? line : undefined
}

export function extractCodeContext(
  code: string,
  errorMessage: string,
  contextLines = 20,
  maxLength = 6000
): string | undefined {
  const lines = code.split(/\r?\n/)
  const sourceFrames = [...errorMessage.matchAll(/File\s+["']([^"']+\.py)["'],\s+line\s+(\d+)/gi)]
  const projectFrame = sourceFrames.find((match) =>
    !/[\\/](?:site-packages|dist-packages|manim|manimgx)[\\/]/i.test(match[1]) &&
    !/(?:^|[\\/])manimgx-runner\.py$/i.test(match[1])
  )
  const richFrame = errorMessage.match(/[│|]\s*(?:❱|>)\s*(\d+)\s+/)
  const candidate = projectFrame?.[2] || richFrame?.[1]
  const targetLine = candidate ? Number.parseInt(candidate, 10) : extractTargetLine(errorMessage)

  if (typeof targetLine !== 'number' || !Number.isFinite(targetLine) || targetLine < 1 || targetLine > lines.length) {
    return undefined
  }

  const start = Math.max(0, targetLine - contextLines - 1)
  const end = Math.min(lines.length, targetLine + contextLines)
  const snippet = lines.slice(start, end).join('\n').trim()
  if (!snippet) return undefined
  return snippet.length <= maxLength ? snippet : snippet.slice(0, maxLength)
}

export function applyPatchToCode(code: string, patch: CodePatch, targetLine?: number): string {
  const matches: number[] = []
  let searchIndex = 0

  while (true) {
    const foundAt = code.indexOf(patch.originalSnippet, searchIndex)
    if (foundAt < 0) {
      break
    }
    matches.push(foundAt)
    searchIndex = foundAt + Math.max(1, patch.originalSnippet.length)
  }

  if (matches.length === 0) {
    throw new Error('Code retry patch original_snippet not found in code')
  }

  const bestIndex =
    typeof targetLine === 'number'
      ? matches.reduce((best, current) => {
          const bestDistance = Math.abs(getLineNumberAtIndex(code, best) - targetLine)
          const currentDistance = Math.abs(getLineNumberAtIndex(code, current) - targetLine)
          return currentDistance < bestDistance ? current : best
        })
      : matches[0]

  return `${code.slice(0, bestIndex)}${patch.replacementSnippet}${code.slice(bestIndex + patch.originalSnippet.length)}`
}

export function applyPatchSetToCode(code: string, patchSet: CodePatchSet, targetLine?: number): string {
  return patchSet.patches.reduce((currentCode, patch, index) => {
    const lineHint = index === 0 ? targetLine : undefined
    return applyPatchToCode(currentCode, patch, lineHint)
  }, code)
}

export function getErrorType(stderr: string): string {
  if (!stderr) return 'Unknown'

  const errorPatterns = [
    { name: 'MemoryError', pattern: /MemoryError|Unable to allocate|out of memory/i },
    { name: 'NameError', pattern: /NameError/i },
    { name: 'SyntaxError', pattern: /SyntaxError/i },
    { name: 'AttributeError', pattern: /AttributeError/i },
    { name: 'ImportError', pattern: /ImportError/i },
    { name: 'TypeError', pattern: /TypeError/i },
    { name: 'ValueError', pattern: /ValueError/i },
    { name: 'RuntimeError', pattern: /RuntimeError/i },
    { name: 'IndentationError', pattern: /IndentationError/i }
  ]

  for (const { name, pattern } of errorPatterns) {
    if (pattern.test(stderr)) {
      return name
    }
  }

  return 'Unknown'
}

export function extractErrorMessage(stderr: string): string {
  if (!stderr) return 'Unknown error'

  const lines = stderr.trim().split('\n')
  const lastLine = lines[lines.length - 1]?.trim()

  return lastLine || stderr.slice(0, 500)
}

export function extractErrorContext(stderr: string, maxLength = 3000): string {
  if (!stderr) return 'Unknown error'

  const normalized = stderr.replace(/\r\n/g, '\n').trim()
  if (normalized.length <= maxLength) {
    return normalized
  }
  return `...[traceback truncated]\n${normalized.slice(-maxLength)}`
}