import { BeanConsulta } from "./beanConsulta";
import { Subject } from "rxjs";
import { isNullOrUndefined } from "util";

export class AbstractPaged<T> {

    public size: number;
    public page: number;
    public sizeDB: number;
    public pageIndex: number;
    public dataList: any[];
    public subject: Subject<any>;
    public cleanSearch: Subject<any>;

    constructor(_size?: number) {
        this.page = 0;
        this.size = _size ? _size : 20;
        this.sizeDB = 0;
        this.pageIndex = 0;
        this.dataList = [];
        this.subject = new Subject<any>();
    }

    public setRequest(request: any, resetList?: boolean) {
        if (resetList) {
            this.dataList = request.dataList;
        } else {
            this.dataList = this.dataList.concat(request.dataList);
        }
        this.sizeDB = request.sizeDB;
        this.subject.next();
    }

    public resetPagination() {
        this.page = 0;
        this.size = 20;
        this.sizeDB = 0;
        this.pageIndex = 0;
        this.dataList = [];
    }

    public resolve(params?: any, filters?: any, filtersDefault?: any, ): BeanConsulta<T> {
        let beanConsulta: BeanConsulta<T> = new BeanConsulta<T>();
        beanConsulta.page = this.page;
        beanConsulta.size = this.size;
        if (params) {
            let fields = Object.keys(params);
            fields.forEach(element => {
                beanConsulta[element] = params[element];
            });
        }

        if (isNullOrUndefined(beanConsulta.queryFilters) && (!isNullOrUndefined(filters) || !isNullOrUndefined(filtersDefault))) {
            beanConsulta.queryFilters = [];
        }
        if (!isNullOrUndefined(filters)) {
            let fieldsFilters: string[] = Object.keys(filters);
            fieldsFilters.forEach(element => {
                beanConsulta.queryFilters.push({ field: element, value: filters[element] })
            });
        }
        if (!isNullOrUndefined(filtersDefault)) {
            let fieldsFilters: string[] = Object.keys(filtersDefault);
            fieldsFilters.forEach(element => {
                beanConsulta.queryFilters.push({ field: element, value: filtersDefault[element] })
            });
        }

        return beanConsulta;
    }


    protected resolverFilters(filters: any, value?: any, removeFields?: string[]): [any, boolean] {
        if (isNullOrUndefined(filters)) {
            return [value, false];
        } else {
            let retorno = Object.assign(filters, value || {});
            if (!isNullOrUndefined(removeFields)) {
                removeFields.forEach(field => {
                    delete retorno[field];
                })
            }
            return [retorno, false];
        }
    }

    public isCallRequest() {
        let retorno: boolean = ((this.page + 1) * this.size) < this.sizeDB;
        if (retorno) {
            this.page = ++this.page;
        }
        return retorno;
    }

    public nextCleanSearch(value?: any) {
        if (!isNullOrUndefined(this.cleanSearch)) {
            this.cleanSearch.next(value);
        }
    }
}