import { is } from "./is";
import { DefaultPointer, Value } from "./values";

export type Tuple<T> = Array<T> | [T];

export type Record<LabelType extends Value<T>, FieldsType extends Tuple<Value<T>>, T extends object = DefaultPointer>
    = FieldsType & { label: LabelType };

export type RecordGetters<Fs, R> = {
    [K in string & keyof Fs]: (r: R) => Fs[K];
};

export type CtorTypes<Fs, Names extends Tuple<keyof Fs>> =
    { [K in keyof Names]: Fs[keyof Fs & Names[K]] } & any[];

export interface RecordConstructor<L extends Value<T>, Fs, Names extends Tuple<keyof Fs>, T extends object = DefaultPointer> {
    (...fields: CtorTypes<Fs, Names>): Record<L, CtorTypes<Fs, Names>, T>;
    constructorInfo: RecordConstructorInfo<L, T>;
    isClassOf(v: any): v is Record<L, CtorTypes<Fs, Names>, T>;
    _: RecordGetters<Fs, Record<L, CtorTypes<Fs, Names>, T>>;
};

export interface RecordConstructorInfo<L extends Value<T>, T extends object = DefaultPointer> {
    label: L;
    arity: number;
}

export function Record<L extends Value<T>, FieldsType extends Tuple<Value<T>>, T extends object = DefaultPointer>(
    label: L, fields: FieldsType): Record<L, FieldsType, T>
{
    (fields as any).label = label;
    return fields as Record<L, FieldsType, T>;
}

export namespace Record {
    export function isRecord<L extends Value<T>, FieldsType extends Tuple<Value<T>>, T extends object = DefaultPointer>(x: any): x is Record<L, FieldsType, T> {
        return Array.isArray(x) && 'label' in x;
    }

    export function fallbackToString (_f: Value<any>): string {
        return '<unprintable_preserves_field_value>';
    }

    export function constructorInfo<L extends Value<T>, FieldsType extends Tuple<Value<T>>, T extends object = DefaultPointer>(
        r: Record<L, FieldsType, T>): RecordConstructorInfo<L, T>
    {
        return { label: r.label, arity: r.length };
    }

    export function isClassOf<L extends Value<T>, FieldsType extends Tuple<Value<T>>, T extends object = DefaultPointer>(
        ci: RecordConstructorInfo<L, T>, v: any): v is Record<L, FieldsType, T>
    {
        return (Record.isRecord(v)) && is(ci.label, v.label) && (ci.arity === v.length);
    }

    export function makeConstructor<Fs, T extends object = DefaultPointer>()
    : (<L extends Value<T>, Names extends Tuple<keyof Fs>>(label: L, fieldNames: Names) =>
        RecordConstructor<L, Fs, Names, T>)
    {
        return <L extends Value<T>, Names extends Tuple<keyof Fs>>(label: L, fieldNames: Names) => {
            const ctor: RecordConstructor<L, Fs, Names, T> =
                ((...fields: CtorTypes<Fs, Names>) =>
                    Record(label, fields)) as RecordConstructor<L, Fs, Names, T>;
            const constructorInfo = { label, arity: fieldNames.length };
            ctor.constructorInfo = constructorInfo;
            ctor.isClassOf = (v: any): v is Record<L, CtorTypes<Fs, Names>, T> => Record.isClassOf(constructorInfo, v);
            (ctor as any)._ = {};
            fieldNames.forEach((name, i) => (ctor._ as any)[name] = (r: Record<L, CtorTypes<Fs, Names>, T>) => r[i]);
            return ctor;
        };
    }
}

Array.prototype.asPreservesText = function (): string {
    if ('label' in (this as any)) {
        const r = this as Record<Value, Tuple<Value>, DefaultPointer>;
        return '<' + r.label.asPreservesText() + (r.length > 0 ? ' ': '') +
            r.map(f => {
                try {
                    return f.asPreservesText();
                } catch (e) {
                    return Record.fallbackToString(f);
                }
            }).join(' ') + '>';
    } else {
        return '[' + this.map(i => i.asPreservesText()).join(', ') + ']';
    }
};