import { Context, Controller } from "@hotwired/stimulus";

interface PClass<T> {
  prototype: T;
}

// Camelback
type Cbz<T extends string> = T extends `${infer A}_${infer B}`
  ? `${A}${Cbz<Capitalize<B>>}`
  : T extends `${infer A}-${infer B}`
  ? `${A}${Cbz<Capitalize<B>>}`
  : T;

type Camelize<T extends string> = Capitalize<Cbz<T>>;

namespace Values {
  type ValuesConstructors =
    | BooleanConstructor
    | NumberConstructor
    | StringConstructor;

  interface TypeWithDefault {
    type: ValuesConstructors;
    default: unknown;
  }

  export interface ValueType {
    [name: string]: ValuesConstructors | TypeWithDefault;
  }

  type HasValue<V extends ValueType> = {
    [K in keyof V as `has${Camelize<K & string>}Value`]: boolean;
  };

  type NamedValue<V extends ValueType> = {
    [K in keyof V as `${Cbz<K & string>}Value`]: V[K] extends TypeWithDefault
      ? ReturnType<V[K]["type"]>
      : V[K] extends ValuesConstructors
      ? ReturnType<V[K]>
      : unknown;
  };

  export type Typed<V extends ValueType> = HasValue<V> & NamedValue<V>;
}

namespace Targets {
  type TargetConstructors = PClass<HTMLElement>;

  export interface ValueType {
    [name: string]: TargetConstructors;
  }

  type HasTarget<V extends ValueType> = {
    [K in keyof V as `has${Camelize<K & string>}Target`]: boolean;
  };

  type NamedTarget<V extends ValueType> = {
    [K in keyof V as `${Cbz<
      K & string
    >}Target`]: V[K] extends TargetConstructors ? V[K]["prototype"] : unknown;
  };

  export type Typed<V extends ValueType> = HasTarget<V> & NamedTarget<V>;
}

namespace Outlets {
  type OutletConstructors = PClass<Controller>;

  export interface ValueType {
    [name: string]: OutletConstructors;
  }

  type HasOutlet<V extends ValueType> = {
    [K in keyof V as `has${Camelize<K & string>}Outlet`]: boolean;
  };

  type NamedOutlet<V extends ValueType> = {
    [K in keyof V as `${Cbz<
      K & string
    >}Outlet`]: V[K] extends OutletConstructors ? V[K]["prototype"] : unknown;
  };

  export type Typed<V extends ValueType> = HasOutlet<V> & NamedOutlet<V>;
}

interface StaticOptions<
  V extends Values.ValueType,
  T extends Targets.ValueType,
  O extends Outlets.ValueType
> {
  values?: V;
  targets?: T;
  outlets?: O;
}

interface TControllerInstance<
  P extends PClass<any>,
  V extends Values.ValueType,
  T extends Targets.ValueType,
  O extends Outlets.ValueType
> {
  new (context: Context): Controller<P["prototype"]> &
    Values.Typed<V> &
    Targets.Typed<T> &
    Outlets.Typed<O>;
}

export function TController<
  E extends HTMLElement,
  P extends PClass<E>,
  V extends Values.ValueType = {},
  T extends Targets.ValueType = {},
  O extends Outlets.ValueType = {}
>(options: StaticOptions<V, T, O> & { el: P }) {
  return class extends Controller<E> {
    static values = options.values ?? {};
    static targets = Object.keys(options.targets ?? {});
    static outlets = Object.keys(options.outlets ?? {});
  } as unknown as TControllerInstance<P, V, T, O>;
}