import {Const} from '../../utils/const';
import {IGridSelectItem} from './grid-select-item';


export class GridSelectFactory {
    /**
     * Returns select item for grid
     */
    static getGridSelect(headerName: string, field: string, editable: boolean, values: any[], itemKey: string,
                         itemValueKeys: string[], mandatory: boolean = true, relatesOnDgField: string = null,
                         headerClass: string = null, pinned: boolean = false, cellClass: any = null,
                         exclusive: boolean = false, exclusiveCompareData: any = null, exclusiveCompareDataKey: string = null): {} {

        if (null !== relatesOnDgField && exclusive) {
            // NOTE: This is not allowed for now, maybe needed in future
            throw new Error('Select can be either relative or exclusive');
        }

        const res = {
            headerName,
            field,
            headerClass,
            pinned,
            editable,
            cellClass: null === cellClass ?? (editable ? '' : Const.CSS_NO_EDIT),
            cellRenderer: 'gridSelectRenderer',
            cellEditor: 'gridSelectEditor',
            cellEditorParams: {
                values: null === relatesOnDgField && !exclusive ? GridSelectFactory.getGridSelectItems(values, itemKey, itemValueKeys, mandatory) : values,
                itemKey,
                itemValueKeys,
                mandatory,
                relatesOnDgField,
                exclusive,
                exclusiveCompareData,
                exclusiveCompareDataKey
            }
        };
        if (mandatory) {
            res['cellClassRules'] = {
                error(params) {
                    return params.value == null;
                }
            };
        }
        return res;
    }

    /**
     * Returns select item for grid without renderer and editor
     */
    static getGridSelectForSelectors(headerName: string, field: string, editable: boolean, values: any[], itemKey: string,
                                     itemValueKeys: string[], mandatory: boolean = true, relatesOnDgField: string = null,
                                     headerClass: string = null, pinned: boolean = false, cellClass: any = null,
                                     exclusive: boolean = false, exclusiveCompareData: any = null, exclusiveCompareDataKey: string = null): {} {

        const res: {} = GridSelectFactory.getGridSelect(
            headerName, field, editable, values, itemKey, itemValueKeys, mandatory, relatesOnDgField,
            headerClass, pinned, cellClass, exclusive, exclusiveCompareData, exclusiveCompareDataKey
        );
        delete res['cellRenderer'];
        delete res['cellEditor'];
        return res;
    }

    /**
     * Returns array of grid select items
     */
    static getGridSelectItems(objArray: any[], key: string, valueKeys: string[], mandatory: boolean = true): IGridSelectItem[] {
        const res: IGridSelectItem[] = [];

        if (!mandatory) {
            // Add empty item (null value)
            res.push(GridSelectFactory.getGridSelectItem({key: null, value: '-'}, 'key', valueKeys, true));
        }

        objArray.forEach(item => {
            res.push(GridSelectFactory.getGridSelectItem(item, key, valueKeys));
        });
        return res;
    }

    /**
     * Returns single grid select item
     */
    static getGridSelectItem(obj: any, key: string, valueKeys: string[], isNullItem: boolean = false): IGridSelectItem {
        if (!obj.hasOwnProperty(key)) {
            throw new Error('GridFactory: Key not found: ' + key);
        }

        let gridItem: {} = {};
        if (!isNullItem) {
            for (const item of valueKeys) {
                if (!obj.hasOwnProperty(key) || !obj.hasOwnProperty(item)) {
                    throw new Error('GridFactory: Value not found: ' + item);
                }
            }
            gridItem = {
                key: obj[key],
                value: GridSelectFactory.getGridSelectItemValue(obj, valueKeys)
            };
        } else {
            // Empty placeholder item
            gridItem = {
                key: obj.key,
                value: obj.value
            };
        }
        return gridItem as IGridSelectItem;
    }

    /**
     * Returns displayed value of grid item
     */
    static getGridSelectItemValue(obj: any, valueKeys: string[]): string {
        let value = '';
        for (let i = 0; i < valueKeys.length; i++) {
            value += obj[valueKeys[i]];
            value += i < (valueKeys.length - 1) ? ' - ' : '';
        }
        return value;
    }
}