import { Injectable } from '@angular/core';
import { Observable, Subject } from 'rxjs';
import { flatten } from 'lodash-es';
import { RowNode, TreeNode } from './types/treenode';
import { TreeTableColumn } from './types/treetable-column';

@Injectable()
export class TreetableService {

    private selectionSource = new Subject();
    private dblClickSource = new Subject();
    private changeCheckboxStatus = new Subject<RowNode>();
    private removeNode = new Subject<RowNode>();
    private insertNode = new Subject<TreeNode>();
    private updateNode = new Subject<RowNode>();


    selectionSource$: Observable<any> = this.selectionSource.asObservable();
    dblClickSource$: Observable<any> = this.dblClickSource.asObservable();
    changeCheckboxStatus$: Observable<RowNode> = this.changeCheckboxStatus.asObservable();
    insertNode$: Observable<TreeNode> = this.insertNode.asObservable();
    removeNode$: Observable<RowNode> = this.removeNode.asObservable();
    updateNode$: Observable<RowNode> = this.updateNode.asObservable();

    onSelectionChange(selected?: TreeNode[]) {
        this.selectionSource.next(selected);
    }

    onDblClick(rowNode: RowNode) {
        this.dblClickSource.next(rowNode);
    }

    onChangeCheckboxStatus(rowNode: RowNode) {
        this.changeCheckboxStatus.next(rowNode);
    }

    onInsert(treeNode: TreeNode, parent?: TreeNode) {
        this.insertNode.next(treeNode);
    }

    onRemove(rowNode: RowNode) {
        this.removeNode.next(rowNode);
    }

    onUpdate(rowNode: RowNode) {
        this.updateNode.next(rowNode);
    }

    columnIsVisible(col, tt) {
        if (col.visible === undefined) {
            return true;
        }
        if (typeof col.visible === 'function') {
            return col.visible(tt);
        }

        return col.visible;
    }

    checkColumnsForGroupHeader(columns: any, tt: any) {
        let _columns = [];
        if (columns && columns.length) {
            _columns = this.getDataColumns(columns);
        }
        return {
            columns: _columns
        };
    }


    private getDataFields(cols, length) {
        let i = 0;
        let j = 0;
        cols.forEach(n => {
            const colspan = n.colspan || 1;
            if (i + colspan <= length) {
                i += colspan;
                j++;
            }
        });
        return cols.splice(0, j);
    }


    private getDataColumns(cols) {
        if (!cols || !cols.length) {
            return [];
        }

        let fields = [];
        for (let i = 0; i < cols.length; i++) {
            let _cols = cols[i];
            if (cols[i] && !cols[i].length) {
                _cols = [...fields];
                fields = [];
            }
            _cols.forEach(n => {
                if (!n.field && n.colspan && n.colspan > 1) {
                    this.getDataFields(cols[i + 1], n.colspan).forEach(d => {
                        if (!fields.includes(f => f.field === d.field)) {
                            fields.push(d);
                        }
                    });
                } else {
                    if (!fields.includes(f => f.field === n.field)) {
                        fields.push(n);
                    }
                }
            });
        }
        return fields.filter(n => !n.colspan || n.colspan === 1);
    }

}