/*
* @Author: 疯狂秀才(Lucas Huang)
* @Date: 2018-12-14 14:40:48
 * @LastEditors: 疯狂秀才(Lucas Huang)
 * @LastEditTime: 2019-09-25 18:10:29
* @Company: Inspur
* @Version: v0.0.1
*/

import { Component, OnInit, ViewChild, ViewContainerRef, EventEmitter, Output,
    ComponentFactoryResolver, ComponentRef, ChangeDetectorRef, Injector, ReflectiveInjector
} from '@angular/core';
import { Observable, of } from 'rxjs';

import { DataTableComponent } from '@farris/ui-datatable';
import { TreeTableComponent } from '@farris/ui-treetable';

import { LookupGridOptions, LookupGridResult } from './lookup-grid-options';
import { LookupGridComponent } from './lookup-grid.component';

@Component({
    selector: 'lookup-left',
    templateUrl: './lookup-left.component.html'
})

export class LookupLeftComponent implements OnInit {

    cmpRef: ComponentRef<any>;
    navOptions: LookupGridOptions;
    lookupCmp: LookupGridComponent;


    @ViewChild('container', {read: ViewContainerRef}) cmpContainer: ViewContainerRef;
    @Output() selected = new EventEmitter<{ data: any}>();
    @Output() unselected = new EventEmitter();
    @Output() search = new EventEmitter<{ field: string, value: string }>();
    @Output() pageChanged = new EventEmitter<{ pageInfo: {pageIndex: number, pageSize: number}, search: {field: string, value: string} }>();

    private _searchState = null;
    private allData = null;

    constructor(private cfr: ComponentFactoryResolver, private cd: ChangeDetectorRef) { }

    ngOnInit() {
    }

    createComponent(): Observable<any> {
        let dtFac = null;
        if (!this.isTreeList()) {
            dtFac = this.cfr.resolveComponentFactory(DataTableComponent);
        } else {
            dtFac = this.cfr.resolveComponentFactory(TreeTableComponent);
        }
        this.navOptions['keepSelect'] = false;
        // 左侧查询过滤条，隐藏掉；
        this.navOptions['showFilterBar'] = true;
        // if (this.navOptions.width) {
        //     this.navOptions.width = this.navOptions.width - 2;
        // }

        this.navOptions.width = this.lookupCmp.leftPanelWidth - 2;

        // const injector: Injector = ReflectiveInjector.resolveAndCreate([
        //     { provide: DataTableService, useFactory: () => { new DataTableService()}}
        // ]);

        this.cmpRef = this.cmpContainer.createComponent(dtFac);

        if (!this.isTreeList()) {
            this.navOptions['fill'] = true;
            this.cmpRef.instance.maxSize = 5;
            this.cmpRef.instance.fill = true;
        } else {
            this.navOptions['fit'] = true;
        }
        // this.cmpRef.instance.fit = true;

        if (this.navOptions.pageInfo) {
            if (this.navOptions.pageInfo.pageList) {
                this.navOptions.pageList = this.navOptions.pageInfo.pageList;
            }
            this.navOptions.pagination = this.navOptions.pageInfo.enablePager;
            this.navOptions.pageIndex = this.navOptions.pageInfo.pageIndex;
            this.navOptions.pageSize = this.navOptions.pageInfo.pageSize;
        } else {
            this.navOptions.pagination = false;
        }

        Object.assign(this.cmpRef.instance, this.navOptions);

        this.loadData();
        return of(this.cmpRef);
    }

    update() {
        this.cd.detectChanges();
    }

    resize(size?: {width: number, height: number}) {
        if (size) {
            size.width = size.width - 2;
            // if (this.cmpRef.instance instanceof TreeTableComponent) {
            //     size.height += 46;
            // }
            this.cmpRef.instance.resize(size);
        }
    }

    isTreeList() {
        return this.navOptions.displayType.toLowerCase() === 'treelist';
    }

    private selectLeftDataTableRow(items: any, dt: DataTableComponent) {
        if (items && items.length) {
            let item = null;
            if (this.lookupCmp.navSelectedIds) {
                item = items.find(n => n[dt.idField] == this.lookupCmp.navSelectedIds);
            } else {
                if (this.lookupCmp.selectFirstInNav) {
                    item = items[0];
                }
            }

            if (item) {
                dt.dtBody.selectedRowIndex = -1;
                dt.dtBody.selectedRow('', 0, item);
            }
        }
    }

    private closeLoading() {
        this.lookupCmp.closeLoading();
    }

    private initDataTable(dt: DataTableComponent) {
        dt.loadData({
            pageSize: this.navOptions.pageSize,
            pageIndex: this.navOptions.pageIndex,
            total: this.navOptions.total,
            data: this.navOptions.items,
        });

        dt.resize({ width: 320, height: this.navOptions.height});
        // 行选中
        dt.selectedRow.subscribe(d => {
            this.selected.emit({ data: d.data });
        });

        dt.unSelectRow.subscribe(d => {
            this.selected.emit(null);
        });

        const p = { pageInfo: { pageIndex: 1, pageSize: this.navOptions.pageSize }, search: '' };


        const loadTableData = {
            next: (data: LookupGridResult) => {
                this.closeLoading();
                dataTableReLoad(data);
            },
            error: (err) => {
                this.closeLoading();
            }
        };

        // 查询
        dt.search.subscribe( searchData => {
            this._searchState = searchData;
            this.search.emit(searchData);
            p.search = searchData;
            p.pageInfo.pageSize = dt.pageSize;
            this.lookupCmp.navigationFilter = null;
            this.lookupCmp.httpMgr.getData(p, 'navsearch').subscribe(loadTableData);
        });

        const dataTableReLoad = (data) => {
            dt.loadData({
                pageSize: data.pageInfo.pageSize,
                pageIndex: data.pageInfo.pageIndex,
                total: data.total,
                data: data.items,
            });

            this.selectLeftDataTableRow(data.items, dt);
            dt.cd.markForCheck();
        };

        // 分页
        dt.pageChanged.subscribe(d => {
            this.pageChanged.emit(d);
            this.lookupCmp.navigationFilter = null;
            this.lookupCmp.httpMgr.getData(d, 'navsearch').subscribe(loadTableData);
        });

        dt.pageSizeChanged.subscribe((e) => {
            this.lookupCmp.navigationFilter = null;
            this.lookupCmp.httpMgr.getData(e, 'navsearch').subscribe(loadTableData);
        });

        dt.columnSorted.subscribe( (sort: {sortName: string, sortOrder: any}) => {
            const { sortName, sortOrder } = {...sort};
            this.lookupCmp.navigationFilter = null;
            const param = Object.assign({ sortName, sortOrder }, this._searchState);
            this.lookupCmp.httpMgr.getData(param, 'navsearch').subscribe(loadTableData);
        });

        dt.clearSearchValue.subscribe( () => {
            this._searchState = null;
        });

        this.selectLeftDataTableRow(this.navOptions.items, dt);
    }

    private initTreeTable(tt: TreeTableComponent) {
        tt.virtualized = true;
        tt.nodeSelected.subscribe(d => {
            this.selected.emit({data: d.node.data});
        });

        tt.nodeUnSelect.subscribe(d => {
            this.selected.emit(null);
        });

        tt.fixedHeader = true;

        // tt.fit = true;
        this.lookupCmp.treeNodeHelper.updateTreeNodeExpanded(this.navOptions.items, this.navOptions.treeInfo);

        tt.loadDataType = this.navOptions.treeInfo.loadDataType;
        // 检查完整树过滤条件 By Lucas 20200302
        this.navOptions.items = this.lookupCmp.checkNodeCanBeSelect(this.navOptions.items, this.navOptions.treeInfo.loadDataType === 'all');
        tt.loadData(this.navOptions.items);

        if (this.lookupCmp.navSelectedIds) {
            tt.selectNode(this.lookupCmp.navSelectedIds);
        } else if (this.lookupCmp.selectFirstInNav) {
            tt.selectFirstNode();
        }

        this.allData = this.navOptions.items;

        const loadTreeData = {
            next: (resData: any) => {
                this.closeLoading();
                tt.clearAll();
                const items = this.lookupCmp.checkNodeCanBeSelect(resData.items, this.navOptions.treeInfo.loadDataType === 'all');
                tt.loadData(items);
                tt.resize();
            },
            error: (err) => {
                this.closeLoading();
            }
        };


        tt.search.subscribe(search => {
            this._searchState = search;
            this.lookupCmp.navigationFilter = null;
            this.lookupCmp.httpMgr.getData({ search }, 'navsearch').subscribe(loadTreeData);
        });

        tt.columnSorted.subscribe( (sort: {sortName: string, sortOrder: any}) => {
            this.lookupCmp.navigationFilter = null;
            if (tt.loadDataType === 'all') {
                tt.clientSort();
            } else {
                const { sortName, sortOrder } = {...sort};

                const param = Object.assign({ sortName, sortOrder }, this._searchState);
                this.lookupCmp.httpMgr.getData(param, 'nav').subscribe(loadTreeData);
            }
        });

        tt.clearSearchValue.subscribe( () => {
            this._searchState = null;
            tt.loadData(this.allData);
        });


        tt.expand.subscribe((tn: any) => {
            this.onNodeExpanded(tn, tt);
        });
    }


    private onNodeExpanded(tn: any, tt) {
        if (tn.leaf) {
            return;
        }
        if (!tn.children || !tn.children.length) {
            const treeInfo = this.navOptions.treeInfo;
            if (this.navOptions.treeInfo.loadDataType === 'async') {
                let parentPath = '';
                let parentLayer = -1;
                const { field = '*', value = '' } = {
                    ...tt.searchData
                };

                tn['showLoading'] = true;
                tt.detectChanges();
                if (treeInfo.layerType === 'parentId') {
                    // 父ID加载方式
                    parentPath = tn['id'];
                } else {
                    const treeInfoField = treeInfo.dataField;
                    if (treeInfoField) {
                        parentPath = tn.data[treeInfoField][treeInfo.pathField];
                        parentLayer = tn.data[treeInfoField][treeInfo.layerField];
                    } else {
                        console.log('未找到分级信息。');
                    }
                }

                if (!this.lookupCmp.uri) {
                    this.lookupCmp.expandTreeNode.emit({
                        instance: tt, node: tn,
                        parentIdOrPath: parentPath, parentLayer, search: { value, field }
                    });

                    return;
                }
                this.getChildren(
                    parentPath, parentLayer, {searchField: field === '*' ? '*' : field, searchValue: value}, tt
                ).subscribe(data => {
                    if (tt) {
                        if (tn && data.items && data.items.length) {
                            tt.appendChildren(data.items, tn);
                        }
                        tn['showLoading'] = false;
                        tt.detectChanges();
                    }
                });
            }
        }
    }

    private getChildren( parentPath, parentLayer, searchData: { searchField: string; searchValue: string }, tt ): Observable<any> {
        const uri = this.lookupCmp.gridOptions.uri;
        const search = { parentLayer, category: 'nav', ...searchData };
        if (this.navOptions.treeInfo.layerType === 'parentId') {
            search['parentId'] = parentPath;
        } else {
            search['parentPath'] = parentPath;
        }

        const param = {
            searchValue: JSON.stringify(search),
            customData: this.lookupCmp.customData,
            enableFullTree: false,
            loadTreeDataType: 'layerload'
        };

        if (this.lookupCmp.helpId) {
            param['helpId'] = this.lookupCmp.helpId;
        }

        if (tt && tt.sortName) {
            Object.assign(param, {
                sortName: tt.sortName,
                sortOrder: tt.sortOrder
            });
        }

        return this.lookupCmp.http.getData(uri , param);
    }


    loadData() {
        this.cmpRef.instance.allColumnsTitle = this.lookupCmp.allColumnsTitle;
        if (!this.isTreeList()) {
            const dt = this.cmpRef.instance as DataTableComponent;
            this.initDataTable(dt);
        } else {
            const tt = this.cmpRef.instance as TreeTableComponent;
            this.initTreeTable(tt);
        }
    }
}