import { Change } from "diff";
import { IThemedToken } from "shiki";
import { DiffLine as DiffLineProto } from "../generated/highlight/DiffLine";
import { FormattedString, applyFormatting } from "./FormattedString";
import { ThemeColor } from "./ThemeColor";

export type DiffLineType = "UNKNOWN" | "ADD" | "DELETE" | "MATCH" | "META";

export interface RawDiffLine {
 index?: number;
 type?: DiffLineType;
 oldNumber?: number;
 newNumber?: number;
 text: string;
 html: string;
}

export class DiffLine {
 private _index: number;
 private _type: DiffLineType;
 private _oldNumber: number;
 private _newNumber: number;
 private _text: string;
 private _formattedText: FormattedString;
 private _tokens: IThemedToken[];
 private _changes: Change[];

 constructor(
 index: number,
 type: DiffLineType,
 oldNumber: number,
 newNumber: number,
 text: string,
 tokens: IThemedToken[],
 ) {
 this._index = index;
 this._type = type;
 this._oldNumber = oldNumber;
 this._newNumber = newNumber;
 this._text = text;
 this._formattedText = new FormattedString().appendString(text);
 this._tokens = tokens;
 this._changes = [];
 }

 get type(): DiffLineType {
 return this._type;
 }

 get text(): string {
 return this._text;
 }

 get formattedText(): FormattedString {
 return this._formattedText;
 }

 get tokens(): IThemedToken[] {
 return this._tokens;
 }

 get changes(): Change[] {
 return this._changes;
 }

 set changes(changes: Change[]) {
 this._changes = changes;
 }

 static from(line: DiffLineProto, tokens: IThemedToken[]): DiffLine {
 const index = line.index || 0;
 const type = (line.type as DiffLineType) || "UNKNOWN";
 const oldNumber = line.oldNumber || 0;
 const newNumber = line.newNumber || 0;
 const text = line.text || "";
 return new DiffLine(index, type, oldNumber, newNumber, text, tokens);
 }

 to(): DiffLineProto {
 const html = applyFormatting(this.formattedText);
 return {
 index: this._index,
 type: this._type,
 oldNumber: this._oldNumber,
 newNumber: this._newNumber,
 text: this._text,
 html: html,
 };
 }

 highlight(): void {
 this.highlightChanges();
 this.highlightSyntax();
 }

 private highlightChanges(): void {
 if (!this._changes) return;

 let wordColor: ThemeColor;
 switch (this._type) {
 case "DELETE":
 wordColor = { color: "sk-del" };
 break;
 case "ADD":
 wordColor = { color: "sk-add" };
 break;
 default:
 wordColor = {}; // This is actually not used
 break;
 }

 let lineIndex = 0;
 for (const change of this._changes) {
 // Skip changes that would not be present in the line
 if (change.removed && this._type === "ADD") {
 continue;
 }
 if (change.added && this._type === "DELETE") {
 continue;
 }
 if (change.removed || change.added) {
 this.formattedText.addSpan(
 lineIndex,
 lineIndex + change.value.length,
 wordColor,
 );
 }
 lineIndex += change.value.length;
 }
 }

 private highlightSyntax(): void {
 if (this._type === "META") return;

 let index = 0;
 for (const { content, color, fontStyle } of this._tokens) {
 if (color || fontStyle) {
 this._formattedText.addSpan(index, index + content.length, {
 color,
 fontStyle,
 });
 }
 if (content) index += content.length;
 }
 }
}