import { diffWordsWithSpace } from "diff";

import type { ReviewHighlightedToken } from "./shikiReviewHighlighter";

interface ReviewDiffOperation {
  readonly value: string;
  readonly added?: true;
  readonly removed?: true;
}

interface ReviewDiffHighlightRange {
  readonly start: number;
  readonly end: number;
}

const REVIEW_MAX_WORD_ALT_LINE_LENGTH = 1_000;

function cleanLineEnding(value: string): string {
  return value.endsWith("\n") ? value.slice(0, -1) : value;
}

function pushOrJoinSpan(input: {
  readonly operation: ReviewDiffOperation;
  readonly spans: Array<[0 | 1, string]>;
  readonly enableJoin: boolean;
  readonly isNeutral?: boolean;
  readonly isLastOperation?: boolean;
}): void {
  const { operation, spans, enableJoin, isNeutral = false, isLastOperation = false } = input;
  const lastSpan = spans.at(-1);

  if (!lastSpan || isLastOperation || !enableJoin) {
    spans.push([isNeutral ? 0 : 1, operation.value]);
    return;
  }

  const lastSpanIsNeutral = lastSpan[0] === 0;
  if (
    isNeutral === lastSpanIsNeutral ||
    (isNeutral && operation.value.length === 1 && !lastSpanIsNeutral)
  ) {
    lastSpan[1] += operation.value;
    return;
  }

  spans.push([isNeutral ? 0 : 1, operation.value]);
}

function spansToRanges(
  spans: ReadonlyArray<readonly [0 | 1, string]>,
): ReadonlyArray<ReviewDiffHighlightRange> {
  const ranges: ReviewDiffHighlightRange[] = [];
  let offset = 0;

  spans.forEach(([kind, value]) => {
    const nextOffset = offset + value.length;
    if (kind === 1 && value.length > 0) {
      ranges.push({ start: offset, end: nextOffset });
    }
    offset = nextOffset;
  });

  return ranges;
}

function mergeNearbyRanges(
  ranges: ReadonlyArray<ReviewDiffHighlightRange>,
): ReadonlyArray<ReviewDiffHighlightRange> {
  if (ranges.length <= 1) {
    return ranges;
  }

  const merged: ReviewDiffHighlightRange[] = [];

  ranges.forEach((range) => {
    const previous = merged.at(-1);
    if (previous && range.start - previous.end <= 1) {
      merged[merged.length - 1] = { start: previous.start, end: range.end };
      return;
    }
    merged.push({ ...range });
  });

  return merged;
}

function appendTokenSegment(
  target: ReviewHighlightedToken[],
  source: ReviewHighlightedToken,
  content: string,
  diffHighlight: boolean,
): void {
  if (content.length === 0) {
    return;
  }

  const previous = target.at(-1);
  if (
    previous &&
    previous.color === source.color &&
    previous.fontStyle === source.fontStyle &&
    previous.diffHighlight === diffHighlight
  ) {
    previous.content += content;
    return;
  }

  target.push({
    content,
    color: source.color,
    fontStyle: source.fontStyle,
    diffHighlight,
  });
}

export function computeWordAltDiffRanges(input: {
  readonly deletionLine: string;
  readonly additionLine: string;
}): {
  readonly deletion: ReadonlyArray<ReviewDiffHighlightRange>;
  readonly addition: ReadonlyArray<ReviewDiffHighlightRange>;
} {
  const deletionLine = cleanLineEnding(input.deletionLine);
  const additionLine = cleanLineEnding(input.additionLine);

  if (deletionLine.length === 0 && additionLine.length === 0) {
    return { deletion: [], addition: [] };
  }

  if (
    deletionLine.length > REVIEW_MAX_WORD_ALT_LINE_LENGTH ||
    additionLine.length > REVIEW_MAX_WORD_ALT_LINE_LENGTH
  ) {
    return { deletion: [], addition: [] };
  }

  const operations = diffWordsWithSpace(
    deletionLine,
    additionLine,
  ) as ReadonlyArray<ReviewDiffOperation>;
  const deletionSpans: Array<[0 | 1, string]> = [];
  const additionSpans: Array<[0 | 1, string]> = [];
  const lastOperation = operations.at(-1);

  operations.forEach((operation) => {
    const isLastOperation = operation === lastOperation;
    if (!operation.added && !operation.removed) {
      pushOrJoinSpan({
        operation,
        spans: deletionSpans,
        enableJoin: true,
        isNeutral: true,
        isLastOperation,
      });
      pushOrJoinSpan({
        operation,
        spans: additionSpans,
        enableJoin: true,
        isNeutral: true,
        isLastOperation,
      });
      return;
    }

    if (operation.removed) {
      pushOrJoinSpan({
        operation,
        spans: deletionSpans,
        enableJoin: true,
        isLastOperation,
      });
      return;
    }

    pushOrJoinSpan({
      operation,
      spans: additionSpans,
      enableJoin: true,
      isLastOperation,
    });
  });

  return {
    deletion: mergeNearbyRanges(spansToRanges(deletionSpans)),
    addition: mergeNearbyRanges(spansToRanges(additionSpans)),
  };
}

export function applyDiffRangesToTokens(
  tokens: ReadonlyArray<ReviewHighlightedToken>,
  ranges: ReadonlyArray<ReviewDiffHighlightRange>,
): ReadonlyArray<ReviewHighlightedToken> {
  if (tokens.length === 0 || ranges.length === 0) {
    return tokens;
  }

  const nextTokens: ReviewHighlightedToken[] = [];
  let tokenOffset = 0;
  let rangeIndex = 0;

  tokens.forEach((token) => {
    const tokenStart = tokenOffset;
    const tokenEnd = tokenStart + token.content.length;
    tokenOffset = tokenEnd;

    if (token.content.length === 0) {
      nextTokens.push(token);
      return;
    }

    while (rangeIndex < ranges.length && ranges[rangeIndex]!.end <= tokenStart) {
      rangeIndex += 1;
    }

    if ((ranges[rangeIndex]?.start ?? Number.POSITIVE_INFINITY) >= tokenEnd) {
      nextTokens.push(token.diffHighlight ? { ...token, diffHighlight: false } : token);
      return;
    }

    let cursor = tokenStart;
    let localRangeIndex = rangeIndex;

    while ((ranges[localRangeIndex]?.start ?? Number.POSITIVE_INFINITY) < tokenEnd) {
      const range = ranges[localRangeIndex];
      if (!range) {
        break;
      }

      if (range.start > cursor) {
        appendTokenSegment(
          nextTokens,
          token,
          token.content.slice(cursor - tokenStart, range.start - tokenStart),
          false,
        );
      }

      const highlightedStart = Math.max(cursor, range.start);
      const highlightedEnd = Math.min(tokenEnd, range.end);

      if (highlightedEnd > highlightedStart) {
        appendTokenSegment(
          nextTokens,
          token,
          token.content.slice(highlightedStart - tokenStart, highlightedEnd - tokenStart),
          true,
        );
      }

      cursor = highlightedEnd;
      if (range.end <= tokenEnd) {
        localRangeIndex += 1;
      } else {
        break;
      }
    }

    if (cursor < tokenEnd) {
      appendTokenSegment(nextTokens, token, token.content.slice(cursor - tokenStart), false);
    }

    rangeIndex = localRangeIndex;
  });

  return nextTokens;
}