import { splitPromptIntoComposerSegments } from "./composer-editor-mentions";

export interface ComposerListEdit {
  start: number;
  end: number;
  replacement: string;
  /** Expanded caret offset after the edit is applied. */
  cursorAfter: number;
}

type ListMarker =
  | { kind: "ordered"; indent: string; numberText: string; delimiter: "." | ")"; space: string }
  | { kind: "task"; indent: string; space: string }
  | { kind: "bullet"; indent: string; bullet: string; space: string };

interface ParsedListMarker {
  marker: ListMarker;
  markerEnd: number;
  /** Column a nested item must reach to belong to this item. */
  contentColumn: number;
}

function parseListMarker(line: string): ParsedListMarker | null {
  const indent = line.match(/^[ \t]*/)?.[0] ?? "";
  const rest = line.slice(indent.length);
  const ordered = rest.match(/^(\d+)([.)])((?:[ \t]+)|\s*$)/);
  if (ordered && ordered[1] !== undefined && ordered[2] !== undefined) {
    const space = ordered[3] ?? "";
    return {
      marker: {
        kind: "ordered",
        indent,
        numberText: ordered[1],
        delimiter: ordered[2] === ")" ? ")" : ".",
        space,
      },
      markerEnd: indent.length + ordered[0].length,
      contentColumn: contentColumn(indent, ordered[1].length + 1, space),
    };
  }
  // The checkbox is item content, so a task's content starts after "- ".
  const task = rest.match(/^-(\s)\[[ xX]\]((?:[ \t]+)|\s*$)/);
  if (task && task[1] !== undefined) {
    return {
      marker: { kind: "task", indent, space: task[2] ?? "" },
      markerEnd: indent.length + task[0].length,
      contentColumn: contentColumn(indent, 1, task[1]),
    };
  }
  const bullet = rest.match(/^([-*+])((?:[ \t]+)|\s*$)/);
  if (bullet && bullet[1] !== undefined) {
    const space = bullet[2] ?? "";
    return {
      marker: { kind: "bullet", indent, bullet: bullet[1], space },
      markerEnd: indent.length + bullet[0].length,
      contentColumn: contentColumn(indent, 1, space),
    };
  }
  return null;
}

// CommonMark content follows 1-4 columns of padding; wider padding is code, so the content
// column sits one column past the marker.
function contentColumn(indent: string, markerWidth: number, padding: string): number {
  const markerEnd = indentWidth(indent) + markerWidth;
  const space = indentWidth(padding, markerEnd);
  return markerEnd + (space >= 1 && space <= 4 ? space : 1);
}

export function nextOrderedMarkerText(marker: string): string {
  const numberText = marker.slice(0, -1);
  const delimiter = marker.slice(-1);
  const number = Number.parseInt(numberText, 10);
  const next = Number.isSafeInteger(number)
    ? String(number + 1).padStart(numberText.length, "0")
    : numberText;
  return `${next}${delimiter}`;
}

function nextMarkerText(marker: ListMarker): string {
  if (marker.kind === "ordered") {
    return `${marker.indent}${nextOrderedMarkerText(`${marker.numberText}${marker.delimiter}`)} `;
  }
  if (marker.kind === "task") {
    return `${marker.indent}- [ ] `;
  }
  return `${marker.indent}${marker.bullet} `;
}

// Markdown tabs advance to the next four-column stop.
function indentWidth(line: string, fromColumn = 0): number {
  let column = fromColumn;
  for (const char of line) {
    if (char === " ") column += 1;
    else if (char === "\t") column += 4 - (column % 4);
    else break;
  }
  return column - fromColumn;
}

function renumberFollowingItems(
  value: string,
  afterLineEnd: number,
  marker: Extract<ListMarker, { kind: "ordered" }>,
  tokens: ReturnType<typeof inlineTokenRanges>,
): { end: number; text: string } | null {
  const baseWidth = indentWidth(marker.indent);
  const parts: string[] = [];
  let expected = Number.parseInt(marker.numberText, 10) + 2;
  let position = afterLineEnd;
  let copiedUntil = afterLineEnd;
  let tokenIndex = 0;
  while (position < value.length && Number.isSafeInteger(expected)) {
    const lineStart = position + 1;
    const nextBreak = value.indexOf("\n", lineStart);
    const lineEnd = nextBreak === -1 ? value.length : nextBreak;
    position = lineEnd;
    let token = tokens[tokenIndex];
    while (token && token.end <= lineStart) {
      tokenIndex += 1;
      token = tokens[tokenIndex];
    }
    // A newline inside a chip does not start a list item.
    if (token && token.start < lineStart) continue;

    const line = value.slice(lineStart, lineEnd);
    const width = indentWidth(line);
    if (line.trim() === "" || width < baseWidth) break;
    if (width > baseWidth) continue;
    const parsed = parseListMarker(line);
    if (parsed?.marker.kind !== "ordered" || parsed.marker.delimiter !== marker.delimiter) break;

    const current = parsed.marker;
    const numberStart = lineStart + current.indent.length;
    const numberEnd = numberStart + current.numberText.length;
    const replacement = current.numberText.startsWith("0")
      ? String(expected).padStart(current.numberText.length, "0")
      : String(expected);
    if (replacement !== current.numberText) {
      parts.push(value.slice(copiedUntil, numberStart), replacement);
      copiedUntil = numberEnd;
    }
    expected += 1;
  }
  return parts.length === 0 ? null : { end: copiedUntil, text: parts.join("") };
}

function inlineTokenRanges(value: string): Array<{ start: number; end: number }> {
  const ranges: Array<{ start: number; end: number }> = [];
  let offset = 0;
  for (const segment of splitPromptIntoComposerSegments(value)) {
    const end = offset + (segment.type === "text" ? segment.text : segment.source).length;
    if (segment.type !== "text") ranges.push({ start: offset, end });
    offset = end;
  }
  return ranges;
}

function isInsideInlineToken(
  tokens: ReturnType<typeof inlineTokenRanges>,
  cursor: number,
): boolean {
  return tokens.some((range) => cursor > range.start && cursor < range.end);
}

function currentLine(value: string, cursor: number): { start: number; end: number; text: string } {
  const start = value.lastIndexOf("\n", cursor - 1) + 1;
  const endIndex = value.indexOf("\n", cursor);
  const end = endIndex === -1 ? value.length : endIndex;
  return { start, end, text: value.slice(start, end) };
}

function* listMarkersAbove(
  value: string,
  lineStart: number,
  tokens: ReturnType<typeof inlineTokenRanges>,
): Generator<ParsedListMarker> {
  let tokenIndex = tokens.length - 1;
  while (lineStart > 0) {
    const lineEnd = lineStart - 1;
    lineStart = value.lastIndexOf("\n", lineEnd - 1) + 1;
    // A newline inside a chip does not start a list item.
    for (let token = tokens[tokenIndex]; token; token = tokens[tokenIndex]) {
      if (token.start >= lineStart) tokenIndex -= 1;
      else if (token.end > lineStart) lineStart = value.lastIndexOf("\n", token.start - 1) + 1;
      else break;
    }
    const parsed = parseListMarker(value.slice(lineStart, lineEnd));
    if (!parsed) return;
    yield parsed;
  }
}

function parentMarker(
  value: string,
  lineStart: number,
  marker: ListMarker,
  tokens: ReturnType<typeof inlineTokenRanges>,
): ListMarker | null {
  const width = indentWidth(marker.indent);
  for (const above of listMarkersAbove(value, lineStart, tokens)) {
    if (indentWidth(above.marker.indent) < width) return above.marker;
  }
  return null;
}

function nestedNumber(
  marker: ListMarker,
  previousChild: ListMarker | undefined,
): { replacedLength: number; text: string } {
  if (marker.kind !== "ordered") return { replacedLength: 0, text: "" };
  const continues =
    previousChild?.kind === "ordered" && previousChild.delimiter === marker.delimiter;
  return {
    replacedLength: marker.numberText.length,
    text: continues
      ? nextOrderedMarkerText(`${previousChild.numberText}${marker.delimiter}`).slice(0, -1)
      : "1",
  };
}

export function listContinuationForEnter(value: string, cursor: number): ComposerListEdit | null {
  if (!Number.isInteger(cursor) || cursor < 0 || cursor > value.length) return null;
  const line = currentLine(value, cursor);
  const parsed = parseListMarker(line.text);
  if (!parsed || parsed.marker.space === "") return null;
  const markerEnd = line.start + parsed.markerEnd;
  if (cursor < markerEnd) return null;
  const tokens = inlineTokenRanges(value);
  if (isInsideInlineToken(tokens, cursor)) return null;
  if (value.slice(markerEnd, line.end).trim() === "") {
    const parent = parentMarker(value, line.start, parsed.marker, tokens);
    const replacement = parent ? nextMarkerText(parent) : "";
    const cursorAfter = line.start + replacement.length;
    const end = Math.max(cursor, markerEnd);
    const renumbered =
      parent?.kind === "ordered" ? renumberFollowingItems(value, line.end, parent, tokens) : null;
    if (renumbered) {
      return {
        start: line.start,
        end: renumbered.end,
        replacement: replacement + value.slice(end, line.end) + renumbered.text,
        cursorAfter,
      };
    }
    return { start: line.start, end, replacement, cursorAfter };
  }
  const insertion = `\n${nextMarkerText(parsed.marker)}`;
  const cursorAfter = cursor + insertion.length;
  const { marker } = parsed;
  if (marker.kind === "ordered") {
    const renumbered = renumberFollowingItems(value, line.end, marker, tokens);
    if (renumbered) {
      return {
        start: cursor,
        end: renumbered.end,
        replacement: insertion + value.slice(cursor, line.end) + renumbered.text,
        cursorAfter,
      };
    }
  }
  return { start: cursor, end: cursor, replacement: insertion, cursorAfter };
}

export function listIndentForTab(
  value: string,
  start: number,
  end: number,
): ComposerListEdit | null {
  if (!Number.isInteger(start) || start !== end || start < 0 || start > value.length) return null;
  const line = currentLine(value, start);
  const parsed = parseListMarker(line.text);
  if (!parsed) return null;
  const tokens = inlineTokenRanges(value);
  if (isInsideInlineToken(tokens, start)) return null;
  const { marker } = parsed;
  const width = indentWidth(marker.indent);
  let previousChild: ListMarker | undefined;
  for (const above of listMarkersAbove(value, line.start, tokens)) {
    const aboveWidth = indentWidth(above.marker.indent);
    if (aboveWidth < width) break;
    if (aboveWidth > width) {
      if (!previousChild || aboveWidth < indentWidth(previousChild.indent)) {
        previousChild = above.marker;
      }
      continue;
    }
    const indent =
      previousChild?.indent ?? above.marker.indent + " ".repeat(above.contentColumn - aboveWidth);
    const number = nestedNumber(marker, previousChild);
    const replacedEnd = line.start + marker.indent.length + number.replacedLength;
    const replacement = indent + number.text;
    return {
      start: line.start,
      end: replacedEnd,
      replacement,
      cursorAfter:
        start < replacedEnd
          ? line.start + indent.length
          : start - replacedEnd + line.start + replacement.length,
    };
  }
  return { start: line.start, end: line.start, replacement: "  ", cursorAfter: start + 2 };
}

export function listOutdentForTab(
  value: string,
  start: number,
  end: number,
): ComposerListEdit | null {
  if (!Number.isInteger(start) || start !== end || start < 0 || start > value.length) return null;
  const line = currentLine(value, start);
  const parsed = parseListMarker(line.text);
  if (!parsed?.marker.indent) return null;
  const tokens = inlineTokenRanges(value);
  if (isInsideInlineToken(tokens, start)) return null;
  const { marker } = parsed;
  const parent = parentMarker(value, line.start, marker, tokens);
  // With no parent above, undo one step of Tab's two-space fallback.
  const indent = parent?.indent ?? marker.indent.replace(/^(?:\t| {1,2})/, "");
  const continues =
    parent?.kind === "ordered" &&
    marker.kind === "ordered" &&
    parent.delimiter === marker.delimiter;
  const number = continues ? nestedNumber(marker, parent) : { replacedLength: 0, text: "" };
  const replacedEnd = line.start + marker.indent.length + number.replacedLength;
  const replacement = indent + number.text;
  const cursorAfter =
    start < replacedEnd
      ? line.start + indent.length
      : start - replacedEnd + line.start + replacement.length;
  const renumbered = continues ? renumberFollowingItems(value, line.end, parent, tokens) : null;
  if (renumbered) {
    return {
      start: line.start,
      end: renumbered.end,
      replacement: replacement + value.slice(replacedEnd, line.end) + renumbered.text,
      cursorAfter,
    };
  }
  return { start: line.start, end: replacedEnd, replacement, cursorAfter };
}