import { camelCase, decapitalize } from '@skmtc/core'
import { toTsModelProjectionBase } from '@skmtc/lang-typescript'
import { join } from '@std/path'
import denoJson from '../deno.json' with { type: 'json' }
import { type EnrichmentSchema, toEnrichmentSchema } from './enrichments.ts'

export const MyLibBase = toTsModelProjectionBase<EnrichmentSchema>({
  id: denoJson.name,

  // SLOT(naming): the emitted binding name, derived from refName ONLY
  // (deterministic; never operationId, never construction-dependent).
  toIdentifierName({ refName }): string {
    return decapitalize(camelCase(refName))
  },

  // SLOT(identifier-kind): 'variable' for schema values; 'type' or
  // 'interface' would make consumers import it type-only.
  toIdentifierType: () => ({ type: 'variable' }),

  // SLOT(export-path): where each model's file lives. '@' is the
  // project-root marker; keep the .generated.ts suffix convention.
  toExportPath({ refName, enrichments, variant }): string {
    const name = this.toIdentifierName({ refName, enrichments, variant })

    return join('@', 'models', `${name}.generated.ts`)
  },

  toEnrichmentSchema,
})

import { type EmptyEnrichments, emptyEnrichmentSchema } from '@skmtc/core'

// SLOT(enrichments): the opt-out. To accept per-model options, replace
// with a valibot three-scope umbrella ({ subject, generator, stack }) —
// see skmtc-generator §4. Must stay a FUNCTION returning the schema.
export const toEnrichmentSchema = () => emptyEnrichmentSchema

export type EnrichmentSchema = EmptyEnrichments

/**
 * SLOT(library): the emitted library, in one place.
 *
 * LIB_MODULE is the module specifier written into emitted import
 * headers; LIB is the imported symbol every snippet's render body
 * composes with. Change both here, then rewrite the `toString()`
 * bodies (each marked with a SLOT comment) in the snippet classes.
 */
export const LIB_MODULE = 'mylib'
export const LIB = 'm'

import { toModelEntry } from '@skmtc/core'
import denoJson from '../deno.json' with { type: 'json' }
import { type EnrichmentSchema, toEnrichmentSchema } from './enrichments.ts'
import { MyLibProjection } from './MyLibProjection.ts'

export const myLibEntry = toModelEntry<EnrichmentSchema>({
  id: denoJson.name,
  toEnrichmentSchema,
  transform({ context, refName }) {
    context.insertModel(MyLibProjection, refName)
  },
})

import type { Modifiers, Stringable } from '@skmtc/core'

/**
 * SLOT(modifiers): how the target library expresses optional and
 * nullable. Applied ONCE, at each leaf's render — never while building
 * stored fields, and no other owner. Order matters: nullable wraps the
 * value first, optional wraps the result (zod convention; adjust if
 * your library composes differently).
 */
export const applyModifiers = (
  value: Stringable,
  { required, nullable }: Modifiers,
): string => {
  const withNullable = nullable ? `${value}.nullable()` : `${value}`

  return required ? withNullable : `${withNullable}.optional()`
}

/**
 * The schema-type router: every schema node dispatches to exactly one
 * snippet class. Every branch returns a snippet OBJECT — text exists
 * only inside toString() bodies. Fine-grained attribution is captured
 * via each snippet's super call (`stackTrail: schema.stackTrail.clone()`).
 */
import { toGeneratorOnlyKey, toRefName } from '@skmtc/core'
import type { Modifiers, SchemaToValueFn, SchemaType } from '@skmtc/core'
import { match } from 'ts-pattern'
import { myLibEntry } from './mod.ts'
import { MyLibArray } from './MyLibArray.ts'
import { MyLibObject } from './MyLibObject.ts'
import { MyLibRef } from './MyLibRef.ts'
import { MyLibString } from './MyLibString.ts'
import { MyLibUnion } from './MyLibUnion.ts'
import {
  MyLibBoolean,
  MyLibInteger,
  MyLibNumber,
  MyLibUnknown,
  MyLibVoid,
} from './MyLibScalars.ts'

export const toMyLibValue: SchemaToValueFn = (
  { schema: schemaNode, destinationPath, required, context, rootRef },
) => {
  // `schemaNode` arrives typed as the generic `Schema` parameter, and
  // TypeScript does not narrow a type parameter by discriminant.
  // Widening it to the `SchemaType` union lets the match below narrow
  // each case on its own — generator code narrows, it does not assert.
  const schema: SchemaType = schemaNode

  const modifiers: Modifiers = {
    required,
    nullable: 'nullable' in schema ? schema.nullable : undefined,
  }

  const generatorKey = toGeneratorOnlyKey({ generatorId: myLibEntry.id })

  return match(schema)
    // Custom values pass through untouched — they are already Stringable.
    .with({ type: 'custom' }, (custom) => custom)
    .with({ type: 'ref' }, (ref) => {
      return new MyLibRef({
        context,
        destinationPath,
        refName: toRefName(ref.$ref),
        modifiers,
        rootRef,
        schema: ref,
      })
    })
    .with({ type: 'array' }, (arraySchema) => {
      return new MyLibArray({
        context,
        destinationPath,
        modifiers,
        items: arraySchema.items,
        generatorKey,
        rootRef,
        schema: arraySchema,
      })
    })
    .with({ type: 'object' }, (objectSchema) => {
      return new MyLibObject({
        context,
        destinationPath,
        objectSchema,
        modifiers,
        generatorKey,
        rootRef,
      })
    })
    .with({ type: 'union' }, (unionSchema) => {
      return new MyLibUnion({
        context,
        destinationPath,
        members: unionSchema.members,
        discriminator: unionSchema.discriminator,
        modifiers,
        generatorKey,
        rootRef,
        schema: unionSchema,
      })
    })
    .with({ type: 'string' }, (stringSchema) => {
      return new MyLibString({
        context,
        stringSchema,
        modifiers,
        destinationPath,
        generatorKey,
      })
    })
    .with({ type: 'number' }, (schema) => {
      return new MyLibNumber({
        context,
        schema,
        modifiers,
        destinationPath,
        generatorKey,
      })
    })
    .with({ type: 'integer' }, (schema) => {
      return new MyLibInteger({
        context,
        schema,
        modifiers,
        destinationPath,
        generatorKey,
      })
    })
    .with({ type: 'boolean' }, (schema) => {
      return new MyLibBoolean({
        context,
        schema,
        modifiers,
        destinationPath,
        generatorKey,
      })
    })
    .with(
      { type: 'void' },
      () => new MyLibVoid({ context, destinationPath, generatorKey }),
    )
    .with({ type: 'unknown' }, (schema) => {
      return new MyLibUnknown({
        context,
        destinationPath,
        generatorKey,
        schema,
      })
    })
    .exhaustive()
}

import { TsSnippet } from '@skmtc/lang-typescript'
import type {
  GenerateContextType,
  GeneratorKey,
  Modifiers,
  OasRef,
  OasSchema,
  RefName,
  TypeSystemValue,
} from '@skmtc/core'
import { toMyLibValue } from './MyLib.ts'
import { applyModifiers } from './modifiers.ts'
import { LIB, LIB_MODULE } from './lib.ts'

type MyLibArrayArgs = {
  context: GenerateContextType
  destinationPath: string
  items: OasSchema | OasRef<'schema'>
  /** The originating array schema node — for fine-grained attribution. */
  schema?: OasSchema | OasRef<'schema'>
  modifiers: Modifiers
  generatorKey: GeneratorKey
  rootRef?: RefName
}

export class MyLibArray extends TsSnippet {
  type = 'array' as const
  items: TypeSystemValue
  modifiers: Modifiers

  constructor(
    {
      context,
      generatorKey,
      destinationPath,
      items,
      modifiers,
      rootRef,
      schema,
    }: MyLibArrayArgs,
  ) {
    super({ context, generatorKey, stackTrail: schema?.stackTrail.clone() })

    this.modifiers = modifiers

    // The items value is built by recursing through the router — a
    // snippet, never a string. This is what keeps nested refs cached.
    this.items = toMyLibValue({
      destinationPath,
      schema: items,
      required: true,
      context,
      rootRef,
    })

    this.register({ imports: { [LIB_MODULE]: [LIB] }, destinationPath })
  }

  override toString(): string {
    // SLOT(array)
    return applyModifiers(`${LIB}.array(${this.items})`, this.modifiers)
  }
}

import { isEmpty } from '@skmtc/core'
import { handleKey, TsSnippet } from '@skmtc/lang-typescript'
import type {
  CustomValue,
  GenerateContextType,
  GeneratorKey,
  Modifiers,
  OasObject,
  OasRef,
  OasSchema,
  RefName,
  TypeSystemValue,
} from '@skmtc/core'
import { toMyLibValue } from './MyLib.ts'
import { applyModifiers } from './modifiers.ts'
import { MyLibUnknown } from './MyLibScalars.ts'
import { LIB, LIB_MODULE } from './lib.ts'

type MyLibObjectArgs = {
  context: GenerateContextType
  destinationPath: string
  objectSchema: OasObject
  modifiers: Modifiers
  generatorKey: GeneratorKey
  rootRef?: RefName
}

export class MyLibObject extends TsSnippet {
  type = 'object' as const
  objectProperties: MyLibObjectProperties | null
  recordProperties: MyLibRecord | null
  modifiers: Modifiers

  constructor(
    {
      context,
      generatorKey,
      destinationPath,
      objectSchema,
      modifiers,
      rootRef,
    }: MyLibObjectArgs,
  ) {
    super({
      context,
      generatorKey,
      stackTrail: objectSchema.stackTrail.clone(),
    })

    this.modifiers = modifiers

    const { properties, required, additionalProperties } = objectSchema

    const hasProperties = properties && !isEmpty(properties)

    this.recordProperties = additionalProperties
      ? new MyLibRecord({
        context,
        generatorKey,
        destinationPath,
        schema: additionalProperties,
        rootRef,
      })
      : null

    this.objectProperties = hasProperties
      ? new MyLibObjectProperties({
        context,
        generatorKey,
        destinationPath,
        properties,
        // 'required' lists which PROPERTIES are required — it is not
        // about the object itself. Each property's optionality renders
        // at that property's own leaf via its modifiers.
        required,
        rootRef,
      })
      : null

    this.register({ imports: { [LIB_MODULE]: [LIB] }, destinationPath })
  }

  override toString(): string {
    const { objectProperties, recordProperties } = this

    // SLOT(object-intersection): properties + additionalProperties in
    // one schema — the target's intersection syntax.
    if (objectProperties && recordProperties) {
      return applyModifiers(
        `${objectProperties}.and(${recordProperties})`,
        this.modifiers,
      )
    }

    // SLOT(object-empty): a fully unconstrained object.
    return applyModifiers(
      recordProperties?.toString() ?? objectProperties?.toString() ??
        `${LIB}.object({})`,
      this.modifiers,
    )
  }
}

type Visibility = {
  readOnly: boolean
  writeOnly: boolean
}

type MyLibObjectPropertiesArgs = {
  context: GenerateContextType
  destinationPath: string
  properties: Record<string, OasSchema | OasRef<'schema'> | CustomValue>
  required: OasObject['required']
  generatorKey: GeneratorKey
  rootRef?: RefName
}

class MyLibObjectProperties extends TsSnippet {
  properties: Record<string, TypeSystemValue>
  required: string[]
  /** Per-property readOnly/writeOnly — see SLOT(visibility). */
  visibility: Record<string, Visibility>

  constructor(
    {
      context,
      generatorKey,
      destinationPath,
      properties,
      required = [],
      rootRef,
    }: MyLibObjectPropertiesArgs,
  ) {
    super({ context, generatorKey })

    this.required = required

    // The property loop: every value comes from the router — a snippet,
    // never rendered text. Optionality flows into each leaf's modifiers.
    this.properties = Object.fromEntries(
      Object.entries(properties).map(([key, property]) => [
        key,
        toMyLibValue({
          destinationPath,
          schema: property,
          required: required.includes(key),
          context,
          rootRef,
        }),
      ]),
    )

    this.visibility = Object.fromEntries(
      Object.entries(properties).map(([key, property]) => [
        key,
        {
          readOnly: 'readOnly' in property && property.readOnly === true,
          writeOnly: 'writeOnly' in property && property.writeOnly === true,
        },
      ]),
    )
  }

  override toString(): string {
    // SLOT(object-properties): handleKey quotes keys that aren't valid
    // identifiers ('first-name' → quoted).
    //
    // SLOT(visibility): this.visibility[key] carries readOnly/writeOnly.
    // Default is to ignore them (single-variant output). Strategies if
    // the target needs them: annotate the value (e.g. `.readonly()`),
    // or emit request/response variants via the entry's `variant`
    // threading and drop writeOnly/readOnly fields respectively.
    const fields = Object.entries(this.properties)
      .map(([key, value]) => `${handleKey(key)}: ${value}`)
      .join(', ')

    return `${LIB}.object({${fields}})`
  }
}

type MyLibRecordArgs = {
  context: GenerateContextType
  destinationPath: string
  schema: true | OasSchema | OasRef<'schema'>
  generatorKey: GeneratorKey
  rootRef?: RefName
}

class MyLibRecord extends TsSnippet {
  value: TypeSystemValue

  constructor(
    { context, generatorKey, destinationPath, schema, rootRef }:
      MyLibRecordArgs,
  ) {
    super({ context, generatorKey })

    // additionalProperties: true (or an empty schema) means untyped
    // values — route to the unknown fallback, never throw.
    this.value = schema === true || isEmpty(schema)
      ? new MyLibUnknown({ context, destinationPath, generatorKey })
      : toMyLibValue({
        destinationPath,
        schema,
        required: true,
        context,
        rootRef,
      })
  }

  override toString(): string {
    // SLOT(record): string-keyed map of this.value.
    return `${LIB}.record(${LIB}.string(), ${this.value})`
  }
}

import { camelCase, capitalize } from '@skmtc/core'
import type {
  ContentSettings,
  GenerateContextType,
  RefName,
  TypeSystemValue,
} from '@skmtc/core'
import { createVariable } from '@skmtc/lang-typescript'
import { toMyLibValue } from './MyLib.ts'
import { MyLibBase } from './base.ts'
import type { EnrichmentSchema } from './enrichments.ts'

type ConstructorArgs = {
  context: GenerateContextType
  destinationPath: string
  refName: RefName
  settings: ContentSettings<EnrichmentSchema>
  rootRef?: RefName
}

export class MyLibProjection extends MyLibBase {
  value: TypeSystemValue

  constructor(
    { context, refName, settings, destinationPath, rootRef }: ConstructorArgs,
  ) {
    super({ context, refName, settings })

    const schema = context.resolveSchemaRefOnce(refName, MyLibBase.id)

    this.value = toMyLibValue({
      schema,
      required: true,
      destinationPath,
      context,
      rootRef,
    })

    // A recursive schema renders a lazy back-reference (see MyLibRef).
    // The enclosing `export const` then references its own initializer,
    // which TypeScript cannot type by inference — TS7022/TS7024.
    // Detected via `modelDepth`, not by rendering: `resolveSchemaRefOnce`
    // above set this key to 1 and every terminal back-reference bumps it,
    // so `> 1` means a cycle was emitted into this model's value.
    // (Rendering here instead would orphan every inner snippet from the
    // attribution map.) Self-recursion is what OpenAPI schemas produce;
    // mutual recursion is NOT detected by this check.
    if (context.modelDepth[`${MyLibBase.id}:${refName}`] > 1) {
      // SLOT(recursion-annotation): a type expression that breaks the
      // cycle, valid in the emitted file (zod: `z.ZodType<Order>`, with
      // the type supplied by a peer type generator).
      this.settings.identifier.typeName = `MyLibSchema<${
        capitalize(camelCase(refName))
      }>`
    }
  }

  // These two statics make the projection consumable by PEER generators
  // via insertNormalizedModel — keep them.
  static schemaToValueFn = (...args: Parameters<typeof toMyLibValue>) => {
    return toMyLibValue(...args)
  }

  static createIdentifier = createVariable

  override toString(): string {
    return `${this.value}`
  }
}

import { ModelDriver, toModelGeneratorKey } from '@skmtc/core'
import { TsSnippet } from '@skmtc/lang-typescript'
import type {
  GenerateContextType,
  Modifiers,
  OasRef,
  OasSchema,
  RefName,
} from '@skmtc/core'
import { applyModifiers } from './modifiers.ts'
import { MyLibProjection } from './MyLibProjection.ts'
import { myLibEntry } from './mod.ts'
import { LIB, LIB_MODULE } from './lib.ts'

type MyLibRefArgs = {
  context: GenerateContextType
  destinationPath: string
  modifiers: Modifiers
  refName: RefName
  rootRef?: RefName
  /** The originating ref schema node — for fine-grained attribution. */
  schema?: OasSchema | OasRef<'schema'>
}

/**
 * A $ref. Only the peer's NAME lands in this value tree — the Driver
 * (or the recursion branch) resolves the definition and stitches the
 * cross-file import. Never inline-expand a ref and never hand-write
 * its import.
 */
export class MyLibRef extends TsSnippet {
  type = 'ref' as const
  modifiers: Modifiers
  name: string
  terminal: boolean

  constructor(
    { context, refName, destinationPath, modifiers, rootRef, schema }:
      MyLibRefArgs,
  ) {
    super({
      context,
      generatorKey: toModelGeneratorKey({
        generatorId: myLibEntry.id,
        refName,
        variant: 'main',
      }),
      stackTrail: schema?.stackTrail.clone(),
    })

    if (context.modelDepth[`${myLibEntry.id}:${refName}`] > 0) {
      // A back-reference to a model still open on the build stack: a
      // recursive cycle, rendered below via SLOT(lazy). Bump the depth
      // so the enclosing MyLibProjection — whose own
      // `resolveSchemaRefOnce` set this key to 1 — can detect recursion
      // as `> 1` and annotate the export to break the target language's
      // circular type inference. `ModelDriver` resets the key to 0 when
      // the model finishes building.
      context.modelDepth[`${myLibEntry.id}:${refName}`]++

      const settings = context.toModelContentSettings({
        refName,
        projection: MyLibProjection,
        variant: 'main',
      })

      this.register({
        imports: { [LIB_MODULE]: [LIB] },
        destinationPath: settings.exportPath,
      })

      this.name = settings.identifier.name
      this.modifiers = modifiers
      this.terminal = true
    } else {
      // The memoization path: probe the cache; hit → reuse (the peer's
      // constructor never runs) + auto-stitched import; miss →
      // construct recursively.
      const { settings } = new ModelDriver({
        context,
        refName,
        destinationPath,
        rootRef,
        projection: MyLibProjection,
        variant: 'main',
      })

      this.name = settings.identifier.name
      this.modifiers = modifiers
      this.terminal = false
    }
  }

  override toString(): string {
    const out = applyModifiers(this.name, this.modifiers)

    // SLOT(lazy): the target's deferred-reference form for recursive
    // cycles (zod: `z.lazy(() => x)`).
    return this.terminal ? `${LIB}.lazy(() => ${out})` : out
  }
}

import { TsSnippet } from '@skmtc/lang-typescript'
import type {
  GenerateContextType,
  GeneratorKey,
  Modifiers,
  OasBoolean,
  OasInteger,
  OasNumber,
  OasRef,
  OasSchema,
} from '@skmtc/core'
import { applyModifiers } from './modifiers.ts'
import { LIB, LIB_MODULE } from './lib.ts'

type ScalarArgs<Schema> = {
  context: GenerateContextType
  schema: Schema
  modifiers: Modifiers
  destinationPath: string
  generatorKey: GeneratorKey
}

export class MyLibNumber extends TsSnippet {
  type = 'number' as const
  schema: OasNumber
  modifiers: Modifiers

  constructor(
    { context, schema, modifiers, destinationPath, generatorKey }: ScalarArgs<
      OasNumber
    >,
  ) {
    super({ context, generatorKey, stackTrail: schema.stackTrail.clone() })

    this.schema = schema
    this.modifiers = modifiers

    this.register({ imports: { [LIB_MODULE]: [LIB] }, destinationPath })
  }

  override toString(): string {
    // SLOT(number): minimum / maximum / multipleOf live on this.schema.
    return applyModifiers(`${LIB}.number()`, this.modifiers)
  }
}

export class MyLibInteger extends TsSnippet {
  type = 'integer' as const
  schema: OasInteger
  modifiers: Modifiers

  constructor(
    { context, schema, modifiers, destinationPath, generatorKey }: ScalarArgs<
      OasInteger
    >,
  ) {
    super({ context, generatorKey, stackTrail: schema.stackTrail.clone() })

    this.schema = schema
    this.modifiers = modifiers

    this.register({ imports: { [LIB_MODULE]: [LIB] }, destinationPath })
  }

  override toString(): string {
    // SLOT(integer): if the target has no integer kind, compose it
    // (e.g. number + integer constraint).
    return applyModifiers(`${LIB}.integer()`, this.modifiers)
  }
}

export class MyLibBoolean extends TsSnippet {
  type = 'boolean' as const
  schema: OasBoolean
  modifiers: Modifiers

  constructor(
    { context, schema, modifiers, destinationPath, generatorKey }: ScalarArgs<
      OasBoolean
    >,
  ) {
    super({ context, generatorKey, stackTrail: schema.stackTrail.clone() })

    this.schema = schema
    this.modifiers = modifiers

    this.register({ imports: { [LIB_MODULE]: [LIB] }, destinationPath })
  }

  override toString(): string {
    // SLOT(boolean)
    return applyModifiers(`${LIB}.boolean()`, this.modifiers)
  }
}

type MyLibUnknownArgs = {
  context: GenerateContextType
  destinationPath: string
  generatorKey: GeneratorKey
  /**
   * The originating schema node — for fine-grained attribution.
   * Optional: also built internally (e.g. a record's unknown value)
   * with no originating node, in which case the pointer is inherited.
   */
  schema?: OasSchema | OasRef<'schema'>
}

export class MyLibUnknown extends TsSnippet {
  type = 'unknown' as const

  constructor(
    { context, destinationPath, generatorKey, schema }: MyLibUnknownArgs,
  ) {
    super({ context, generatorKey, stackTrail: schema?.stackTrail.clone() })

    this.register({ imports: { [LIB_MODULE]: [LIB] }, destinationPath })
  }

  override toString(): string {
    // SLOT(unknown): the never-throw fallback — untyped schemas route
    // here rather than failing the subject.
    return `${LIB}.unknown()`
  }
}

// `OasVoid` is not part of the `OasSchema` union, so it can't flow
// through `SnippetBase.schema` — a void snippet inherits its ancestor /
// key-derived pointer.
type MyLibVoidArgs = {
  context: GenerateContextType
  generatorKey: GeneratorKey
  destinationPath: string
}

export class MyLibVoid extends TsSnippet {
  type = 'void' as const

  constructor({ context, generatorKey, destinationPath }: MyLibVoidArgs) {
    super({ context, generatorKey })

    this.register({ imports: { [LIB_MODULE]: [LIB] }, destinationPath })
  }

  override toString(): string {
    // SLOT(void)
    return `${LIB}.void()`
  }
}

import { TsSnippet } from '@skmtc/lang-typescript'
import type {
  GenerateContextType,
  GeneratorKey,
  Modifiers,
  OasString,
} from '@skmtc/core'
import { applyModifiers } from './modifiers.ts'
import { LIB, LIB_MODULE } from './lib.ts'

type MyLibStringArgs = {
  context: GenerateContextType
  stringSchema: OasString
  modifiers: Modifiers
  destinationPath: string
  generatorKey: GeneratorKey
}

export class MyLibString extends TsSnippet {
  type = 'string' as const
  stringSchema: OasString
  // format + enums are part of the TypeSystemString contract peers rely on.
  format: string | undefined
  enums: string[] | (string | null)[] | undefined
  modifiers: Modifiers

  constructor(
    { context, stringSchema, generatorKey, destinationPath, modifiers }:
      MyLibStringArgs,
  ) {
    super({
      context,
      generatorKey,
      stackTrail: stringSchema.stackTrail.clone(),
    })

    this.stringSchema = stringSchema
    this.format = stringSchema.format
    this.enums = stringSchema.enums
    this.modifiers = modifiers

    this.register({ imports: { [LIB_MODULE]: [LIB] }, destinationPath })
  }

  override toString(): string {
    const { enums } = this

    // SLOT(string): the target syntax for strings, enums and literals.
    // A single-member enum is a literal; a null member comes from
    // OpenAPI 3.1-style nullable enums and must not be quoted.
    const content = enums?.length
      ? enums.length === 1
        ? `${LIB}.literal(${literal(enums[0])})`
        : `${LIB}.enum([${enums.map(literal).join(', ')}])`
      : `${LIB}.string()`

    // SLOT(string-constraints): minLength / maxLength / pattern /
    // format live on this.stringSchema — append target syntax here.
    return applyModifiers(content, this.modifiers)
  }
}

const literal = (
  value: string | null,
): string => (value === null ? 'null' : `'${value}'`)

import { TsSnippet } from '@skmtc/lang-typescript'
import type {
  GenerateContextType,
  GeneratorKey,
  Modifiers,
  OasDiscriminator,
  OasRef,
  OasSchema,
  RefName,
  TypeSystemValue,
} from '@skmtc/core'
import { toMyLibValue } from './MyLib.ts'
import { applyModifiers } from './modifiers.ts'
import { LIB, LIB_MODULE } from './lib.ts'

type MyLibUnionArgs = {
  context: GenerateContextType
  destinationPath: string
  members: (OasSchema | OasRef<'schema'>)[]
  /** The originating union schema node — for fine-grained attribution. */
  schema?: OasSchema | OasRef<'schema'>
  discriminator?: OasDiscriminator
  modifiers: Modifiers
  generatorKey: GeneratorKey
  rootRef?: RefName
}

export class MyLibUnion extends TsSnippet {
  type = 'union' as const
  members: TypeSystemValue[]
  discriminator: string | undefined
  modifiers: Modifiers

  constructor(
    {
      context,
      generatorKey,
      destinationPath,
      members,
      discriminator,
      modifiers,
      rootRef,
      schema,
    }: MyLibUnionArgs,
  ) {
    super({ context, generatorKey, stackTrail: schema?.stackTrail.clone() })

    this.members = members.map((member) =>
      toMyLibValue({
        destinationPath,
        schema: member,
        required: true,
        context,
        rootRef,
      })
    )

    this.discriminator = discriminator?.propertyName
    this.modifiers = modifiers

    this.register({ imports: { [LIB_MODULE]: [LIB] }, destinationPath })
  }

  override toString(): string {
    const members = this.members.map((member) => `${member}`).join(', ')

    // SLOT(union): oneOf/anyOf syntax; use the discriminator when the
    // target has a dedicated discriminated-union form.
    const content = this.discriminator
      ? `${LIB}.discriminatedUnion('${this.discriminator}', [${members}])`
      : `${LIB}.union([${members}])`

    return applyModifiers(content, this.modifiers)
  }
}