import { Context, Effect, Match, Option, type ParseResult, Record as Rec } from 'effect'
import {
  Composition,
  type CompositionClass,
  isStructure,
  type SlotFill,
  type Structure,
  type UiContract,
} from '@playfast/reform'
import {
  type AnyComposition,
  type AnyScene,
  type AnySlot,
  type AnySlotChild,
  type TriggerRegistryApi,
  type WireNode,
  type WireTree,
} from '@playfast/reform/internal'
import {
  childComposition,
  type Mounted,
  noRegister,
  slotsOf,
  structureFills,
  toWireNodeFromStructure,
} from './wireNode'

export interface RenderSceneToWireOptions {
  readonly register: TriggerRegistryApi['register']
}

export const serviceFromContext = <Services, Identifier, Service>(
  context: Context.Context<Services>,
  tag: Context.Tag<Identifier, Service>,
  missing: string,
): Effect.Effect<Service, never, never> =>
  Option.match(Context.getOption(context, tag), {
    onNone: () => Effect.dieMessage(missing),
    onSome: Effect.succeed,
  })

export const capturedSlotProvider = <Services>(
  context: Context.Context<Services>,
  slotDefinition: AnySlot,
): Effect.Effect<AnySlotChild, never, never> =>
  slotDefinition.capture((exact) =>
    serviceFromContext(
      context,
      exact.provider,
      'reform-remote: scene does not provide a declared slot',
    ),
  )

export const renderCapturedComposition = <Services>(
  context: Context.Context<Services>,
  composition: AnyComposition,
  props: unknown,
): Effect.Effect<Structure<UiContract>, never, never> =>
  composition.capture<Effect.Effect<Structure<UiContract>, never, never>>(
    <P, C extends UiContract, S extends ReadonlyArray<unknown>, N extends string, Identity>(
      exact: CompositionClass<P, C, S, N, Identity>,
    ): Effect.Effect<Structure<UiContract>, never, never> =>
      Option.match(exact.parseProps(props), {
        onNone: () =>
          Effect.dieMessage(
            `reform-remote: invalid props for composition ${composition.manifest.name}`,
          ),
        onSome: (parsed) =>
          serviceFromContext(
            context,
            exact.tag,
            `reform-remote: scene does not provide composition ${composition.manifest.name}`,
          ).pipe(
            Effect.flatMap((service) =>
              Composition.render<P, C>(service, {
                props: parsed,
                tracker: { add: () => {} },
              }),
            ),
            Effect.flatMap((frame) => {
              if (isStructure(frame)) {
                return Effect.succeed(frame)
              }
              return Effect.dieMessage(
                `reform-remote: composition ${composition.manifest.name} did not return a Structure`,
              )
            }),
          ),
      }),
  )

export const enqueueStructureSlot = (
  parent: Mounted,
  slotName: string,
  child: AnyComposition,
  fill: SlotFill<unknown>,
): ReadonlyArray<Mounted> =>
  Match.value(fill).pipe(
    Match.tag('Each', (each) => {
      // Keyed, not positional: a trigger handle embeds the node id, so an id built from
      // the index silently re-points a handle the client already holds at whatever row
      // slid into that slot. An accidental duplicate key falls back to the index rather
      // than minting two nodes with one id.
      const used = new Set<string>()
      // The disambiguator is retried rather than assumed free: a key that literally ends
      // in `#<n>` can already hold the string a later repeat would mint, and two nodes
      // sharing an id costs a whole row on the wire.
      const unusedId = (base: string): string => {
        const attempt = (round: number): string => {
          const candidate = round === 0 ? base : `${base}#${round}`
          return used.has(candidate) ? attempt(round + 1) : candidate
        }
        return attempt(0)
      }
      return each.items.map((entry, index): Mounted => {
        const id = unusedId(`${parent.id}.${slotName}.${entry.key ?? index}`)
        used.add(id)
        return {
          comp: child,
          props: entry.props,
          id,
          parentId: Option.some(parent.id),
          slot: Option.some(slotName),
          childIndex: index,
          key: Option.fromNullable(entry.key),
        }
      })
    }),
    Match.tag('One', (single) => [
      {
        comp: child,
        props: single.props,
        id: `${parent.id}.${slotName}.0`,
        parentId: Option.some(parent.id),
        slot: Option.some(slotName),
        childIndex: 0,
        key: Option.none(),
      } satisfies Mounted,
    ]),
    Match.tag('Absent', () => []),
    Match.exhaustive,
  )

export type SlotProvider<Services> = (
  slotDefinition: AnySlot,
) => Effect.Effect<AnySlotChild, never, Services>

export const collect: <Services>(
  root: AnyComposition,
  provideSlot: SlotProvider<Services>,
) => Effect.Effect<Map<AnySlot, AnyComposition>, never, Services> = Effect.fn('collect')(function* <
  Services,
>(
  root: AnyComposition,
  provideSlot: SlotProvider<Services>,
): Effect.fn.Return<Map<AnySlot, AnyComposition>, never, Services> {
  const bindings = new Map<AnySlot, AnyComposition>()
  // Explicit type keeps the recursive reference cast-free.
  const walk: (comp: AnyComposition) => Effect.Effect<void, never, Services> = Effect.fn('walk')(
    function* (comp: AnyComposition): Effect.fn.Return<void, never, Services> {
      yield* Effect.forEach(Rec.values(slotsOf(comp)), (slotClass) =>
        Effect.gen(function* () {
          if (bindings.has(slotClass)) {
            return
          }
          const child = childComposition(yield* provideSlot(slotClass))
          bindings.set(slotClass, child)
          yield* walk(child)
        }),
      )
    },
  )
  yield* walk(root)
  return bindings
})

export type CompositionRenderer<Services> = (
  composition: AnyComposition,
  props: unknown,
) => Effect.Effect<Structure<UiContract>, never, Services>

export interface RenderLevel {
  <Services>(
    frontier: ReadonlyArray<Mounted>,
    bindings: ReadonlyMap<AnySlot, AnyComposition>,
    register: TriggerRegistryApi['register'],
    render: CompositionRenderer<Services>,
  ): Effect.Effect<ReadonlyArray<WireNode>, ParseResult.ParseError, Services>
}

export const renderLevel: RenderLevel = Effect.fn('renderLevel')(function* <Services>(
  frontier: ReadonlyArray<Mounted>,
  bindings: ReadonlyMap<AnySlot, AnyComposition>,
  register: TriggerRegistryApi['register'],
  render: CompositionRenderer<Services>,
): Effect.fn.Return<ReadonlyArray<WireNode>, ParseResult.ParseError, Services> {
  if (frontier.length === 0) {
    return []
  }
  const rendered = yield* Effect.forEach(frontier, (mounted) =>
    Effect.gen(function* () {
      const frame = yield* render(mounted.comp, mounted.props)
      const node = yield* toWireNodeFromStructure(mounted, frame, register)
      const fills = structureFills(frame)
      const children = Rec.toEntries(slotsOf(mounted.comp)).flatMap(([slotName, slotClass]) => {
        const child = bindings.get(slotClass)
        if (child === undefined) {
          return []
        }
        const fill = fills[slotName]
        if (fill === undefined) {
          return []
        }
        return enqueueStructureSlot(mounted, slotName, child, fill)
      })
      return { node, children }
    }),
  )
  const nodes = rendered.map((entry) => entry.node)
  const next = rendered.flatMap((entry) => entry.children)
  const rest = yield* renderLevel(next, bindings, register, render)
  return [...nodes, ...rest]
})

export const renderSceneWith: <SlotServices, CompositionServices>(
  scene: AnyScene,
  options: RenderSceneToWireOptions | undefined,
  provideSlot: SlotProvider<SlotServices>,
  render: CompositionRenderer<CompositionServices>,
) => Effect.Effect<WireTree, ParseResult.ParseError, SlotServices | CompositionServices> =
  Effect.fn('renderSceneWith')(function* <SlotServices, CompositionServices>(
    scene: AnyScene,
    options: RenderSceneToWireOptions | undefined,
    provideSlot: SlotProvider<SlotServices>,
    render: CompositionRenderer<CompositionServices>,
  ): Effect.fn.Return<WireTree, ParseResult.ParseError, SlotServices | CompositionServices> {
    const register = options?.register ?? noRegister
    const bindings = yield* collect(scene.composition, provideSlot)
    const root: Mounted = {
      comp: scene.composition,
      props: {},
      id: '0',
      parentId: Option.none(),
      slot: Option.none(),
      childIndex: 0,
      key: Option.none(),
    }
    return yield* renderLevel([root], bindings, register, render)
  })