import { AllowedNames } from "../types";
import { getInheritedHiddenProp } from "../object";

type ObjectKey = (string | symbol | number);

export interface RegisterDecorator<T, R> {
    <O>(target: O, property: AllowedNames<O, T>, descriptor?: PropertyDescriptor): any;
    get_registry(target: any): Record<ObjectKey, { key: ObjectKey, params: R }>;
    get_keys(target: any): ObjectKey[]
    registry_symbol: Symbol;
}

export interface ArgRegisterDecorator<T, R extends any[], P> {
    (...args: R): (<O>(target: O, property: AllowedNames<O, T>, descriptor?: PropertyDescriptor) => any)
    get_registry(target: any): Record<ObjectKey, P>
    get_keys(target: any): ObjectKey[]
    registry_symbol: Symbol;
}

// TODO Stage 3 Compat?
export function create_arg_registering_decorator<T, R extends any[]>(): ArgRegisterDecorator<T, R, { key: string, params: R }>
export function create_arg_registering_decorator<T, R extends any[], P>(transformer: (key: symbol | string, ...args: R) => P): ArgRegisterDecorator<T, R, P>
export function create_arg_registering_decorator<T, R extends any[], P>(
    transformer: (key, ...args: R) => P = ((key, ...params) => ({ key, params })) as any
) {
    const symbol = Symbol();

    const metaDecorator = (...args: R) => {
        const decorator = (<O>(target: O, property: AllowedNames<O, T>, descriptor?: PropertyDescriptor): any => {
            const registry = metaDecorator.get_registry(target);
            registry[property] = transformer(property, ...args);
            return descriptor;
        }) as any as ArgRegisterDecorator<T, R, P>;

        return decorator;
    }

    metaDecorator.get_registry = (target: any) => getInheritedHiddenProp(target, symbol, 'object')

    metaDecorator.get_keys = (target: any) => {
        const registry = metaDecorator.get_registry(target);
        return Object.keys(registry);
    }

    metaDecorator.registry_symbol = symbol;

    return metaDecorator as any;
}

// TODO Stage 3 Compat?
export function create_registering_decorator<T>(): RegisterDecorator<T, { key: string }> {
    const symbol = Symbol();
    const decorator = <O>(target: O, property: AllowedNames<O, T>, descriptor?: PropertyDescriptor): any => {
        const registry = decorator.get_registry(target);
        registry[property] = {
            key: property,
        }
        return descriptor;
    }

    decorator.get_registry = (target: any) => getInheritedHiddenProp(target, symbol, 'object')

    decorator.get_keys = (target: any) => {
        const registry = decorator.get_registry(target);
        return Object.keys(registry);
    }

    decorator.registry_symbol = symbol;

    return decorator as any;
}