import {
    Component,
    EventEmitter,
    Input,
    OnDestroy,
    Output,
    ViewChild,
    Renderer2,
    ViewEncapsulation,
    QueryList,
} from '@angular/core';
import { Subject } from 'rxjs';

// modules
import { CommonModule } from '@angular/common';
import { HttpClientModule } from '@angular/common/http';
import { AngularSvgIconModule } from 'angular-svg-icon';
import { NgbModule, NgbPopover } from '@ng-bootstrap/ng-bootstrap';

// animations
import { showAnimation } from '../../animations/show.animation';
import { closeForm } from '../../animations/close-form.animation';

// pipes
import { FilterConditionsSetPipe } from './pipes/filter-conditions-set.pipe';
import { FilterConditionsClearPipe } from './pipes/filter-conditions-clear.pipe';
import { FilterPopoverConditionsPipe } from './pipes/filter-popover-conditions.pipe';
import { FilterConditionsUserBoxPipe } from './pipes/filter-conditions-user-box.pipe';
import { CaSvgPipe } from '../../pipes/ca-svg.pipe';

// enums
import { ToolbarFilterStringEnum } from '../ca-map/enums/toolbar-filter-string.enum';
import { FilterActionsStringEnum } from './enums/filter-actions-string.enum';

// models
import { ArrayStatus } from '../../models/array-status.model';
import { filterOutput } from '../../models/filter-output.model';
import { filterOutputWithParams } from '../../models/filter-output-params.model';
import { UserGroup } from './components/ca-user-filter/models/ca-user-group.model';

// components
import { CaStatusFilterComponent } from './components/ca-status-filter/ca-status-filter.component';
import { CaTimeFilterComponent } from './components/ca-time-filter/ca-time-filter.component';
import { CaDispatcherFilterComponent } from './components/ca-dispatcher-filter/ca-dispatcher-filter.component';
import { CaStateFilterComponent } from './components/ca-state-filter/ca-state-filter.component';
import { CaTruckTypeFilterComponent } from './components/ca-truck-type-filter/ca-truck-type-filter.component';
import { CaTrailerTypeFilterComponent } from './components/ca-trailer-type-filter/ca-trailer-type-filter.component';
import { CaPmFilterComponent } from './components/ca-pm-filter/ca-pm-filter.component';
import { CaUserFilterComponent } from './components/ca-user-filter/ca-user-filter.component';
import { CaAutoclosePopoverComponent } from '../ca-autoclose-popover/ca-autoclose-popover.component';
import { CaAppTooltipV2Component } from '../ca-app-tooltip-v2/ca-app-tooltip-v2.component';
import { CaViolationFilterComponent } from './components/ca-violation-filter/ca-violation-filter.component';
import { CaCollapsibleFilterComponent } from '../ca-collapsible-filter/ca-collapsible-filter.component';
import { CaTimeFilterDropdownComponent } from './components/ca-time-filter-dropdown/ca-time-filter-dropdown.component';

@Component({
    selector: 'app-ca-filter',
    templateUrl: './ca-filter.component.html',
    styleUrls: ['./ca-filter.component.scss'],
    imports: [
        // modules
        CommonModule,
        HttpClientModule,
        AngularSvgIconModule,
        NgbModule,
        // components
        CaStatusFilterComponent,
        CaTimeFilterComponent,
        CaDispatcherFilterComponent,
        CaStateFilterComponent,
        CaTruckTypeFilterComponent,
        CaTrailerTypeFilterComponent,
        CaPmFilterComponent,
        CaUserFilterComponent,
        CaViolationFilterComponent,
        CaAutoclosePopoverComponent,
        CaAppTooltipV2Component,
        CaCollapsibleFilterComponent,
        CaTimeFilterDropdownComponent,
        // pipes
        FilterConditionsSetPipe,
        FilterConditionsClearPipe,
        FilterConditionsUserBoxPipe,
        FilterPopoverConditionsPipe,
        CaSvgPipe,
    ],
    encapsulation: ViewEncapsulation.Emulated,
    animations: [showAnimation('showAnimation'), closeForm('closeForm')],
})
export class CaFilterComponent implements OnDestroy {
    @ViewChild('t2') t2!: NgbPopover;
    @ViewChild(CaAutoclosePopoverComponent)
    public autoClose!: CaAutoclosePopoverComponent;

    @ViewChild(CaStatusFilterComponent)
    public caStatusFilter!: CaStatusFilterComponent;

    @ViewChild(CaTimeFilterComponent)
    public caTimeFilter!: CaTimeFilterComponent;

    @ViewChild(CaTimeFilterDropdownComponent)
    public caTimeFilterDropdown!: CaTimeFilterDropdownComponent;

    @ViewChild(CaDispatcherFilterComponent)
    public caDispatcherFilter!: CaDispatcherFilterComponent;

    @ViewChild(CaStateFilterComponent)
    public caStateFilter!: CaStateFilterComponent;

    @ViewChild(CaTruckTypeFilterComponent)
    public caTruckTypeFilter!: CaTruckTypeFilterComponent;

    @ViewChild(CaTrailerTypeFilterComponent)
    public caTrailerTypeFilter!: CaTrailerTypeFilterComponent;

    @ViewChild(CaPmFilterComponent)
    public caPmFilter!: CaPmFilterComponent;

    @ViewChild(CaCollapsibleFilterComponent)
    public caCollapsibleFilter!: CaCollapsibleFilterComponent;

    @ViewChild(CaUserFilterComponent)
    public caUserFilter!: CaUserFilterComponent;

    @ViewChild(CaViolationFilterComponent)
    public caViolationFilter!: CaViolationFilterComponent;

    @Input() type!: string;
    @Input() isDisabled!: boolean;
    @Input() timeSubType: string = ToolbarFilterStringEnum.PAST;
    @Input() subType: string = ToolbarFilterStringEnum.PENDING_STATUS;
    @Input() unselectedUser!: ArrayStatus[];
    @Input() userGroup!: UserGroup[];
    @Input() loadStatusOptionsArray!: ArrayStatus[];
    @Input() truckTypeArray!: ArrayStatus[];
    @Input() trailerTypeArray!: ArrayStatus[];
    @Input() pmFilterArray!: ArrayStatus[];
    @Input() selectedTimeValue!: string;

    @Input() isRepairFilter: boolean = false;
    @Input() hasNoLeftIcon: boolean = false;
    @Input() hasLeftSideIcon: boolean = false;
    @Input() hasLargeLeftIcon: boolean = false;

    @Input() isMoneyFilter: boolean = true;
    @Input() isMilesFilter: boolean = false;
    @Input() isButtonFilter: boolean = false;
    @Input() isFuelType: boolean = false;
    @Input() isLoadType: boolean = true;
    @Input() isCollapsibleFilter: boolean = false;
    @Input() filterTitle!: string;
    @Input() icon!: string;

    @Input() usaStates!: ArrayStatus[];
    @Input() canadaStates!: ArrayStatus[];

    @Output() setFilter = new EventEmitter<
        filterOutput | filterOutputWithParams
    >();

    @Output() clearAll = new EventEmitter<
        filterOutput | filterOutputWithParams
    >();

    private destroy$ = new Subject<void>();
    public isSearchExpanded!: boolean;
    public isFilterActive: boolean = false;
    public selectedUser: ArrayStatus[] = [];
    public isAscendingSortOrder: boolean = true;
    public autoCloseComponent!: QueryList<CaAutoclosePopoverComponent>;
    public isHoverClosed: boolean = false;
    public isFilterHoveredOver: boolean = false;
    public isAnimated: boolean = false;
    public isFilterActiveColor: boolean = false;
    public filterCount: number = 0;
    public hasFilterCount: boolean = false;

    constructor(private renderer: Renderer2) {}

    public ngOnInit(): void {
        this.filterCount = this.getFilterCount();
        this.hasFilterCount = !this.isNotDropdown() && !!this.filterCount;
    }

    public getComponentInstance(): CaFilterComponent {
        return this;
    }

    public isNotDropdown(): boolean {
        return (
            this.type === ToolbarFilterStringEnum.MONEY_FILTER ||
            this.type === ToolbarFilterStringEnum.TIME_FILTER ||
            this.type === ToolbarFilterStringEnum.MILES_FILTER ||
            this.type === ToolbarFilterStringEnum.VIOLATION_FILTER
        );
    }

    public getFilterCount(): number {
        return (
            this.caPmFilter?.selectedPmFilterArray.length ||
            this.caStatusFilter?.selectedUser.length ||
            this.caTrailerTypeFilter?.selectedTrailerTypeArray.length ||
            this.caTruckTypeFilter?.selectedTruckTypeArray.length ||
            this.caDispatcherFilter?.selectedUser.length ||
            this.caStateFilter?.usaSelectedStates.length ||
            this.caStateFilter?.canadaSelectedStates.length
        );
    }

    public onFilterClose(): boolean {
        if (!this.isFilterActive) return false;
        this.isFilterActive = false;

        let mainElementHolder;

        if (!this.isButtonFilter) {
            if (this.type === ToolbarFilterStringEnum.TIME_FILTER)
                mainElementHolder = this.renderer.selectRootElement(
                    '.time-filter-holder',
                    true
                );
            else
                mainElementHolder = this.renderer.selectRootElement(
                    '.filter-holder',
                    true
                );
        }

        switch (this.type) {
            case ToolbarFilterStringEnum.STATUS_FILTER:
                if (this.caStatusFilter) this.caStatusFilter.onFilterClose();
                break;

            case ToolbarFilterStringEnum.TIME_FILTER:
                if (this.caTimeFilter) this.caTimeFilter.onFilterClose();
                break;

            case ToolbarFilterStringEnum.DISPATCHER_FILTER:
            case ToolbarFilterStringEnum.DRIVER_FILTER:
            case ToolbarFilterStringEnum.FUEL_STOP_FILTER:
            case ToolbarFilterStringEnum.BROKER_FILTER:
                if (this.caDispatcherFilter)
                    this.caDispatcherFilter.onFilterClose();
                break;

            case ToolbarFilterStringEnum.STATE_FILTER:
                if (this.caStateFilter) this.caStateFilter.onFilterClose();
                break;

            case ToolbarFilterStringEnum.TRUCK_TYPE_FILTER:
                if (this.caTruckTypeFilter)
                    this.caTruckTypeFilter.onFilterClose();
                break;

            case ToolbarFilterStringEnum.TRAILER_TYPE_FILTER:
                if (this.caTrailerTypeFilter)
                    this.caTrailerTypeFilter.onFilterClose();
                break;

            case ToolbarFilterStringEnum.PM_FILTER:
            case ToolbarFilterStringEnum.CATEGORY_REPAIR_FILTER:
            case ToolbarFilterStringEnum.FUEL_ITEM_FILTER:
            case ToolbarFilterStringEnum.DEPARTMENT_FILTER:
            case ToolbarFilterStringEnum.PARKING_FILTER:
            case ToolbarFilterStringEnum.TAG_FILTER:
            case ToolbarFilterStringEnum.ACTION_FILTER:
            case ToolbarFilterStringEnum.LABEL_FILTER:
                if (this.caPmFilter) this.caPmFilter.onFilterClose();
                break;

            case ToolbarFilterStringEnum.USER_FILTER:
            case ToolbarFilterStringEnum.MODULE_FILTER:
                if (this.caUserFilter) this.caUserFilter.onFilterClose();
                break;

            case ToolbarFilterStringEnum.VIOLATION_FILTER:
                if (this.caViolationFilter)
                    this.caViolationFilter.onFilterClose();
                break;

            case ToolbarFilterStringEnum.VACATION_FILTER:
                this.clearAll.emit({
                    action: ToolbarFilterStringEnum.CLEAR,
                    filterType: ToolbarFilterStringEnum.VACATION_FILTER,
                    vacation: false,
                });
                break;

            default:
                break;
        }

        return true;
    }

    public onFilterShown(): void {
        this.isFilterActive = true;
        this.isAnimated = true;

        if (this.type === ToolbarFilterStringEnum.VACATION_FILTER) {
            this.setFilter.emit({
                action: ToolbarFilterStringEnum.SET,
                filterType: ToolbarFilterStringEnum.VACATION_FILTER,
                vacation: true,
            });
        }
    }

    public sortItems(): void {
        switch (this.type) {
            case ToolbarFilterStringEnum.STATUS_FILTER:
                if (this.caStatusFilter) {
                    this.caStatusFilter.sortItems();
                    this.isAscendingSortOrder =
                        this.caStatusFilter.isAscendingSortOrder;
                }
                break;

            case ToolbarFilterStringEnum.DISPATCHER_FILTER:
            case ToolbarFilterStringEnum.DRIVER_FILTER:
            case ToolbarFilterStringEnum.FUEL_STOP_FILTER:
            case ToolbarFilterStringEnum.BROKER_FILTER:
                if (this.caDispatcherFilter) {
                    this.caDispatcherFilter.sortItems();
                    this.isAscendingSortOrder =
                        this.caDispatcherFilter.isAscendingSortOrder;
                }
                break;

            case ToolbarFilterStringEnum.TRUCK_TYPE_FILTER:
                if (this.caTruckTypeFilter) {
                    this.caTruckTypeFilter.sortItems();
                    this.isAscendingSortOrder =
                        this.caTruckTypeFilter.isAscendingSortOrder;
                }
                break;

            case ToolbarFilterStringEnum.TRAILER_TYPE_FILTER:
                if (this.caTrailerTypeFilter) {
                    this.caTrailerTypeFilter.sortItems();
                    this.isAscendingSortOrder =
                        this.caTrailerTypeFilter.isAscendingSortOrder;
                }
                break;

            case ToolbarFilterStringEnum.PM_FILTER:
            case ToolbarFilterStringEnum.CATEGORY_REPAIR_FILTER:
            case ToolbarFilterStringEnum.FUEL_ITEM_FILTER:
            case ToolbarFilterStringEnum.DEPARTMENT_FILTER:
            case ToolbarFilterStringEnum.PARKING_FILTER:
            case ToolbarFilterStringEnum.TAG_FILTER:
            case ToolbarFilterStringEnum.ACTION_FILTER:
            case ToolbarFilterStringEnum.LABEL_FILTER:
                if (this.caPmFilter) {
                    this.caPmFilter.sortItems();
                    this.isAscendingSortOrder =
                        this.caPmFilter.isAscendingSortOrder;
                }
                break;

            case ToolbarFilterStringEnum.USER_FILTER:
            case ToolbarFilterStringEnum.MODULE_FILTER:
                if (this.caUserFilter) {
                    this.caUserFilter.sortItems();
                    this.isAscendingSortOrder =
                        this.caUserFilter.isAscendingSortOrder;
                }
                break;

            default:
                this.isAscendingSortOrder = true;
                break;
        }
    }

    public showSearch(mod?: string): void {
        this.isSearchExpanded = !mod;
    }

    public setFilterValue(event: Event): void {
        let filterResult: filterOutput | filterOutputWithParams | any;
        this.isFilterActiveColor = true;

        if (this.isCollapsibleFilter && this.caCollapsibleFilter) {
            filterResult = this.caCollapsibleFilter.setFilterValue();
            this.setFilterEmit(filterResult);
            return;
        }

        switch (this.type) {
            case ToolbarFilterStringEnum.STATUS_FILTER:
                if (this.caStatusFilter)
                    filterResult = this.caStatusFilter.setFilterValue();
                break;

            case ToolbarFilterStringEnum.TIME_FILTER:
                if (this.caTimeFilter)
                    filterResult = this.caTimeFilter.setFilterValue(event);

                this.selectedTimeValue =
                    filterResult?.queryParams?.timeSelected;
                break;

            case ToolbarFilterStringEnum.TIME_FILTER_DROPDOWN:
                if (this.caTimeFilterDropdown)
                    filterResult =
                        this.caTimeFilterDropdown.setFilterValue(event);

                this.selectedTimeValue =
                    filterResult?.queryParams?.timeSelected;
                break;

            case ToolbarFilterStringEnum.DISPATCHER_FILTER:
            case ToolbarFilterStringEnum.DRIVER_FILTER:
            case ToolbarFilterStringEnum.FUEL_STOP_FILTER:
            case ToolbarFilterStringEnum.BROKER_FILTER:
                if (this.caDispatcherFilter)
                    filterResult =
                        this.caDispatcherFilter.setFilterValue(event);
                break;

            case ToolbarFilterStringEnum.STATE_FILTER:
                if (this.caStateFilter)
                    filterResult = this.caStateFilter.setFilterValue();
                break;

            case ToolbarFilterStringEnum.TRUCK_TYPE_FILTER:
                if (this.caTruckTypeFilter)
                    filterResult = this.caTruckTypeFilter.setFilterValue();
                break;

            case ToolbarFilterStringEnum.TRAILER_TYPE_FILTER:
                if (this.caTrailerTypeFilter)
                    filterResult = this.caTrailerTypeFilter.setFilterValue();
                break;

            case ToolbarFilterStringEnum.PM_FILTER:
            case ToolbarFilterStringEnum.CATEGORY_REPAIR_FILTER:
            case ToolbarFilterStringEnum.FUEL_ITEM_FILTER:
            case ToolbarFilterStringEnum.DEPARTMENT_FILTER:
            case ToolbarFilterStringEnum.PARKING_FILTER:
            case ToolbarFilterStringEnum.TAG_FILTER:
            case ToolbarFilterStringEnum.ACTION_FILTER:
            case ToolbarFilterStringEnum.LABEL_FILTER:
                if (this.caPmFilter)
                    filterResult = this.caPmFilter.setFilterValue();
                break;

            case ToolbarFilterStringEnum.USER_FILTER:
            case ToolbarFilterStringEnum.MODULE_FILTER:
                if (this.caUserFilter)
                    filterResult = this.caUserFilter.setFilterValue(event);
                break;

            case ToolbarFilterStringEnum.VIOLATION_FILTER:
                if (this.caViolationFilter)
                    filterResult = this.caViolationFilter.setFilterValue(event);
                break;

            default:
                const action = FilterActionsStringEnum.ACTION_CLEAR;
                const type = FilterActionsStringEnum.TYPE_UNKNOWN;
                const filterType = FilterActionsStringEnum.TYPE_UNKNOWN;
                const data = {
                    action,
                    type,
                    filterType,
                };
                filterResult = data;
                break;
        }

        if (filterResult) this.autoClose.closeCustomPopover();
        this.setFilterEmit(filterResult);
    }

    public setFilterEmit(
        data: filterOutput | filterOutputWithParams | undefined
    ): void {
        if (this.setFilter) this.setFilter.emit(data);
    }

    public clearAllValues(event?: Event): void {
        let filterResult: filterOutput | filterOutputWithParams | undefined;
        this.isFilterActiveColor = false;
        this.isHoverClosed = false;

        switch (this.type) {
            case ToolbarFilterStringEnum.STATUS_FILTER:
                if (this.caStatusFilter)
                    filterResult = this.caStatusFilter.clearAll(event);
                break;

            case ToolbarFilterStringEnum.TIME_FILTER:
                if (this.caTimeFilter)
                    filterResult = this.caTimeFilter.clearAll(event);
                break;

            case ToolbarFilterStringEnum.DISPATCHER_FILTER:
            case ToolbarFilterStringEnum.DRIVER_FILTER:
            case ToolbarFilterStringEnum.FUEL_STOP_FILTER:
            case ToolbarFilterStringEnum.BROKER_FILTER:
                if (this.caDispatcherFilter)
                    filterResult = this.caDispatcherFilter.clearAll(event);
                break;

            case ToolbarFilterStringEnum.STATE_FILTER:
                if (this.caStateFilter)
                    filterResult = this.caStateFilter.clearAll(event);
                break;

            case ToolbarFilterStringEnum.TRUCK_TYPE_FILTER:
                if (this.caTruckTypeFilter)
                    filterResult = this.caTruckTypeFilter.clearAll(event);
                break;

            case ToolbarFilterStringEnum.TRAILER_TYPE_FILTER:
                if (this.caTrailerTypeFilter)
                    filterResult = this.caTrailerTypeFilter.clearAll(event);
                break;

            case ToolbarFilterStringEnum.PM_FILTER:
            case ToolbarFilterStringEnum.CATEGORY_REPAIR_FILTER:
            case ToolbarFilterStringEnum.FUEL_ITEM_FILTER:
            case ToolbarFilterStringEnum.DEPARTMENT_FILTER:
            case ToolbarFilterStringEnum.PARKING_FILTER:
            case ToolbarFilterStringEnum.TAG_FILTER:
            case ToolbarFilterStringEnum.ACTION_FILTER:
            case ToolbarFilterStringEnum.LABEL_FILTER:
                if (this.caPmFilter)
                    filterResult = this.caPmFilter.clearAll(event);
                break;

            case ToolbarFilterStringEnum.USER_FILTER:
            case ToolbarFilterStringEnum.MODULE_FILTER:
                if (this.caUserFilter)
                    filterResult = this.caUserFilter.clearAll(event);
                break;

            case ToolbarFilterStringEnum.VIOLATION_FILTER:
                if (this.caViolationFilter)
                    filterResult = this.caViolationFilter.clearAll(event);
                break;

            default:
                const action = FilterActionsStringEnum.ACTION_CLEAR;
                const type = FilterActionsStringEnum.TYPE_UNKNOWN;
                const filterType = FilterActionsStringEnum.TYPE_UNKNOWN;
                const data = {
                    action,
                    type,
                    filterType,
                };
                filterResult = data;
                break;
        }

        if (filterResult) this.autoClose.closeCustomPopover();
        this.clearAllValuesEmit(filterResult);
    }

    public clearAllValuesEmit(
        data: filterOutput | filterOutputWithParams | undefined
    ): void {
        if (this.clearAll) this.clearAll.emit(data);
    }

    ngOnDestroy(): void {
        this.destroy$.next();
        this.destroy$.complete();
    }
}