import { diffWords } from "diff";
import { ThemedToken } from "shiki";
import { DiffLine as DiffLineProto } from "../generated/highlight/DiffLine";
import Highlight from "../highlight";
import { DiffLine } from "./DiffLine";
import { Context } from "./context";

const HIGHLIGHT_CHANGE_RATIO = 1.0;

export class DiffFile {
 private _highlight: Highlight;
 private _oldPath: string;
 private _oldText: string;
 private _newPath: string;
 private _newText: string;
 _context: Context;
 _rawlines: DiffLineProto[];

 constructor(
 highlight: Highlight,
 oldPath: string | undefined,
 oldText: string | undefined,
 newPath: string | undefined,
 newText: string | undefined,

 context: Context,
 rawLines: DiffLineProto[],
 ) {
 this._highlight = highlight;
 this._oldPath = oldPath || "";
 this._oldText = oldText || "";
 this._newPath = newPath || "";
 this._newText = newText || "";
 this._context = context;
 this._rawlines = rawLines;
 }

 private async oldTokens(): Promise<ThemedToken[][]> {
 return (await this._highlight.tokensAsync(this._oldText)) || [];
 }

 private async newTokens(): Promise<ThemedToken[][]> {
 return (await this._highlight.tokensAsync(this._newText)) || [];
 }

 async highlight() {
 const linesA: (DiffLine | null)[] = [];
 const linesB: (DiffLine | null)[] = [];
 const result: DiffLine[] = [];
 const oldTokens: ThemedToken[][] = await this.oldTokens();
 const newTokens: ThemedToken[][] = await this.newTokens();

 for (const rawLine of this._rawlines) {
 const tokens =
 (rawLine.type === "DELETE"
 ? oldTokens.at((rawLine.oldNumber || 0) - 1)
 : newTokens.at((rawLine.newNumber || 0) - 1)) || [];

 const line = DiffLine.from(rawLine, tokens);
 result.push(line);

 if (line.type === "DELETE") {
 linesA.push(line);
 } else if (line.type === "ADD") {
 linesB.push(line);
 } else {
 while (linesA.length < linesB.length) {
 linesA.push(null);
 }
 while (linesB.length < linesA.length) {
 linesB.push(null);
 }
 linesA.push(line);
 linesB.push(line);
 }
 }

 this.getChanges(linesA, linesB);
 for (const line of result) {
 line.highlight();
 }

 return result;
 }

 private getChanges(
 linesA: (DiffLine | null)[],
 linesB: (DiffLine | null)[],
 ): void {
 const { colorWords } = this._context;
 if (!colorWords) return;

 const length = Math.max(linesA.length, linesB.length);
 for (let i = 0; i < length; i++) {
 const lineA = linesA[i];
 const lineB = linesB[i];
 if (lineA === lineB || !lineA?.text || !lineB?.text) {
 continue;
 }
 this.getChangesInLine(lineA, lineB);
 }
 }

 /**
 * Given a pair of lines from a diff, returns more granular changes to the
 * lines. Attempts to only return changes that are useful. The current heuristic
 * is to only show granular changes if the ratio of change to unchanged parts in
 * the line is below a threshold, otherwise the lines have changed substantially
 * enough for the granular diffs to not be useful.
 */
 private getChangesInLine(lineA: DiffLine, lineB: DiffLine): void {
 const { ignoreCase, ignoreWhitespace } = this._context;

 // Drop the prefix
 const changes = diffWords(lineA.text, lineB.text, {
 ignoreCase,
 ignoreWhitespace,
 });

 // Count how many words changed vs total words. Note that a replacement gets
 // double counted.
 let changedWords = 0;
 let totalWords = 0;
 for (const { added, removed, count } of changes) {
 if (added || removed) {
 changedWords += count ?? 0;
 } else {
 totalWords += count ?? 0;
 }
 }
 if (changedWords > totalWords * HIGHLIGHT_CHANGE_RATIO) {
 return;
 }

 lineA.changes = changes;
 lineB.changes = changes;
 }
}