import {Schema, Field, Fields, CheckFunction, CheckType, CheckObject} from "./Schema";
import {FieldSetUtil} from "./FieldSetUtil";
import {SchemaUtil} from "./SchemaUtil";
import {Validation} from "@anyhowstep/validation";

export class SchemaBuilder<T, Desired> {
    private schema : Schema<T>;
    constructor (schema : Schema<T>) {
        this.schema = schema;
    }
    public static Create<Desired> () {
        return new SchemaBuilder<{}, Desired>({
            fields: {}
        });
    }

    private createFields<K extends keyof Desired, F> (key : K, field : Field<F>) : Fields<T & { [k in K] : F }> {
        return Object.assign(
            {},
            this.schema.fields,
            {
                [key.toString()] : field
            }
        ) as any;
    }
    private copyWithField<K extends keyof Desired, F> (key : K, field : Field<F>) : Schema<T & { [keyName in K] : F }> {
        return {
            allowExtraFields: this.schema.allowExtraFields,
            check: this.schema.check,
            fields: this.createFields(key, field)
        };
    }
    public add<K extends keyof Desired> (key : K, field : CheckType<Desired[K]>) : SchemaBuilder<T & { [keyName in K] : Desired[K] }, Desired>;
    public add<K extends keyof Desired> (key : K, field : CheckObject<Desired[K]>) : SchemaBuilder<T & { [keyName in K] : Desired[K] }, Desired>;
    public add<K extends keyof Desired> (key : K, field : CheckType<Desired[K]> | CheckObject<Desired[K]>) : SchemaBuilder<T & { [keyName in K] : Desired[K] }, Desired> {
        return new SchemaBuilder<T & { [k in K] : Desired[K] }, Desired>(this.copyWithField(key, field));
    }
    public optional<K extends keyof Desired, F extends Desired[K]> (key : K, check : CheckFunction<F>|Schema<F>) : SchemaBuilder<T & { [keyName in K] : F|undefined }, Desired> {
        if (FieldSetUtil.IsSchema(check)) {
            return new SchemaBuilder<T & { [k in K] : F|undefined }, Desired>(
                this.copyWithField(key, SchemaUtil.GetOptionalCheck(check))
            );
        } else {
            return new SchemaBuilder<T & { [k in K] : F|undefined }, Desired>(
                this.copyWithField(key, Validation.IsOptionalHandler(check))
            );
        }
    }
    public allowExtraFields () : SchemaBuilder<T, Desired> {
        return new SchemaBuilder({
            allowExtraFields: true,
            check: this.schema.check,
            fields: Object.assign({}, this.schema.fields)
        });
    }
    public check (this : SchemaBuilder<Desired, T>, check : (name : string, target : T) => Promise<void>) : SchemaBuilder<T, T> {
        return new SchemaBuilder<T, T>({
            allowExtraFields: this.schema.allowExtraFields,
            check: check,
            fields: Object.assign({}, this.schema.fields) as any
        });
    }
    public build (this : SchemaBuilder<Desired, T>) : Schema<T> {
        return {
            allowExtraFields: this.schema.allowExtraFields,
            check: this.schema.check as any,
            fields: Object.assign({}, this.schema.fields) as any
        };
    }

    private unionAllowExtraFields<B> (other : Schema<B>) : boolean|undefined {
        if (this.schema.allowExtraFields == true || other.allowExtraFields == true) {
            return true;
        } else {
            return undefined;
        }
    }
    private unionCheck<B> (other : Schema<B>) : ((name : string, target : T&B) => Promise<void>)|undefined {
        const myCheck = this.schema.check;
        const otherCheck = other.check;

        if (myCheck == null) {
            if (otherCheck == null) {
                return undefined;
            } else {
                return other.check;
            }
        } else {
            if (otherCheck == null) {
                return this.schema.check;
            } else {
                return (name, target) => {
                    return otherCheck(name, target)
                        .then(() => {
                            return myCheck(name, target);
                        });
                };
            }
        }
    }
    private unionFields<B> (other : Schema<B>) : Fields<T & B> {
        return Object.assign(
            {},
            other.fields,
            this.schema.fields
        ) as any;
    }
    public union<B> (other : Schema<B>) : SchemaBuilder<T & B, Desired> {
        return new SchemaBuilder<T & B, Desired>({
            allowExtraFields: this.unionAllowExtraFields(other),
            check: this.unionCheck(other),
            fields: this.unionFields(other)
        });
    }
    public partialUnion<B> (other : Schema<B>) : SchemaBuilder<T & Partial<B>, Desired> {
        return this.union(SchemaUtil.ToPartial(other));
    }

    public remove<K extends keyof T> (key : K) : SchemaBuilder<T & { [k in K]? : undefined; }, Desired> {
        const fields = Object.assign({}, this.schema.fields);
        delete fields[key];

        return new SchemaBuilder<T & { [k in K]? : undefined }, Desired>({
            allowExtraFields: this.schema.allowExtraFields,
            check: this.schema.check,
            fields: fields as any
        });
    }
}