import type { Exact, ValueOf } from "type-fest";

type UnaryFn<T, R> = (shape: T) => R;

// `Extract` drops optional handlers (`undefined`) so `PatternReturns` also works
// when `P`'s constraint has optional keys.
type PatternReturns<P> = ReturnType<
    Extract<ValueOf<P>, (...args: never[]) => unknown>
>;

type Handlers<T extends string | number, R> = { [K in T]: UnaryFn<K, R> };

// The fallback is a *second argument*, not a property of the handler map,
// because its parameter is the remainder `Exclude<T, keyof Handled>` and TypeScript
// fixes a property's contextual type before it infers its sibling keys. A later
// argument, by contrast, is contextually typed from inference on an earlier
// one, so the split is what makes the remainder expressible at all.
// See development/library.md.
type Fallback<T extends string | number, Handled, R> = UnaryFn<
    Exclude<T, keyof Handled>,
    R
>;

// TypeScript does not apply the excess-property check to a generic constraint,
// so `Exact` restores it for the generic forms: a handler map can otherwise
// carry keys outside `T`.

// oxlint-disable typescript/unified-signatures
// Strict returns: one common `R`. Overload order is load-bearing:
//   #1 Handlers (first) -> the exhaustive form and the autocomplete popup
//   #2 Fallback (last)  -> accepts a partial handler map plus a fallback
interface MatcherStrict<T extends string | number> {
    <R>(handlers: Handlers<T, R>): UnaryFn<T, R>;
    <R, Handled extends Exact<Partial<Handlers<T, R>>, Handled>>(
        handlers: Handled & Partial<Handlers<T, R>>,
        fallback: Fallback<T, Handled, R>,
    ): UnaryFn<T, R>;
}
// oxlint-enable typescript/unified-signatures

// Widened returns: the union of every handler's return type. `P` is inferred
// from the whole handler map, whose closed constraint supplies the
// contextual/autocomplete type.
// oxlint-disable typescript/unified-signatures
interface MatcherWidening<T extends string | number> {
    <P extends Exact<Handlers<T, unknown>, P>>(
        handlers: P,
    ): UnaryFn<T, PatternReturns<P>>;
    <R, Handled extends Exact<Partial<Handlers<T, unknown>>, Handled>>(
        handlers: Handled,
        fallback: Fallback<T, Handled, R>,
    ): UnaryFn<T, PatternReturns<Handled> | R>;
}
// oxlint-enable typescript/unified-signatures

type HandlerMap = Record<string | number, UnaryFn<never, unknown> | undefined>;

const dispatch =
    (handlers: HandlerMap, fallback?: UnaryFn<never, unknown>) =>
    (shape: string | number): unknown =>
        (
            handlers[shape] ??
            fallback ??
            (() => {
                throw new Error(`Unhandled shape: ${shape}`);
            })
        )(
            // oxlint-disable-next-line typescript/no-unsafe-type-assertion
            shape as never,
        );

export const getMatcher = <T extends string | number>(): MatcherStrict<T> =>
    dispatch;
export const getMatcherW = <T extends string | number>(): MatcherWidening<T> =>
    dispatch;