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

import type {
    HandlerMap,
    PatternReturns,
    RedundantFallback,
    UnaryFn,
} from "./matcher-shared.ts";

// A tagged union is discriminated by one property whose values are the tags.
// Only `string` and `number` tags can key a handler map: `symbol` has no
// literal syntax to write a handler under, and `bigint` is not a property key.
type Tag = string | number;

// The discriminant values of `T` under `K`. `Extract` keeps the finite literal
// tags and leaves a widened `string`/`number` as itself, so an open universe
// keeps an open fallback.
type Tags<T extends object, K extends keyof T> = Extract<T[K], Tag>;

// The keys of `T` that can act as a discriminant. `getTaggedUnionMatcher<T>()`
// accepts only these, so the factory rejects a key whose values are not tags.
type Discriminated<T extends object> = {
    [K in keyof T]: T[K] extends Tag ? K : never;
}[keyof T];

// The member(s) of `T` tagged `V`. `Extract` distributes over the union, so a
// duplicated tag maps to a union of members rather than silently dropping one.
type MapTaggedUnion<T extends object, K extends keyof T> = {
    [V in Tags<T, K>]: Extract<T, Record<K, V>>;
};

type Handlers<T extends object, K extends keyof T, R> = {
    [V in Tags<T, K>]: UnaryFn<MapTaggedUnion<T, K>[V], R>;
};

// The members `Handled` covers. Mapping over `Tags` keeps every index within
// `MapTaggedUnion`'s keys, and the conditional drops a stray key outside `T` so
// it cannot widen the remainder. The remainder is `Exclude<T, …>`, mirroring
// the primitive matcher's `Exclude<T, PatternParam<keyof Handled>>`.
type HandledMembers<T extends object, K extends keyof T, Handled> = {
    [V in Tags<T, K>]: V extends keyof Handled
        ? MapTaggedUnion<T, K>[V]
        : never;
}[Tags<T, K>];

// The fallback is a *second argument*, not a property of the handler map, so
// its parameter can be the remainder the map left open. See development/library.md.
type Fallback<T extends object, K extends keyof T, Handled, R> = UnaryFn<
    Exclude<T, HandledMembers<T, K, Handled>>,
    R
>;

// A fallback is redundant once the handler map covers every tag of `T`. Folded
// into `Handled`'s own (self-referential) constraint so it is checked *after*
// inference; see the primitive matcher for why a conditional in the fallback's
// parameter is evaluated too early.
type MustBePartial<T extends object, K extends keyof T, Handled> =
    Tags<T, K> extends keyof Handled ? RedundantFallback : unknown;

// TypeScript does not apply the excess-property check to a generic constraint,
// so `Exact` restores it for the generic forms.

// 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 TaggedUnionMatcherStrict<T extends object, K extends keyof T> {
    <R>(handlers: Handlers<T, K, R>): UnaryFn<T, R>;
    <
        R,
        Handled extends Exact<Partial<Handlers<T, K, R>>, Handled> &
            MustBePartial<T, K, Handled>,
    >(
        handlers: Handled & Partial<Handlers<T, K, R>>,
        fallback: Fallback<T, K, Handled, R>,
    ): UnaryFn<T, R>;
}

// 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.
interface TaggedUnionMatcherWidening<T extends object, K extends keyof T> {
    <P extends Exact<Handlers<T, K, unknown>, P>>(
        handlers: P,
    ): UnaryFn<T, PatternReturns<P>>;
    <
        R,
        Handled extends Exact<Partial<Handlers<T, K, unknown>>, Handled> &
            MustBePartial<T, K, Handled>,
    >(
        handlers: Handled,
        fallback: Fallback<T, K, Handled, R>,
    ): UnaryFn<T, PatternReturns<Handled> | R>;
}

const dispatch =
    (k: PropertyKey) =>
    (handlers: HandlerMap, fallback?: UnaryFn<never, unknown>) =>
    (shape: object): unknown => {
        // `object` carries no index signature, so the read needs the assertion;
        // the factory admits only keys whose values are `string | number` tags,
        // so the result is narrowed to the map's key space.
        // oxlint-disable-next-line typescript/no-unsafe-type-assertion
        const tag = (shape as UnknownRecord)[k] as string | number;
        return (
            handlers[tag] ??
            fallback ??
            (() => {
                throw new Error(`Unhandled tag: ${String(tag)}`);
            })
        )(
            // oxlint-disable-next-line typescript/no-unsafe-type-assertion
            shape as never,
        );
    };

export const getTaggedUnionMatcher =
    <T extends object>() =>
    <K extends Discriminated<T>>(k: K): TaggedUnionMatcherStrict<T, K> =>
        dispatch(k);

export const getTaggedUnionMatcherW =
    <T extends object>() =>
    <K extends Discriminated<T>>(k: K): TaggedUnionMatcherWidening<T, K> =>
        dispatch(k);