/*
 * Copyright (C) 2026 Mateusz Gruszczyński @linuxiarz.pl
 * Source-Available Code / Dual-Licensed.
 * 
 * Free for non-commercial and evaluation use under terms of BSL/GPLv3.
 * Commercial or production use requires a valid paid license.
 * See LICENSE file in repository root for details.
 */

const VERSION = 2;
const OWNER_COLOR_SEPARATOR = "\u001f";

function ownerIdentity(owner) {
  return String(owner || "").split(OWNER_COLOR_SEPARATOR, 1)[0];
}

function normalize(spans, length) {
  const sorted = (Array.isArray(spans) ? spans : [])
    .map(span => ({
      start: Math.max(0, Math.min(length, Number(span?.start) || 0)),
      end: Math.max(0, Math.min(length, Number(span?.end) || 0)),
      owner: String(span?.owner || ""),
    }))
    .filter(span => span.owner && span.end > span.start)
    .sort((a, b) => a.start - b.start || a.end - b.end);

  const result = [];
  for (const span of sorted) {
    const previous = result.at(-1);
    if (previous && previous.owner === span.owner && span.start <= previous.end) {
      previous.end = Math.max(previous.end, span.end);
      continue;
    }
    if (previous && span.start < previous.end) span.start = previous.end;
    if (span.end > span.start) result.push(span);
  }
  return result;
}

function fromLineOwners(content, owners) {
  const spans = [];
  let offset = 0;
  content.split("\n").forEach((line, index, lines) => {
    const length = line.length + (index < lines.length - 1 ? 1 : 0);
    const owner = String(owners[index] || "");
    if (owner && length > 0) spans.push({ start: offset, end: offset + length, owner });
    offset += length;
  });
  return normalize(spans, content.length);
}

export function parseAuthorship(content, raw) {
  let parsed;
  try { parsed = typeof raw === "string" ? JSON.parse(raw || "[]") : raw; } catch { parsed = []; }
  if (Array.isArray(parsed)) return { version: VERSION, spans: fromLineOwners(content, parsed) };
  if (parsed && parsed.version === VERSION && Array.isArray(parsed.spans)) {
    return { version: VERSION, spans: normalize(parsed.spans, content.length) };
  }
  return { version: VERSION, spans: [] };
}

export function serializeAuthorship(model, contentLength) {
  const canonical = canonicalSpans(model, contentLength);
  const spans = canonical
    ? canonical.map(span => ({ start: span.start, end: span.end, owner: span.owner }))
    : normalize(model?.spans, contentLength);
  return JSON.stringify({ version: VERSION, spans });
}

function canonicalSpans(model, length) {
  const spans = model?.spans;
  if (!Array.isArray(spans)) return null;
  let previousEnd = 0, previousOwner = "";
  for (const span of spans) {
    if (!span || typeof span.owner !== "string" || !span.owner
      || !Number.isFinite(span.start) || !Number.isFinite(span.end)
      || span.start < previousEnd || span.end <= span.start || span.end > length
      || (span.start === previousEnd && span.owner === previousOwner)) return null;
    previousEnd = span.end;
    previousOwner = span.owner;
  }
  return spans;
}

function appendCanonicalSpan(result, start, end, owner) {
  if (!owner || end <= start) return;
  const previous = result.at(-1);
  if (previous?.owner === owner && start <= previous.end) {
    previous.end = Math.max(previous.end, end);
  } else result.push({ start, end, owner });
}

function fastAuthorshipEdit(spans, prefix, oldSuffix, insertedLength, delta, owner) {
  const result = [];
  let inserted = false;
  const insert = () => {
    if (!inserted) {
      appendCanonicalSpan(result, prefix, prefix + insertedLength, owner ? String(owner) : "");
      inserted = true;
    }
  };
  for (const span of spans) {
    if (span.end <= prefix) {
      appendCanonicalSpan(result, span.start, span.end, span.owner);
    } else if (span.start >= oldSuffix) {
      insert();
      appendCanonicalSpan(result, span.start + delta, span.end + delta, span.owner);
    } else {
      if (span.start < prefix) appendCanonicalSpan(result, span.start, prefix, span.owner);
      insert();
      if (span.end > oldSuffix) {
        appendCanonicalSpan(result, prefix + insertedLength, span.end + delta, span.owner);
      }
    }
  }
  insert();
  return { version: VERSION, spans: result };
}

export function applyAuthorshipEdit(model, previousText, nextText, owner) {
  if (previousText === nextText) return parseAuthorship(nextText, model);
  let prefix = 0;
  const shared = Math.min(previousText.length, nextText.length);
  while (prefix < shared && previousText.charCodeAt(prefix) === nextText.charCodeAt(prefix)) prefix++;

  let oldSuffix = previousText.length;
  let newSuffix = nextText.length;
  while (oldSuffix > prefix && newSuffix > prefix && previousText.charCodeAt(oldSuffix - 1) === nextText.charCodeAt(newSuffix - 1)) {
    oldSuffix--;
    newSuffix--;
  }

  const removedLength = oldSuffix - prefix;
  const insertedLength = newSuffix - prefix;
  const delta = insertedLength - removedLength;
  const canonical = canonicalSpans(model, previousText.length);
  if (canonical) return fastAuthorshipEdit(canonical, prefix, oldSuffix, insertedLength, delta, owner);
  const updated = [];

  for (const source of normalize(model?.spans, previousText.length)) {
    if (source.end <= prefix) {
      updated.push({ ...source });
      continue;
    }
    if (source.start >= oldSuffix) {
      updated.push({ start: source.start + delta, end: source.end + delta, owner: source.owner });
      continue;
    }
    if (source.start < prefix) updated.push({ start: source.start, end: prefix, owner: source.owner });
    if (source.end > oldSuffix) updated.push({ start: prefix + insertedLength, end: source.end + delta, owner: source.owner });
  }

  if (insertedLength > 0 && owner) updated.push({ start: prefix, end: prefix + insertedLength, owner: String(owner) });
  return { version: VERSION, spans: normalize(updated, nextText.length) };
}

export function replaceAuthorshipOwner(model, matcher, replacement, contentLength) {
  const canonical = canonicalSpans(model, contentLength);
  if (canonical) {
    const spans = [];
    for (const span of canonical) {
      const owner = matcher(span.owner) ? String(replacement || "") : span.owner;
      appendCanonicalSpan(spans, span.start, span.end, owner);
    }
    return { version: VERSION, spans };
  }

  return {
    version: VERSION,
    spans: normalize((model?.spans || []).map(span => matcher(span.owner) ? { ...span, owner: replacement } : span), contentLength),
  };
}

export function authorshipOwners(model) {
  const owners = new Map();
  for (const span of model?.spans || []) {
    const identity = ownerIdentity(span.owner);
    if (identity) owners.set(identity, span.owner);
  }
  return [...owners.values()];
}

export function lineAuthors(content, model) {
  const spans = model?.spans || [];
  const starts = [0];
  for (let i = 0; i < content.length; i++) if (content.charCodeAt(i) === 10) starts.push(i + 1);

  let canonical = true;
  for (let i = 0, previousEnd = 0; i < spans.length; i++) {
    const span = spans[i];
    if (!Number.isFinite(span?.start) || !Number.isFinite(span?.end)
      || span.start < previousEnd || span.end < span.start) {
      canonical = false;
      break;
    }
    previousEnd = span.end;
  }

  let cursor = 0;
  return starts.map((start, index) => {
    const end = index + 1 < starts.length ? starts[index + 1] : content.length;
    const totals = new Map();
    const representatives = new Map();
    if (canonical) {
      while (cursor < spans.length && spans[cursor].end <= start) cursor++;
    }
    for (let i = canonical ? cursor : 0; i < spans.length; i++) {
      const span = spans[i];
      if (canonical && span.start >= end) break;
      const overlap = Math.max(0, Math.min(end, span.end) - Math.max(start, span.start));
      if (!overlap) continue;
      const identity = ownerIdentity(span.owner);
      totals.set(identity, (totals.get(identity) || 0) + overlap);
      representatives.set(identity, span.owner);
    }
    return [...totals.entries()]
      .sort((a, b) => b[1] - a[1])
      .map(([identity]) => representatives.get(identity));
  });
}

export function mapSelectionThroughEdit(previousText, nextText, start, end = start) {
  if (previousText === nextText) return { start, end };
  let prefix = 0;
  const shared = Math.min(previousText.length, nextText.length);
  while (prefix < shared && previousText.charCodeAt(prefix) === nextText.charCodeAt(prefix)) prefix++;

  let oldSuffix = previousText.length;
  let newSuffix = nextText.length;
  while (oldSuffix > prefix && newSuffix > prefix && previousText.charCodeAt(oldSuffix - 1) === nextText.charCodeAt(newSuffix - 1)) {
    oldSuffix--;
    newSuffix--;
  }

  const insertedLength = newSuffix - prefix;
  const delta = insertedLength - (oldSuffix - prefix);
  const map = position => {
    if (position < prefix) return position;
    if (position > oldSuffix) return position + delta;
    if (position === prefix && oldSuffix === prefix) return prefix + insertedLength;
    return prefix + insertedLength;
  };
  return {
    start: Math.max(0, Math.min(nextText.length, map(start))),
    end: Math.max(0, Math.min(nextText.length, map(end))),
  };
}
export function syncAuthorshipLayer(layer, editor) {
  if (!layer || !editor) return;
  const canvas = layer.querySelector(".authorship-canvas");
  if (!canvas) return;
  canvas.style.transform = `translate3d(${-editor.scrollLeft}px, ${-editor.scrollTop}px, 0)`;
  layer.scrollTop = 0;
  layer.scrollLeft = 0;
}

export function renderAuthorshipLayer(layer, editor, model, colorFor) {
  if (!layer) return;
  const style = getComputedStyle(editor);
  layer.style.left = `${editor.offsetLeft}px`;
  const canvas = document.createElement("div");
  canvas.className = "authorship-canvas";
  canvas.style.paddingTop = style.paddingTop;
  canvas.style.paddingRight = style.paddingRight;
  canvas.style.paddingBottom = style.paddingBottom;
  canvas.style.paddingLeft = style.paddingLeft;
  canvas.style.fontFamily = style.fontFamily;
  canvas.style.fontSize = style.fontSize;
  canvas.style.fontWeight = style.fontWeight;
  canvas.style.lineHeight = style.lineHeight;
  canvas.style.letterSpacing = style.letterSpacing;
  canvas.style.minWidth = `${editor.scrollWidth}px`;
  canvas.style.minHeight = `${editor.scrollHeight}px`;
  const text = editor.value;
  let cursor = 0;
  for (const span of normalize(model?.spans, text.length)) {
    if (span.start > cursor) canvas.append(document.createTextNode(text.slice(cursor, span.start)));
    const mark = document.createElement("span");
    mark.className = "authorship-fragment";
    mark.style.setProperty("--owner", colorFor(span.owner));
    mark.textContent = text.slice(span.start, span.end);
    mark.title = span.owner.split("\u001f", 1)[0];
    canvas.append(mark);
    cursor = span.end;
  }
  if (cursor < text.length) canvas.append(document.createTextNode(text.slice(cursor)));
  if (!text.endsWith("\n")) canvas.append(document.createTextNode("\n"));
  layer.replaceChildren(canvas);
  syncAuthorshipLayer(layer, editor);
}