import type * as H from 'hotscript'

import {Controller} from '@hotwired/stimulus'
import {type Fn} from 'hotscript'

type ObjIterator<T, Y extends Fn> = H.Pipe<
  T,
  [H.Objects.Entries, H.Unions.ToTuple, H.Tuples.FlatMap<Y>, H.Tuples.ToUnion, H.Objects.FromEntries]
>

/*
 * Covering `has<Name>` and `<name>Value` for Stimulus values.
 */
interface ValuesFn extends Fn {
  return: [
    [`${this['arg0'][0]}Value`, ReturnType<this['arg0'][1]>],
    [`has${Capitalize<this['arg0'][0]>}Value`, boolean],
  ]
}
/*
 * Covering `has<Name>`, `<name>Target` and `<name>Targets` for Stimulus targets.
 */
interface TargetsFn extends Fn {
  return: [
    [`has${Capitalize<this['arg0'][0]>}Target`, boolean],
    [`${this['arg0'][0]}Target`, this['arg0'][1] extends null ? HTMLElement : InstanceType<this['arg0'][1]>],
    [`${this['arg0'][0]}Targets`, this['arg0'][1] extends null ? HTMLElement[] : InstanceType<this['arg0'][1]>[]],
  ]
}

type TargetsConfig = Record<string, (new () => HTMLElement) | null>
type ValuesConfig = Record<string, unknown>

type ControllerWithTargets<E extends HTMLElement, T extends TargetsConfig, Y extends ValuesConfig> = Controller<E> &
  ObjIterator<T, TargetsFn> &
  ObjIterator<Y, ValuesFn>

/**
 * Creates a new Stimulus controller class with automatically defined target properties.
 * The function takes an array of target identifiers, which can be either strings or tuples.
 * For each target, it creates three properties on the controller class:
 * - `<name>Target` for single target elements,
 * - `<name>Targets` for all target elements,
 * - `has<Name>Target` as a boolean indicating the presence of the target.
 *
 * The single target elements are typed according to the provided class in the tuple,
 * or as HTMLElement by default if a string is provided.
 *
 * @returns {Function} A new controller class extending the base Stimulus controller with the defined target properties.
 *
 * @example
 * export default class extends controllerFactory<HTMLDivElement>()({
 *  targets: {
 *    one: null,
 *    two: HTMLInputElement,
 *    three: HTMLButtonElement
 *  },
 *  values: {
 *    key: String,
 *  }
 *}) {
 *  example() {
 *    this.oneTarget      // <- HTMLElement
 *    this.twoTarget      // <- HTMLInputElement
 *    this.threeTarget    // <- HTMLButtonElement
 *
 *    this.hasOneTarget   // <- boolean
 *    this.oneTargets     // <- HTMLElement[]
 *
 *    this.hasKeyValue    // <- boolean
 *    this.keyValue       // <- string
 *
 *    this.element        // <- HTMLDivElement
 *  }
 *}
 */
export function controllerFactory<E extends HTMLElement>() {
  return function createControllerClass<
    const T extends TargetsConfig = TargetsConfig,
    const Y extends ValuesConfig = ValuesConfig,
  >({
    targets,
    values,
  }: {
    targets?: T
    values?: Y
  } = {}): new () => ControllerWithTargets<E, T, Y> {
    class ExtendedController extends Controller<E> {
      static targets = Object.keys(targets ?? {})
      static values = values ?? {}
    }

    return ExtendedController as unknown as new () => ControllerWithTargets<E, T, Y>
  }
}