export class ModelTemplateCombine<const T extends readonly Model.ModelClass[]> {
    readonly type: ArrayCombine<T>['type']
    readonly models: T
    public readonly validations: Set<(value: typeof this.type) => Promise<Model.ValidateReturn>>
    public readonly filters: Set<(value: Model.RemoveTypesForFilter<typeof this.type>) => ArrayCombine<T>['type']>

    constructor(models: T) {
        this.models = models
        this.validations = new Set()
        this.filters = new Set()
    }

    public addValidation(callback: (value: typeof this.type) => Promise<Model.ValidateReturn>) {
        this.validations.add(callback)
    }

    public addFilters(callback: (value: Model.RemoveTypesForFilter<typeof this.type>) => Model.RemoveTypesForFilter<typeof this.type>) {
        this.filters.add(callback)
    }

    public filter(obj: any): any {
        let value = obj
        for (let i = 0; i < this.models.length; i++) {
            const model = this.models[i]

            if (model.filter !== undefined) {
                value = model.filter(value)
            }
        }

        this.filters.forEach(f => { value = f(value)})

        return value
    }

    public async validate(obj: any, skipFilter?: true): Promise<Model.ModelValidateReturnHelper<typeof this.type, undefined>> {
        let v = obj

        if (!skipFilter) {
            v = this.filter(v)
        }

        { // Valida as models
            const promises: Promise<{ errors?: PlataError[] }>[] = []

            for (let i = 0; i < this.models.length; i++) {
                const model = this.models[i];
                
                promises.push(Plata.FastPromise(() => model.validate(v, true)))
            }

            const results = await Promise.all(promises)

            const errors = results
                .filter((r): r is { errors: PlataError[] } => r.errors !== undefined)
                .flatMap(r => r.errors)
            ;

            if (errors.length !== 0) {
                return {
                    value: undefined,
                    errors
                }
            }
        }


        { // Validacoes adicionais
            const promises: Promise<Model.ValidateReturn>[] = []

            this.validations.forEach(va => 
                promises.push(
                    Plata.FastPromise(() => va(v))
                )
            )

            const result = await Promise.all(promises)

            const errors = result.filter(Boolean)

            if (errors.length !== 0) {
                return  {
                    errors,
                    value: undefined
                }
            }
        }

        return {
            value: v,
            errors: undefined
        } 
    }
}