import { OnInit, Component, EventEmitter, Injector, Output, ViewChild } from '@angular/core';
import { AppComponentBase } from '@shared/common/app-component-base';
import { HtmlHelper } from '@shared/helpers/HtmlHelper';
import { ListResultDtoOfOrganizationUnitDto, MoveOrganizationUnitInput, OrganizationUnitDto, OrganizationUnitServiceProxy, FleetsServiceProxy, FleetDto, ListResultDtoOfFleetDto } from '@shared/service-proxies/service-proxies';
import * as _ from 'lodash';
import { Observable } from 'rxjs';
import { catchError } from 'rxjs/operators';

import { TreeNode, MenuItem } from 'primeng/api';

import { ArrayToTreeConverterService } from '@shared/utils/array-to-tree-converter.service';
import { TreeDataHelperService } from '@shared/utils/tree-data-helper.service';
import { EntityTypeHistoryModalComponent } from '@app/shared/common/entityHistory/entity-type-history-modal.component';
import { IBasicOrganizationUnitInfo } from '@app/admin/organization-units/basic-organization-unit-info';
import { CreateOrEditUnitModalComponent } from '@app/admin/organization-units/create-or-edit-unit-modal.component';
import { IUsersWithOrganizationUnit } from '@app/admin/organization-units/users-with-organization-unit';
import { IUserWithOrganizationUnit } from '@app/admin/organization-units/user-with-organization-unit';
import { IRolesWithOrganizationUnit } from '@app/admin/organization-units/roles-with-organization-unit';
import { IRoleWithOrganizationUnit } from '@app/admin/organization-units/role-with-organization-unit';
import { IFleetUnitInfo } from './fleets-unit-info';
import { CreateOrEditFleetModalComponent } from './create-or-edit-fleet-modal.component';
import { IVehiclesWithFleet } from './vehicles-with-fleet.component';
import { IVehicleWithFleet } from './vehicle-with-fleet.component';
import { IDriversWithFleet } from './drivers-with-fleet.component';
import { IDriverWithFleet } from './driver-with-fleet.component';
import { IRatesWithFleet } from './rates-with-fleet.component';
import { IRateWithFleet } from './rate-with-fleet.component';

export interface IFleetOnTree extends IFleetUnitInfo {
    id: number;
    parent: string | number;
    code: string;
    displayName: string;
    memberCount: number;
    roleCount: number;
    text: string;
    state: any;
}

@Component({
    selector: 'fleets-tree',
    templateUrl: './fleets-tree.component.html'
})
export class FleetsTreeComponent extends AppComponentBase implements OnInit {

    @Output() ouSelected = new EventEmitter<IFleetUnitInfo>();

    // @ViewChild('createOrEditOrganizationUnitModal', {static: true}) createOrEditOrganizationUnitModal: CreateOrEditUnitModalComponent;
    // @ViewChild('entityTypeHistoryModal', {static: true}) entityTypeHistoryModal: EntityTypeHistoryModalComponent;
    @ViewChild('createOrEditFleetModal', { static: true }) createOrEditFleetModal: CreateOrEditFleetModalComponent;
    @ViewChild('entityTypeHistoryModal', { static: true }) entityTypeHistoryModal: EntityTypeHistoryModalComponent;
    _entityTypeFullName = 'SprintTek.Shipping.Fleets.Fleet';
    entityHistoryEnabled = false;
    

    treeData: any;
     selectedOu: TreeNode;
    ouContextMenuItems: MenuItem[];
    canManageOrganizationUnits = false;
    fleetsList : any;
    

    constructor(
        injector: Injector,
        private _organizationUnitService: OrganizationUnitServiceProxy,
        private _arrayToTreeConverterService: ArrayToTreeConverterService,
        private _treeDataHelperService: TreeDataHelperService,
        private _fleetsServiceProxy: FleetsServiceProxy,
    ) {
        super(injector);
    }

    totalUnitCount = 0;

    ngOnInit(): void {
        this.canManageOrganizationUnits = this.isGranted('Pages.Administration.OrganizationUnits.ManageOrganizationTree');
        this.setIsEntityHistoryEnabled();
        this.ouContextMenuItems = this.getContextMenuItems();
        this.getTreeDataFromServer();
        
    }

    nodeSelect(event) {
        this.ouSelected.emit(<IFleetUnitInfo>{
            id: event.node.data.id,
            displayName: event.node.data.name
        });
    }

    reload(): void {
        this.getTreeDataFromServer();
    }

    private getTreeDataFromServer(): void {
        let self = this;
        self.spinnerService.show();
        self._fleetsServiceProxy.getAllFleets(undefined, undefined, undefined, undefined, undefined).subscribe((result: ListResultDtoOfFleetDto)  => {
            self.totalUnitCount = result.items.length;
            this.treeData = this._arrayToTreeConverterService.createTree(result.items,
                'parentId',
                'id',
                null,
                'children',
                [
                    {
                        target: 'label',
                        targetFunction(item) {
                            return item.name;
                        }
                    }, {
                        target: 'expandedIcon',
                        value: 'fa fa-folder-open m--font-warning'
                    },
                    {
                        target: 'collapsedIcon',
                        value: 'fa fa-folder m--font-warning'
                    },
                    {
                        target: 'selectable',
                        value: true
                    },
                    {
                        target: 'driverCount',
                        targetFunction(item) {
                            return item.driverCount;
                        }
                    },
                    {
                        target: 'vehicleCount',
                        targetFunction(item) {
                            return item.vehicleCount;
                        }
                    },
                    {
                        target: 'rateCount',
                        targetFunction(item) {
                            return item.rateCount;
                        }
                    },
                    {
                        target: 'mileageMultiplier',
                        targetFunction(item) {
                            return item.mileageMultiplier;
                        }
                    },
                ]);
                self.spinnerService.hide();
        });
    }

    private getContextMenuItems(): any[] {

        const canManageOrganizationTree = this.isGranted('Pages.Administration.OrganizationUnits.ManageOrganizationTree');
        let items = [
            {
                label: this.l('Edit'),
                disabled: !canManageOrganizationTree,
                command: (event) => {
                    this.createOrEditFleetModal.showModal({
                        id: this.selectedOu.data.id,
                        name: this.selectedOu.data.name,
                        mileageMultiplier: this.selectedOu.data.mileageMultiplier
                    });
                }
            },
            {
                label: this.l('Delete'),
                disabled: !canManageOrganizationTree,
                command: () => {
                    this.message.confirm(
                        '','Are you sure?',
                        (isConfirmed) => {
                            if (isConfirmed) {
                                this._fleetsServiceProxy.delete(this.selectedOu.data.id)
                                    .subscribe(() => {
                                        this.reload();
                                        this.notify.success(this.l('SuccessfullyDeleted'));
                                    });
                            }
                        }
                    );
                }
            },
            {
                label: this.l('History'),
                disabled: !this.entityHistoryEnabled,
                command: (event) => {
                    this.showHistory(this.selectedOu.data);
                }
            },
        ];
        return items;
    }

    rateAdded(data: IRatesWithFleet): void {
        this.incrementRateCount(data.ouId, data.rateIds.length);
    }

    rateRemoved(data: IRateWithFleet): void {
        this.incrementRateCount(data.ouId, -1);
    }

    incrementRateCount(ouId: number, incrementAmount: number): void {
        let item = this._treeDataHelperService.findNode(this.treeData, { data: { id: ouId } });
        item.data.rateCount += incrementAmount;
        item.rateCount = item.data.rateCount;
    }

    driverAdded(data: IDriversWithFleet): void {
        this.incrementDriverCount(data.ouId, data.userIds.length);
    }

    driverRemoved(data: IDriverWithFleet): void {
        this.incrementDriverCount(data.ouId, -1);
    }

    incrementDriverCount(ouId: number, incrementAmount: number): void {
        let item = this._treeDataHelperService.findNode(this.treeData, { data: { id: ouId } });
        item.data.driverCount += incrementAmount;
        item.driverCount = item.data.driverCount;
    }

    vehicleAdded(data: IVehiclesWithFleet): void {
        this.incrementVehicleCount(data.ouId, data.vehicleIds.length);
    }

    vehicleRemoved(data: IVehicleWithFleet): void {
        this.incrementVehicleCount(data.ouId, -1);
    }

    incrementVehicleCount(ouId: number, incrementAmount: number): void {
        let item = this._treeDataHelperService.findNode(this.treeData, { data: { id: ouId } });
        item.data.vehicleCount += incrementAmount;
        item.vehicleCount = item.data.vehicleCount;
    }
    addFleet(): void{
        this.createOrEditFleetModal.showModal({
            id: null,
            name: null
        });
    }

    private setIsEntityHistoryEnabled(): void {
        let customSettings = (abp as any).custom;
        this.entityHistoryEnabled = customSettings.EntityHistory && customSettings.EntityHistory.isEnabled && _.filter(customSettings.EntityHistory.enabledEntities, entityType => entityType === this._entityTypeFullName).length === 1;
    }

    showHistory(role: FleetDto): void {
        this.entityTypeHistoryModal.show({
            entityId: role.id.toString(),
            entityTypeFullName: this._entityTypeFullName,
            entityTypeDescription: "Fleet - " +role.name
        });
    }
}