import { ComponentRef } from '@angular/core';
import { DataTableComponent } from '@farris/ui-datatable';
import { TreeNode, TreeTableComponent } from '@farris/ui-treetable';
import { UserFavoriteData } from '../http/RemoteParams';
import { FavoriteAction, FavoriteIcon, FAVORITE_FIELD_NAME, LookupGridDisplayType } from '../lookup-displaytype';
import { LookupGridResult } from '../lookup-grid-options';
import { LookupGridComponent } from '../lookup-grid.component';
import { LookupSelectionService } from './lookup-selection.service';

export class FavoriteHelper {

    private lookupSelectionSer: LookupSelectionService;

    constructor(private instance: LookupGridComponent) {
        this.lookupSelectionSer = this.instance.lookupSelectionSer;
    }

    getFavoriteColumns(): any[] {
        const columns = this.instance.gridOptions.columns.map(item => {
            const rtn = Object.assign({}, item);
            if (item.field === FAVORITE_FIELD_NAME) {
                rtn.formatter = () => FavoriteIcon.delete;
            }
            return rtn;
        });
        return columns;
    }

    favoriteColumnFormatter = (v: any, data: any  ) => {
        const f =  v ? FavoriteIcon.yes : FavoriteIcon.no;
        if (this.instance.isTree()) {
            const id = data[this.instance.idField];
            if (id) {
                const tt = this.instance.componentRef.instance as TreeTableComponent;
                const rn = tt.findRowNode(id);
                if (rn) {
                    if (rn.node.selectable) {
                        return f;
                    } else {
                        return '';
                    }
                }
            }
        }
        return f;
    }

    initPersonalInfo() {
        if (this.instance.personalConfigService) {
            const controlID = this.instance.el.nativeElement.id || this.instance.controlId;
            if (!controlID) {
                console.log('LookupGrid - 未设置组件id, 收藏功能将不能正常，请设置组件id.');
            }
            const pcstr = this.getPersonalConfigKey(controlID);
            this.instance.personalConfigService.controlID = controlID;
            this.instance.personalConfigService.personalConfigKey = pcstr;

            const conf = {
                displayType: this.instance.displayType,
                singleSelect: this.instance.singleSelect,
                idField: this.instance.idField,
                textField: this.instance.textField,
                mapFields: Object.assign({}, this.instance.mapFields || {})
            };

            this.instance.personalConfigService.initPersonalConf(conf);

            // 个性化配置的订阅事件处理
            this.listenPersonalConfigHandler();
        }
    }

    private getPersonalConfigKey(controlID) {
        // return this.instance.ngControl && this.instance.ngControl.name ? this.instance.ngControl.name : this.instance.mapFields
        //     ? this.instance.mapFields[this.instance.textField]
        //     : '';

        if (this.instance.ngControl) {
            if (this.instance.ngControl.name) {
                return this.instance.ngControl.name;
            } else {
                if (this.instance.mapFields && this.instance.mapFields.length) {
                    return Object.keys(this.instance.mapFields).map(k => {
                        return this.instance.mapFields[k];
                    }).join('_');
                } else {
                    return this.instance.textField;
                }
            }
        } else {
            return '';
        }

    }

    /**
     * 监听收藏TAB页中相关事件；
     * 数据选中，取消选中，移除收藏，双击事件
     */
    initFavoriteComponentEvent(cmpRef: ComponentRef<any>) {
        switch (this.instance.displayType) {
            case LookupGridDisplayType.NavList:
            case LookupGridDisplayType.NavTreeList:
            case LookupGridDisplayType.List: {
                const fdt = cmpRef.instance as DataTableComponent;
                fdt.remoteSort = false;
                fdt.selectedRow.subscribe(e => {
                    if (this.instance.singleSelect) {
                        this.lookupSelectionSer.clearSelections();
                    }
                    this.lookupSelectionSer.updateSelections(e.data);
                });
                fdt.unSelectRow.subscribe(e => {
                    this.lookupSelectionSer.unSelect(e.data[this.instance.idField]);
                });

                if (!fdt.singleSelect) {
                    fdt.checkAll.subscribe(e => {
                        this.lookupSelectionSer.updateSelections(fdt.data, e);
                    });
                }

                fdt.cellClick.subscribe((e: any) => {
                    if (e.col.field === FAVORITE_FIELD_NAME) {
                        e.event.stopPropagation();
                        // tslint:disable-next-line: no-string-literal
                        const classList = e.event.target['classList'];
                        if (classList.contains('f-lookup-unfavorite')) {
                            if (this.instance.items) {
                                this.instance.items.forEach(item => {
                                    if (item[this.instance.idField] === e.row[this.instance.idField]) {
                                        item[FAVORITE_FIELD_NAME] = false;
                                    }
                                });

                                const dt = this.instance.componentRef.instance as DataTableComponent;
                                if (dt) {
                                    dt.loadData({
                                        pageSize: this.instance.gridOptions.pageSize,
                                        pageIndex: this.instance.gridOptions.pageIndex,
                                        total: this.instance.gridOptions.total,
                                        data: this.instance.gridOptions.items
                                    });
                                }
                            }

                            this.instance.favoriteItems =
                                this.instance.favoriteItems.filter(n => n[this.instance.idField] !== e.row[this.instance.idField]);

                            this.lookupSelectionSer.updateFavoriteData(e.row, FavoriteAction.delete);
                        }
                    }
                });

                // 双击事件
                fdt.rowDblClick.subscribe((rowData: any) => {
                    if (this.instance.gridOptions.singleSelect) {
                        this.instance.selectItem(rowData);
                    }
                });
                break;
            }
            case LookupGridDisplayType.TreeList: {
                if (cmpRef) {
                    const ftt = cmpRef.instance as TreeTableComponent;
                    ftt.remoteSort = false;
                    ftt.nodeSelected.subscribe(e => {
                        if (this.instance.singleSelect) {
                            this.lookupSelectionSer.clearSelections();
                        }
                        this.lookupSelectionSer.updateSelections(e.node.data);
                    });
                    ftt.nodeUnChecked.subscribe(e => {
                        if (e && e.node && e.node.data && e.node.data.id) {
                            // const tt = this.instance.componentRef.instance as TreeTableComponent;
                            // tt.unSelectNode(e.node.data.id);
                            this.lookupSelectionSer.unSelect(e.node.data.id);
                        }
                    });

                    ftt.nodeChecked.subscribe( e => {
                        if (!this.instance.singleSelect) {
                            if (e.nodes && e.nodes.length) {
                                this.instance.multiSelMgr.updateSelections(e.nodes.map(n => n.data));
                            } else {
                                if (Array.isArray(e.node)) {
                                    this.instance.multiSelMgr.updateSelections(e.node.map(n => n.data));
                                } else {
                                    this.instance.multiSelMgr.updateSelections([e.node.data]);
                                }
                            }
                        }
                    });

                    ftt.cellClick.subscribe(row => {
                        if (row.col.field === FAVORITE_FIELD_NAME) {
                            row.event.stopPropagation();
                            const classList = row.event.target['classList'];
                            if (classList.contains('f-lookup-unfavorite')) {
                                const _this = this.instance;
                                (function every(items) {
                                    if (!items) {
                                        return;
                                    }
                                    let hasFinish = false;
                                    items.forEach(item => {
                                        if (hasFinish) {
                                            return;
                                        }
                                        if (item.data[_this.idField] === row.node[_this.idField]) {
                                            item.data[FAVORITE_FIELD_NAME] = false;
                                            hasFinish = true;
                                        } else if (item.children && item.children.length > 0) {
                                            every(item.children);
                                        }
                                    });
                                })(this.instance.items);
                                const tt = this.instance.componentRef.instance as TreeTableComponent;
                                tt.loadData(this.instance.items);

                                this.lookupSelectionSer.updateFavoriteData(row.node.data, FavoriteAction.delete);
                            }
                        }
                    });
                    ftt.dblClick.subscribe((treeNode: TreeNode) => {
                        if (this.instance.gridOptions.singleSelect && treeNode.selectable) {
                            if (this.instance.okButton) {
                                this.instance.okButton.nativeElement.click();
                            }
                        }
                    });

                    ftt.checkAll.subscribe( e => {
                        const data = e.instance.checkeds.map(n => n.data);
                        this.instance.multiSelMgr.updateSelections(data);
                        this.instance.checkedChange.emit({ data, isCheck: true  });
                    });
                    ftt.unCheckAll.subscribe(() => {
                        this.instance.multiSelMgr.clear();
                        this.instance.checkedChange.emit({ data: [], isCheck: false  });
                    });
                }
            }
        }
    }


    private getFavoritData() {
        if (this.instance.personalConf) {
            const favData = this.instance.personalConf.favorite;
            const _data = (favData && favData[this.instance.localService.localeId]) ? favData[this.instance.localService.localeId] : [];
            return _data;
        }
        return [];
    }

    getFavoritIds() {
        return this.getFavoritData();
    }

    _loadFavoriteData(data = null) {
        const fdt = this.instance.favoritesComponentRef.instance as DataTableComponent;
        this.loadFavoriteDatatable(fdt, data);
        fdt.cd.markForCheck();
        this.instance.closeLoading();
    }

    // 加载收藏grid数据
    loadFavoritesData(res = null) {
        const favIds = this.getFavoritIds();
        switch (this.instance.displayType) {
            case LookupGridDisplayType.NavList:
            case LookupGridDisplayType.NavTreeList:
            case LookupGridDisplayType.List: {
                const fdt = this.instance.favoritesComponentRef.instance as DataTableComponent;
                if (this.instance.favoriteDataFrom === 'locale') {
                    if (res) {
                        this._loadFavoriteData(res.items);
                    } else {
                        // this.instance.httpMgr.getFavoriteData(favIds).subscribe(resData => {
                        //     if (resData) {
                        //         this._loadFavoriteData(resData.items);
                        //     }
                        //     this.instance.closeLoading();
                        // });
                    }
                } else {
                    const favData = this.getFavoritData();
                    this.loadFavoriteDatatable(fdt, res ? res.items : favData);
                }
                break;
            }
            case LookupGridDisplayType.TreeList: {
                if (this.instance.favoritesComponentRef && this.instance.favoritesComponentRef.instance instanceof TreeTableComponent) {
                    const ftt = this.instance.favoritesComponentRef.instance as TreeTableComponent;
                    this.bindFavTreetable(ftt);

                    if (this.instance.favoriteDataFrom === 'locale') {
                        if (res) {
                            this.loadFavoriteForTreeTable(res.items || [], ftt);
                        } else {
                            // this.instance.httpMgr.getFavoriteData(favIds).subscribe(resData => {
                            //     if (resData) {
                            //         const items = resData.items;
                            //         this.loadFavoriteForTreeTable(items, ftt);
                            //     }
                            //     this.instance.closeLoading();
                            // });
                        }
                    } else {
                        if (res) {
                            this.loadFavoriteForTreeTable(res.items, ftt);
                        }
                    }
                }
            }
        }
    }

    private loadFavoriteDatatable(fdt: DataTableComponent, data?: any) {
        if (data !== undefined) {
            this.instance.favoriteItems = data;
        }

        if (fdt.columns && !fdt.columns.length) {
            fdt.columns = this.instance.favoriteColumns;
        }

        fdt.loadData({
            total: 0,
            pageSize: 20,
            pageIndex: 1,
            data: this.instance.favoriteItems
        });


        this.instance.selectionMgr.selectCurrentValue();
        fdt.cd.detectChanges();
    }


    private bindFavTreetable(ftt: TreeTableComponent) {
        ftt.allColumnsTitle = this.instance.allColumnsTitle;
        ftt.idField = this.instance.idField;

        const columns = this.instance.gridOptions.columns.map(item => {
            const rtn: any = { ...item };
            if (item.field === FAVORITE_FIELD_NAME) {
                rtn.formatter = (v: any, data: any): any => {
                    const favids = this.getFavoritIds();
                    if (favids && favids.length) {
                        const index = favids.findIndex(el => el === data[this.instance.idField]);
                        if (index >= 0) {
                            return FavoriteIcon.delete;
                        }
                    }
                    return '';
                };
            }
            return rtn;
        });
        this.instance.favoriteColumns = columns;
        ftt.columns = columns;


        if (this.instance.gridOptions.treeInfo) {
            ftt.onlySelectLeaf = this.instance.gridOptions.treeInfo.onlySelectLeaf;
        }

        if (!ftt.singleSelect) {
            ftt.checkOnSelect = true;
            ftt.selectOnCheck = true;
            ftt.showCheckbox = true;

            // 启用多选后，同时启用级联选择
            // 启用多选后，同时启用级联选择
            if (this.instance.enableCascade) {
                this.instance.ttEventMgr.cascadeValueChanged(this.instance.cascadeStatus);
            } else {
                ftt.cascadeCheck = false;
                ftt.cascadeDown = false;
                ftt.cascadeUp = false;
            }
        }
    }

    initFavoriteTreeData(items) {
        const treeInfo = this.instance.gridOptions.treeInfo;

        if (treeInfo && !treeInfo['treeDataIsInit']) {
            if (treeInfo.layerType.toLowerCase() === 'pathcode') {
                items = this.instance.lookupUtils.makeTree(items, treeInfo);
            } else {
                items = this.instance.lookupUtils.makeTreeWithParentID(
                    items,
                    '',
                    `${treeInfo.dataField}.${treeInfo.parentField}`,
                    this.instance.idField
                );
            }
        }
        return this.instance.checkNodeCanBeSelect(items, true);
    }

    loadFavoriteForTreeTable(items, ftt: any) {
        items = this.initFavoriteTreeData(items);
        this.instance.favoriteItems = items;
        ftt.loadData(items);
        ftt.expandAll();
        this.instance.selectionMgr.selectCurrentValue();

        return items;
    }

    // 更新列表中的收藏数据标识
    updateFavoritesStatus(data: any[]) {

        if (!data || !this.instance.useFavorite) {
            return;
        }

        const favIds = this.getFavoritIds();

        if (favIds && favIds.length) {
            // 处理数据列表中的收藏数据标识
            if (this.instance.displayType !== LookupGridDisplayType.TreeList) {
                data.map(item => {
                    if (favIds && favIds.length && favIds.find(v => v === item[this.instance.idField])) {
                        item[FAVORITE_FIELD_NAME] = true;
                    }
                });
            } else {
                const _this = this.instance;
                (function each(_data) {
                    _data.forEach(item => {
                        if (favIds && favIds.length && favIds.find(v => v === item.data[_this.idField])) {
                            item.data[FAVORITE_FIELD_NAME] = true;
                        }
                        if (item.children && item.children.length > 0) {
                            each(item.children);
                        }
                    });
                })(data);
            }
        }
    }


    private _updateFavorites(value: any, action) {
        const localeID = this.instance.localService.localeId;
        this.instance.personalConf.favorite = this.instance.personalConf.favorite || {};
        const items = value.filter(n => !n['_addtional_']);
        const newVal = items.map(n => n[this.instance.idField]).filter(n => n !== null && n !== undefined);
        // const favIds = this.instance.personalConf.favorite[localeID] || [];
        this.instance.personalConf.favorite[localeID] = newVal;
        return newVal;
    }

    // 收藏数据管理
    private listenPersonalConfigHandler() {
        this.lookupSelectionSer.favoriteItems$.subscribe(n => {
            if (!this.instance.favoritesComponentRef) {
                return;
            }

            const { items, action } = n;
            const favids = this._updateFavorites(items, action);

            this.instance.httpMgr.submitFavoriteData(action);

            if (this.instance.displayType === LookupGridDisplayType.List || this.instance.displayType.includes('NAV')) {
                const dt = this.instance.favoritesComponentRef.instance as DataTableComponent;
                this.loadFavoriteDatatable(dt, items);
            } else if (this.instance.displayType === LookupGridDisplayType.TreeList) {
                const ftt = this.instance.favoritesComponentRef.instance as TreeTableComponent;
                // const favids = items.map(d => d.id);
                this.instance.showLoading();
                this.instance.httpMgr.getData({ favoriteIds: favids }, 'fav').subscribe(resData => {
                    if (resData) {
                        const _items = resData.items;
                        this.loadFavoriteForTreeTable(_items, ftt);
                    } else {
                        this.instance.favoriteItems = [];
                        ftt.loadData([]);
                    }
                    this.instance.closeLoading();
                });
            }
        });
    }

}