import "./events";
import "./lifecycle";

declare const anyParentNodeModifierTag: unique symbol;

type NativeElementAttributes<TTagName extends ElementTagName> = {
  [K in keyof HTMLElementTagNameMap[TTagName] as K extends `on${string}` ? never : K]?:
    K extends "style"
      ? ValueOrFactory<CSSStyleObject>
      : ValueOrFactory<HTMLElementTagNameMap[TTagName][K]>;
};

type LowercaseEventAttributes<TTagName extends ElementTagName> = {
  [K in Extract<keyof HTMLElementTagNameMap[TTagName], `on${string}`>]?: never;
};

/**
 * `onMount` / `onDestroy` attributes — not real DOM events (no native
 * `on${string}` IDL property exists for them), so they're typed here rather
 * than derived from HTMLElementEventAttributeNameMap. See src/element/lifecycle.ts.
 */
type LifecycleElementAttributes<TTagName extends ElementTagName> = {
  onMount?: MountCallback<HTMLElementTagNameMap[TTagName]>;
  onDestroy?: DestroyCallback<HTMLElementTagNameMap[TTagName]>;
};

declare global {
  export type Primitive = string | number | bigint | boolean | symbol | null | undefined;
  export type ElementTagName = keyof HTMLElementTagNameMap;
  export type SVGTagName = keyof SVGElementTagNameMap;
  export type ValueFactory<TValue> = () => TValue;
  export type ValueOrFactory<TValue> = TValue | ValueFactory<TValue>;
  // `never[]` (not `unknown[]`) so factories with typed parameters still match:
  // `(...args: unknown[])` rejects e.g. `(x: number) => string` under strict
  // contravariance and would resolve to never.
  export type InferFactoryResult<TFactory> = TFactory extends (...args: never[]) => infer TResult
    ? TResult
    : never;

  // CSS style object: only the string-valued (settable) CSSStyleDeclaration
  // properties, as string | number. Filters out methods (setProperty, item…),
  // readonly non-string members (length, parentRule) and the numeric index.
  export type CSSStyleObject = {
    [K in keyof CSSStyleDeclaration as K extends string
      ? CSSStyleDeclaration[K] extends string
        ? K
        : never
      : never]?: string | number;
  };

  // Core element attribute types
  export type ExpandedElementAttributes<
    TTagName extends ElementTagName = ElementTagName,
  > = NativeElementAttributes<TTagName>
    & CamelCaseEventAttributes<TTagName>
    & LowercaseEventAttributes<TTagName>
    & LifecycleElementAttributes<TTagName>
    & {
      // Allow custom attributes (data-*, aria-*, etc.)
      [key: string]: ValueOrFactory<unknown>;
    };

  export type DetachedExpandedElementFactory<
    TTagName extends ElementTagName = ElementTagName,
  > = NodeModFn<TTagName> & ((
    parent?: ExpandedElement<TTagName>,
    index?: number,
  ) => ExpandedElement<TTagName>) & {
    readonly [anyParentNodeModifierTag]: true;
  };

  /** Type-only marker for modifiers whose runtime accepts any parent tag. */
  export type AnyParentNodeModifier = {
    readonly [anyParentNodeModifierTag]: true;
  };

  // Core element type
  export type ExpandedElement<
    TTagName extends ElementTagName = ElementTagName,
  > = Partial<Omit<HTMLElementTagNameMap[TTagName], "tagName">> &
    Pick<HTMLElementTagNameMap[TTagName], "tagName">;

  /** A block or portal modifier returns its comment anchor. */
  export type MarkerModifier = (parent: ExpandedElement, index: number) => Comment;

  // Core modifier types
  export type NodeRenderable<TTagName extends ElementTagName = ElementTagName> =
    | Primitive
    | ExpandedElementAttributes<TTagName>
    | ExpandedElement<TTagName>
    | Node;

  export type NodeMod<TTagName extends ElementTagName = ElementTagName> =
    | NodeRenderable<TTagName>
    | ValueFactory<Primitive>
    | ((parent: ExpandedElement<TTagName>, index: number) => Node);  // Allow Node builders

  export type NodeModFn<TTagName extends ElementTagName = ElementTagName> = (
    parent: ExpandedElement<TTagName>,
    index: number,
  ) => NodeMod<TTagName> | void;

  export type NodeModLike<TTagName extends ElementTagName = ElementTagName> =
    | NodeMod<TTagName>
    | NodeModFn<TTagName>
    | AnyParentNodeModifier;

  export type InferExpandedElement<TValue> =
    TValue extends ExpandedElement<infer TTagName>
      ? ExpandedElement<TTagName>
      : TValue extends DetachedExpandedElementFactory<infer TTagName>
        ? ExpandedElement<TTagName>
        : TValue extends ExpandedElementBuilder<infer TTagName>
          ? ExpandedElement<TTagName>
          : TValue extends NodeModFn<infer TTagName>
            ? ExpandedElement<TTagName>
            : Extract<TValue, Element>;

  // Core builder types
  export type ExpandedElementBuilder<
    TTagName extends ElementTagName = ElementTagName,
  > = (
    ...rawMods: readonly NodeModLike<TTagName>[]
  ) => DetachedExpandedElementFactory<TTagName>;
}

export { };