import {
  JsonFieldNamingProfile,
  renderJsonFieldName,
} from './object-location';
import type { CheckResult } from './i18n';

export interface WireFieldMetadata {
  readonly canonicalName: string;
  readonly wireName: string;
  readonly aliases: readonly string[];
}

export interface WireEntityMetadata {
  readonly entityType: string;
  readonly profile: JsonFieldNamingProfile;
  readonly fields: Readonly<Record<string, WireFieldMetadata>>;
}

export interface NormalizedWireInput {
  /** Values keyed only by canonical KSML property names. */
  readonly values: Readonly<Record<string, unknown>>;
  /** Exact submitted RFC 6901 pointer, retained only for accepted aliases. */
  readonly sourceInstancePaths: Readonly<Record<string, string>>;
}

export class WireInputError extends Error {
  constructor(
    public readonly code: 'WIRE_UNKNOWN_FIELD' | 'WIRE_FIELD_COLLISION',
    public readonly instancePath: string,
    message: string,
  ) {
    super(message);
    this.name = 'WireInputError';
  }
}

export function createWireEntityMetadata(
  entityType: string,
  canonicalFields: readonly string[],
  profile: JsonFieldNamingProfile = 'camelCase',
  aliases: Readonly<Record<string, readonly string[]>> = {},
): WireEntityMetadata {
  const fields: Record<string, WireFieldMetadata> = {};
  const spellings = new Map<string, string>();
  for (const canonicalName of canonicalFields) {
    const wireName = renderJsonFieldName(canonicalName, profile);
    const fieldAliases = [...(aliases[canonicalName] ?? [])];
    for (const spelling of [wireName, ...fieldAliases]) {
      const existing = spellings.get(spelling);
      if (existing && existing !== canonicalName) {
        throw new Error(
          `Wire field spelling '${spelling}' maps to both '${existing}' and '${canonicalName}'`,
        );
      }
      spellings.set(spelling, canonicalName);
    }
    fields[canonicalName] = Object.freeze({
      canonicalName,
      wireName,
      aliases: Object.freeze(fieldAliases),
    });
  }
  return Object.freeze({ entityType, profile, fields: Object.freeze(fields) });
}

/**
 * Normalize one JSON object before checker or mutation execution.
 *
 * No serializer naming policy is consulted. The generated field map is the
 * complete authority, and two submitted spellings for one canonical field are
 * always rejected, even when their values happen to be equal.
 */
export function normalizeWireInput(
  input: Readonly<Record<string, unknown>>,
  metadata: WireEntityMetadata,
  parentPointer = '',
): NormalizedWireInput {
  const lookup = new Map<string, WireFieldMetadata>();
  for (const field of Object.values(metadata.fields)) {
    lookup.set(field.wireName, field);
    for (const alias of field.aliases) lookup.set(alias, field);
  }

  const values: Record<string, unknown> = {};
  const sourceInstancePaths: Record<string, string> = {};
  const submitted = new Map<string, string>();
  for (const [submittedName, value] of Object.entries(input)) {
    const pointer = `${parentPointer}/${escapeJsonPointer(submittedName)}`;
    const field = lookup.get(submittedName);
    if (!field) {
      throw new WireInputError(
        'WIRE_UNKNOWN_FIELD', pointer,
        `Unknown ${metadata.entityType} field '${submittedName}'`,
      );
    }
    const previous = submitted.get(field.canonicalName);
    if (previous !== undefined) {
      throw new WireInputError(
        'WIRE_FIELD_COLLISION', pointer,
        `Fields '${previous}' and '${submittedName}' both map to canonical field '${field.canonicalName}'`,
      );
    }
    submitted.set(field.canonicalName, submittedName);
    values[field.canonicalName] = value;
    if (submittedName !== field.wireName) {
      sourceInstancePaths[field.canonicalName] = pointer;
    }
  }
  return Object.freeze({
    values: Object.freeze(values),
    sourceInstancePaths: Object.freeze(sourceInstancePaths),
  });
}

/** Render canonical mutation values to the selected external profile. */
export function encodeWireOutput(
  values: Readonly<Record<string, unknown>>,
  metadata: WireEntityMetadata,
): Readonly<Record<string, unknown>> {
  const output: Record<string, unknown> = {};
  for (const [canonicalName, value] of Object.entries(values)) {
    const field = metadata.fields[canonicalName];
    if (!field) {
      throw new Error(`Unknown canonical ${metadata.entityType} field '${canonicalName}'`);
    }
    output[field.wireName] = value;
  }
  return Object.freeze(output);
}

/** Add submitted alias provenance to checker results without changing location identity. */
export function retainSubmittedPaths(
  results: readonly CheckResult[],
  normalized: NormalizedWireInput,
): CheckResult[] {
  return results.map(result => {
    const firstProperty = result.location.segments.find(segment => segment.kind === 'property');
    if (!firstProperty || firstProperty.kind !== 'property') return { ...result };
    const sourceInstancePath = normalized.sourceInstancePaths[firstProperty.name];
    return sourceInstancePath === undefined ? { ...result } : { ...result, sourceInstancePath };
  });
}

function escapeJsonPointer(value: string): string {
  return value.replace(/~/g, '~0').replace(/\//g, '~1');
}