import { createElement, type ComponentType, type ReactNode } from 'react'
import { Function as Fn } from 'effect'
import { Ui, type MadeView, type UiClass, type UiContract, type ViewImpl } from '@playfast/reform'
import type {
  ArrayBinding,
  ArrayItem,
  ArrayPath,
  FieldBinding,
  FieldPath,
  PathValue,
  Values,
  VariantBody,
  VariantPath,
  VariantTag,
  VariantValue,
  View,
  AnyForm,
} from '@playfast/reform-forms'
import { joinPath } from '@playfast/reform-forms'

export type FieldComponent<A, P extends object = {}> = ComponentType<
  { readonly field: FieldBinding<A> } & P
>

export interface FieldHandle<A> {
  as(component: FieldComponent<A>): ReactNode
  as<P extends object>(component: FieldComponent<A, P>, props: P): ReactNode
}

export interface ArrayItemScope<Item> extends ScopeHelpers<Item> {
  readonly key: string
  readonly index: number
  readonly value: Item
  readonly remove: () => void
  readonly move: (to: number) => void
}

export interface ArrayRenderArgs<Item> {
  readonly items: ReadonlyArray<ArrayItemScope<Item>>
  readonly append: (value?: Item) => void
  readonly remove: (index: number) => void
  readonly move: (from: number, to: number) => void
  readonly swap: (a: number, b: number) => void
}

type VariantCases<V> = {
  readonly [Tag in VariantTag<V>]: (scope: ScopeHelpers<VariantBody<V, Tag>>) => ReactNode
}

export interface ScopeHelpers<ScopeValues> {
  readonly field: <P extends FieldPath<ScopeValues>>(
    path: P,
  ) => FieldHandle<PathValue<ScopeValues, P>>
  readonly array: <P extends ArrayPath<ScopeValues>>(
    path: P,
    render: (args: ArrayRenderArgs<ArrayItem<ScopeValues, P>>) => ReactNode,
  ) => ReactNode
  readonly variant: <P extends VariantPath<ScopeValues>>(
    path: P,
    cases: VariantCases<VariantValue<ScopeValues, P>>,
  ) => ReactNode
}

export interface RootHelpers<F extends AnyForm> extends ScopeHelpers<Values<F>> {
  readonly form: View<F>
}

type ContractWithForm<F extends AnyForm> = UiContract & {
  readonly props: { readonly form: View<F> }
}

const makeFieldHandle = <A,>(field: FieldBinding<A>): FieldHandle<A> => ({
  as: <P extends object>(component: FieldComponent<A, P>, props?: P): ReactNode =>
    createElement(
      component,
      Fn.unsafeCoerce<object, { readonly field: FieldBinding<A> } & P>({ ...props, field }),
    ),
})

interface RuntimeFormView {
  readonly field: <A>(path: string) => FieldBinding<A>
  readonly array: <Item>(path: string) => ArrayBinding<Item>
  readonly variantValue: <Variant>(path: string) => Variant
}

const makeScope = <ScopeValues,>(
  form: RuntimeFormView,
  prefix: string,
): ScopeHelpers<ScopeValues> => {
  const full = (path: string): string => joinPath(prefix, path)
  return {
    field: (path) =>
      makeFieldHandle(form.field<PathValue<ScopeValues, typeof path>>(full(String(path)))),
    array: (path, render) => {
      const binding = form.array<ArrayItem<ScopeValues, typeof path>>(full(String(path)))
      return render({
        append: binding.append,
        remove: binding.remove,
        move: binding.move,
        swap: binding.swap,
        items: Fn.unsafeCoerce(
          binding.items.map((element) => ({
            ...makeScope(form, `${binding.path}[${element.index}]`),
            key: element.key,
            index: element.index,
            value: element.value,
            remove: element.remove,
            move: element.move,
          })),
        ),
      })
    },
    variant: (path, cases) => {
      const variantPath = full(String(path))
      const current = form.variantValue(variantPath)
      if (current === null || typeof current !== 'object' || !('_tag' in current)) {
        return null
      }
      const tag = String(current._tag)
      const handlers = Fn.unsafeCoerce<
        typeof cases,
        Record<string, (scope: ScopeHelpers<unknown>) => ReactNode>
      >(cases)
      const render = handlers[tag]
      return render === undefined ? null : render(makeScope(form, variantPath))
    },
  }
}

export const make = <F extends AnyForm, C extends ContractWithForm<F>, N extends string>(
  contract: UiClass<C, N>,
  _form: F,
  render: (
    helpers: RootHelpers<F> & { readonly props: C['props'] },
    slots: Parameters<ViewImpl<C>>[1],
    events: Parameters<ViewImpl<C>>[2],
  ) => ReactNode,
): MadeView<C, N> =>
  Ui.make(contract, (props, slots, events) =>
    render(
      {
        ...makeScope<Values<F>>(Fn.unsafeCoerce(props.form), ''),
        form: props.form,
        props,
      },
      slots,
      events,
    ),
  )

export const FormUi: { readonly make: typeof make } = { make }