import * as Effect from "effect/Effect";
import * as Schema from "effect/Schema";

import { getUrlDiagnostics } from "@t3tools/shared/urlDiagnostics";

export interface UpdateManifestFile {
  readonly url: string;
  readonly sha512: string;
  readonly size: number;
}

export const UpdateManifestScalar = Schema.Union([Schema.String, Schema.Number, Schema.Boolean]);
export type UpdateManifestScalar = typeof UpdateManifestScalar.Type;

export const UpdateManifestScalarType = Schema.Literals(["string", "number", "boolean"]);
export type UpdateManifestScalarType = typeof UpdateManifestScalarType.Type;

export const UpdateManifestParseReason = Schema.Literals([
  "incomplete file entry",
  "sha512 without a file entry",
  "size without a file entry",
  "unsupported line",
  "version must be a string",
  "releaseDate must be a string",
  "missing version",
  "missing releaseDate",
  "missing files",
]);
export type UpdateManifestParseReason = typeof UpdateManifestParseReason.Type;

export class UpdateManifestParseError extends Schema.TaggedErrorClass<UpdateManifestParseError>()(
  "UpdateManifestParseError",
  {
    platformLabel: Schema.String,
    sourcePath: Schema.String,
    lineNumber: Schema.optionalKey(Schema.Number),
    reason: UpdateManifestParseReason,
    lineLength: Schema.optionalKey(Schema.Number),
  },
) {
  override get message(): string {
    const location =
      this.lineNumber === undefined ? this.sourcePath : `${this.sourcePath}:${this.lineNumber}`;
    const input = this.lineLength === undefined ? "" : ` Input length: ${this.lineLength}.`;
    return `Invalid ${this.platformLabel} update manifest at ${location}: ${this.reason}.${input}`;
  }
}

export class UpdateManifestVersionConflictError extends Schema.TaggedErrorClass<UpdateManifestVersionConflictError>()(
  "UpdateManifestVersionConflictError",
  {
    platformLabel: Schema.String,
    primaryVersion: Schema.String,
    secondaryVersion: Schema.String,
  },
) {
  override get message(): string {
    return `Cannot merge ${this.platformLabel} update manifests with different versions (${this.primaryVersion} vs ${this.secondaryVersion}).`;
  }
}

export class UpdateManifestExtraConflictError extends Schema.TaggedErrorClass<UpdateManifestExtraConflictError>()(
  "UpdateManifestExtraConflictError",
  {
    platformLabel: Schema.String,
    key: Schema.String,
    primaryValueType: UpdateManifestScalarType,
    primaryValueLength: Schema.optionalKey(Schema.Number),
    secondaryValueType: UpdateManifestScalarType,
    secondaryValueLength: Schema.optionalKey(Schema.Number),
  },
) {
  override get message(): string {
    return `Cannot merge ${this.platformLabel} update manifests: conflicting '${this.key}' ${this.primaryValueType} and ${this.secondaryValueType} values.`;
  }
}

export class UpdateManifestFileConflictError extends Schema.TaggedErrorClass<UpdateManifestFileConflictError>()(
  "UpdateManifestFileConflictError",
  {
    platformLabel: Schema.String,
    urlInputLength: Schema.Number,
    urlProtocol: Schema.optionalKey(Schema.String),
    urlHostname: Schema.optionalKey(Schema.String),
    existingManifest: Schema.Literals(["primary", "secondary"]),
    existingSha512Length: Schema.Number,
    existingSize: Schema.Number,
    conflictingManifest: Schema.Literals(["primary", "secondary"]),
    conflictingSha512Length: Schema.Number,
    conflictingSize: Schema.Number,
    sha512Conflict: Schema.Boolean,
    sizeConflict: Schema.Boolean,
  },
) {
  override get message(): string {
    const origin =
      this.urlProtocol === undefined || this.urlHostname === undefined
        ? ""
        : ` at ${this.urlProtocol}//${this.urlHostname}`;
    return `Cannot merge ${this.platformLabel} update manifests: conflicting file entry${origin} (URL input length: ${this.urlInputLength}).`;
  }
}

export class UpdateManifestSerializationError extends Schema.TaggedErrorClass<UpdateManifestSerializationError>()(
  "UpdateManifestSerializationError",
  {
    platformLabel: Schema.String,
    key: Schema.String,
  },
) {
  override get message(): string {
    return `Cannot serialize ${this.platformLabel} update manifest: missing value for '${this.key}'.`;
  }
}

export const UpdateManifestError = Schema.Union([
  UpdateManifestParseError,
  UpdateManifestVersionConflictError,
  UpdateManifestExtraConflictError,
  UpdateManifestFileConflictError,
  UpdateManifestSerializationError,
]);
export type UpdateManifestError = typeof UpdateManifestError.Type;
export const isUpdateManifestError = Schema.is(UpdateManifestError);

export const attemptUpdateManifest = <A>(
  evaluate: () => A,
): Effect.Effect<A, UpdateManifestError> =>
  Effect.suspend(() => {
    try {
      return Effect.succeed(evaluate());
    } catch (error) {
      return isUpdateManifestError(error) ? Effect.fail(error) : Effect.die(error);
    }
  });

export interface UpdateManifest {
  readonly version: string;
  readonly releaseDate: string;
  readonly files: ReadonlyArray<UpdateManifestFile>;
  readonly extras: Readonly<Record<string, UpdateManifestScalar>>;
}

interface MutableUpdateManifestFile {
  url?: string;
  sha512?: string;
  size?: number;
}

function stripSingleQuotes(value: string): string {
  if (value.startsWith("'") && value.endsWith("'")) {
    return value.slice(1, -1).replace(/''/g, "'");
  }
  return value;
}

function parseFileRecord(
  currentFile: MutableUpdateManifestFile | null,
  sourcePath: string,
  lineNumber: number,
  platformLabel: string,
): UpdateManifestFile | null {
  if (currentFile === null) {
    return null;
  }
  if (
    typeof currentFile.url !== "string" ||
    typeof currentFile.sha512 !== "string" ||
    typeof currentFile.size !== "number"
  ) {
    throw new UpdateManifestParseError({
      platformLabel,
      sourcePath,
      lineNumber,
      reason: "incomplete file entry",
    });
  }
  return {
    url: currentFile.url,
    sha512: currentFile.sha512,
    size: currentFile.size,
  };
}

function parseScalarValue(rawValue: string): UpdateManifestScalar {
  const trimmed = rawValue.trim();
  const isQuoted = trimmed.startsWith("'") && trimmed.endsWith("'") && trimmed.length >= 2;
  const value = isQuoted ? trimmed.slice(1, -1).replace(/''/g, "'") : trimmed;
  if (isQuoted) return value;
  if (value === "true") return true;
  if (value === "false") return false;
  if (/^-?\d+(?:\.\d+)?$/.test(value)) {
    return Number(value);
  }
  return value;
}

export function parseUpdateManifest(
  raw: string,
  sourcePath: string,
  platformLabel: string,
): UpdateManifest {
  const lines = raw.split(/\r?\n/);
  const files: UpdateManifestFile[] = [];
  const extras: Record<string, UpdateManifestScalar> = {};
  let version: string | null = null;
  let releaseDate: string | null = null;
  let inFiles = false;
  let currentFile: MutableUpdateManifestFile | null = null;

  for (const [index, rawLine] of lines.entries()) {
    const lineNumber = index + 1;
    const line = rawLine.trimEnd();
    if (line.length === 0) continue;

    const fileUrlMatch = line.match(/^  - url:\s*(.+)$/);
    if (fileUrlMatch?.[1]) {
      const finalized = parseFileRecord(currentFile, sourcePath, lineNumber, platformLabel);
      if (finalized) files.push(finalized);
      currentFile = { url: stripSingleQuotes(fileUrlMatch[1].trim()) };
      inFiles = true;
      continue;
    }

    const fileShaMatch = line.match(/^    sha512:\s*(.+)$/);
    if (fileShaMatch?.[1]) {
      if (currentFile === null) {
        throw new UpdateManifestParseError({
          platformLabel,
          sourcePath,
          lineNumber,
          reason: "sha512 without a file entry",
        });
      }
      currentFile.sha512 = stripSingleQuotes(fileShaMatch[1].trim());
      continue;
    }

    const fileSizeMatch = line.match(/^    size:\s*(\d+)$/);
    if (fileSizeMatch?.[1]) {
      if (currentFile === null) {
        throw new UpdateManifestParseError({
          platformLabel,
          sourcePath,
          lineNumber,
          reason: "size without a file entry",
        });
      }
      currentFile.size = Number(fileSizeMatch[1]);
      continue;
    }

    if (line === "files:") {
      inFiles = true;
      continue;
    }

    if (inFiles && currentFile !== null) {
      const finalized = parseFileRecord(currentFile, sourcePath, lineNumber, platformLabel);
      if (finalized) files.push(finalized);
      currentFile = null;
    }
    inFiles = false;

    const topLevelMatch = line.match(/^([A-Za-z][A-Za-z0-9]*):\s*(.+)$/);
    if (!topLevelMatch?.[1] || topLevelMatch[2] === undefined) {
      throw new UpdateManifestParseError({
        platformLabel,
        sourcePath,
        lineNumber,
        reason: "unsupported line",
        lineLength: line.length,
      });
    }

    const [, key, rawValue] = topLevelMatch;
    const value = parseScalarValue(rawValue);

    if (key === "version") {
      if (typeof value !== "string") {
        throw new UpdateManifestParseError({
          platformLabel,
          sourcePath,
          lineNumber,
          reason: "version must be a string",
        });
      }
      version = value;
      continue;
    }

    if (key === "releaseDate") {
      if (typeof value !== "string") {
        throw new UpdateManifestParseError({
          platformLabel,
          sourcePath,
          lineNumber,
          reason: "releaseDate must be a string",
        });
      }
      releaseDate = value;
      continue;
    }

    if (key === "path" || key === "sha512") {
      continue;
    }

    extras[key] = value;
  }

  const finalized = parseFileRecord(currentFile, sourcePath, lines.length, platformLabel);
  if (finalized) files.push(finalized);

  if (!version) {
    throw new UpdateManifestParseError({
      platformLabel,
      sourcePath,
      reason: "missing version",
    });
  }
  if (!releaseDate) {
    throw new UpdateManifestParseError({
      platformLabel,
      sourcePath,
      reason: "missing releaseDate",
    });
  }
  if (files.length === 0) {
    throw new UpdateManifestParseError({
      platformLabel,
      sourcePath,
      reason: "missing files",
    });
  }

  return {
    version,
    releaseDate,
    files,
    extras,
  };
}

function getScalarType(value: UpdateManifestScalar): UpdateManifestScalarType {
  if (typeof value === "string") return "string";
  if (typeof value === "number") return "number";
  return "boolean";
}

function mergeExtras(
  primary: Readonly<Record<string, UpdateManifestScalar>>,
  secondary: Readonly<Record<string, UpdateManifestScalar>>,
  platformLabel: string,
): Record<string, UpdateManifestScalar> {
  const merged: Record<string, UpdateManifestScalar> = { ...primary };

  for (const [key, value] of Object.entries(secondary)) {
    const existing = merged[key];
    if (existing !== undefined && existing !== value) {
      throw new UpdateManifestExtraConflictError({
        platformLabel,
        key,
        primaryValueType: getScalarType(existing),
        ...(typeof existing === "string" ? { primaryValueLength: existing.length } : {}),
        secondaryValueType: getScalarType(value),
        ...(typeof value === "string" ? { secondaryValueLength: value.length } : {}),
      });
    }
    merged[key] = value;
  }

  return merged;
}

export function mergeUpdateManifests(
  primary: UpdateManifest,
  secondary: UpdateManifest,
  platformLabel: string,
): UpdateManifest {
  if (primary.version !== secondary.version) {
    throw new UpdateManifestVersionConflictError({
      platformLabel,
      primaryVersion: primary.version,
      secondaryVersion: secondary.version,
    });
  }

  const filesByUrl = new Map<
    string,
    { readonly manifest: "primary" | "secondary"; readonly file: UpdateManifestFile }
  >();
  for (const [manifest, files] of [
    ["primary", primary.files],
    ["secondary", secondary.files],
  ] as const) {
    for (const file of files) {
      const existing = filesByUrl.get(file.url);
      if (existing && (existing.file.sha512 !== file.sha512 || existing.file.size !== file.size)) {
        const urlDiagnostics = getUrlDiagnostics(file.url);
        throw new UpdateManifestFileConflictError({
          platformLabel,
          urlInputLength: urlDiagnostics.inputLength,
          ...(urlDiagnostics.protocol === undefined
            ? {}
            : { urlProtocol: urlDiagnostics.protocol }),
          ...(urlDiagnostics.hostname === undefined
            ? {}
            : { urlHostname: urlDiagnostics.hostname }),
          existingManifest: existing.manifest,
          existingSha512Length: existing.file.sha512.length,
          existingSize: existing.file.size,
          conflictingManifest: manifest,
          conflictingSha512Length: file.sha512.length,
          conflictingSize: file.size,
          sha512Conflict: existing.file.sha512 !== file.sha512,
          sizeConflict: existing.file.size !== file.size,
        });
      }
      filesByUrl.set(file.url, { manifest, file });
    }
  }

  return {
    version: primary.version,
    releaseDate:
      primary.releaseDate >= secondary.releaseDate ? primary.releaseDate : secondary.releaseDate,
    files: [...filesByUrl.values()].map(({ file }) => file),
    extras: mergeExtras(primary.extras, secondary.extras, platformLabel),
  };
}

function quoteYamlString(value: string): string {
  return `'${value.replace(/'/g, "''")}'`;
}

function serializeScalarValue(value: UpdateManifestScalar): string {
  if (typeof value === "string") {
    return quoteYamlString(value);
  }
  return String(value);
}

export function serializeUpdateManifest(
  manifest: UpdateManifest,
  options: {
    readonly platformLabel: string;
  },
): string {
  const lines = [`version: ${quoteYamlString(manifest.version)}`, "files:"];

  for (const file of manifest.files) {
    lines.push(`  - url: ${file.url}`);
    lines.push(`    sha512: ${file.sha512}`);
    lines.push(`    size: ${file.size}`);
  }

  for (const key of Object.keys(manifest.extras).toSorted()) {
    const value = manifest.extras[key];
    if (value === undefined) {
      throw new UpdateManifestSerializationError({
        platformLabel: options.platformLabel,
        key,
      });
    }
    lines.push(`${key}: ${serializeScalarValue(value)}`);
  }

  lines.push(`releaseDate: ${quoteYamlString(manifest.releaseDate)}`);
  lines.push("");
  return lines.join("\n");
}