import { Array as Arr, Effect, Option, type ParseResult, Record as Rec, Schema } from 'effect'
import {
  isFeatureBinding,
  isSlot,
  type SlotFill,
  type Structure,
  type Trigger,
  type UiContract,
} from '@playfast/reform'
import {
  type AnyComposition,
  type AnySlot,
  type AnySlotChild,
  type TriggerRegistryApi,
  type UiManifest,
  type WireNode,
  type WireProp,
} from '@playfast/reform/internal'

export const SETTLE_DRAIN = 30
export const settleDrain: Effect.Effect<void> = Effect.yieldNow().pipe(Effect.repeatN(SETTLE_DRAIN))

// The erased event map's never values remain assignable to Trigger<unknown> without a cast.
export const eventsOf = (structure: Structure<UiContract>): Record<string, Trigger<unknown>> =>
  Option.match(Option.fromNullable(structure.events), {
    onNone: () => ({}),
    onSome: (events) => events,
  })

export interface Mounted {
  readonly comp: AnyComposition
  readonly props: unknown
  readonly id: string
  readonly parentId: Option.Option<string>
  readonly slot: Option.Option<string>
  readonly childIndex: number
  readonly key: Option.Option<string>
}

export const childComposition = (child: AnySlotChild): AnyComposition => {
  if (!isFeatureBinding(child)) {
    return child
  }
  return child.capture<AnyComposition>((binding): AnyComposition => binding.composition)
}

export const isRecord = (candidate: unknown): candidate is Record<string, unknown> =>
  typeof candidate === 'object' && candidate !== null && !Array.isArray(candidate)

export const handlesOf = (node: WireNode): ReadonlyArray<string> =>
  node.props.flatMap((prop) => (prop._tag === 'Event' ? [prop.handle] : []))

// One-shot renders still emit deterministic handles but have no client registry.
export const noRegister: TriggerRegistryApi['register'] = () => Effect.void

export const toWireNodeFromStructure: (
  mounted: Mounted,
  structure: Structure<UiContract>,
  register: TriggerRegistryApi['register'],
) => Effect.Effect<WireNode, ParseResult.ParseError> = Effect.fn('toWireNodeFromStructure')(
  function* (
  mounted: Mounted,
  structure: Structure<UiContract>,
  register: TriggerRegistryApi['register'],
): Effect.fn.Return<WireNode, ParseResult.ParseError> {
  const manifest: UiManifest = mounted.comp.manifest.ui.manifest
  const name = manifest.name

  // The manifest stores schema AST only; reconstruct an unknown-safe schema at this wire seam.
  const encodedProps = yield* Option.match(Option.fromNullable(manifest.props), {
    onNone: () => Effect.succeed({}),
    onSome: (reflection) =>
      Schema.encodeUnknown(Schema.make<unknown, unknown>(reflection.ast))(structure.props).pipe(
        Effect.flatMap((encoded) => {
          if (isRecord(encoded)) {
            return Effect.succeed(encoded)
          }
          return Effect.dieMessage(
            `reform-remote: ${manifest.name} props did not encode to a record`,
          )
        }),
      ),
  })
  const dataProps: ReadonlyArray<WireProp> = Rec.toEntries(encodedProps).map(
    ([propName, propValue]): WireProp => ({
      _tag: 'Data',
      name: propName,
      value: propValue,
    }),
  )

  const eventSchemas = Option.fromNullable(manifest.events)
  const events = eventsOf(structure)
  const eventProps: ReadonlyArray<WireProp> = yield* Effect.forEach(
    Rec.toEntries(events),
    ([eventName, trigger]) =>
      Effect.gen(function* () {
        const schema = Option.flatMap(eventSchemas, (schemas) => Rec.get(schemas, eventName))
        if (Option.isNone(schema)) {
          return Option.none<WireProp>()
        }
        const handle = `${mounted.id}:${eventName}`
        yield* register(handle, trigger, Schema.make<unknown, unknown>(schema.value.ast))
        return Option.some<WireProp>({
          _tag: 'Event',
          name: eventName,
          handle,
        })
      }),
  ).pipe(Effect.map(Arr.getSomes))

  return {
    id: mounted.id,
    name,
    parentId: Option.getOrNull(mounted.parentId),
    childIndex: mounted.childIndex,
    slot: Option.getOrNull(mounted.slot),
    key: Option.getOrNull(mounted.key),
    props: [...dataProps, ...eventProps],
  }
})

// Structure erases per-slot fill types; recover SlotFill structurally without `as`.
export const isSlotFill = (candidate: unknown): candidate is SlotFill<unknown> =>
  typeof candidate === 'object' &&
  candidate !== null &&
  '_tag' in candidate &&
  (candidate._tag === 'Each' || candidate._tag === 'One' || candidate._tag === 'Absent')

export const structureFills = (structure: Structure<UiContract>): Record<string, SlotFill<unknown>> =>
  Rec.fromEntries(
    Rec.toEntries(structure.slots).flatMap(
      ([slotName, fillValue]): ReadonlyArray<readonly [string, SlotFill<unknown>]> =>
        isSlotFill(fillValue) ? [[slotName, fillValue]] : [],
    ),
  )

export const slotsOf = (comp: AnyComposition): Record<string, AnySlot> =>
  comp.capture<Record<string, AnySlot>>((exact) => {
    if (!('slots' in exact.manifest)) {
      return {}
    }
    const candidate: unknown = exact.manifest.slots
    if (!isRecord(candidate)) {
      return {}
    }
    return Rec.fromEntries(
      Rec.toEntries(candidate).flatMap(
        ([name, slotDefinition]): ReadonlyArray<readonly [string, AnySlot]> =>
          isSlot(slotDefinition) ? [[name, slotDefinition]] : [],
      ),
    )
  })