import { ArrayStatus } from '../../../../models/array-status.model';

// models
import { UserGroup } from '../../components/ca-user-filter/models/ca-user-group.model';
import { UserData } from '../../components/ca-user-filter/models/ca-user-data.model';

// routes
import { CaFiltersSvgRoutes } from '../svg-routes/ca-filters-svg-routes';
import { UntypedFormGroup } from '@angular/forms';

export class FilterHelper {
  static sortItems(
    sortedFilterArray: ArrayStatus[],
    sortedSelectedFilterArray: ArrayStatus[],
    isAscendingSortOrder: boolean
  ): {
    sortedFilterArray: ArrayStatus[];
    sortedSelectedFilterArray: ArrayStatus[];
    isAscendingSortOrder: boolean;
  } {
    sortedFilterArray.sort((a, b) => {
      if (isAscendingSortOrder) {
        return a.name!.localeCompare(b.name!);
      } else {
        return b.name!.localeCompare(a.name!);
      }
    });

    sortedSelectedFilterArray.sort((a, b) => {
      if (isAscendingSortOrder) {
        return a.name!.localeCompare(b.name!);
      } else {
        return b.name!.localeCompare(a.name!);
      }
    });

    isAscendingSortOrder = !isAscendingSortOrder;

    return {
      sortedFilterArray,
      sortedSelectedFilterArray,
      isAscendingSortOrder,
    };
  }

  static sortItemsCount(
    sortedFilterArray: ArrayStatus[],
    sortedSelectedFilterArray: ArrayStatus[],
    isAscendingSortOrder: boolean
  ): {
    sortedFilterArray: ArrayStatus[];
    sortedSelectedFilterArray: ArrayStatus[];
    isAscendingSortOrder: boolean;
  } {
    sortedFilterArray.sort((a, b) => {
      if (isAscendingSortOrder) {
        return a.count! - b.count!;
      } else {
        return b.count! - a.count!;
      }
    });

    sortedSelectedFilterArray.sort((a, b) => {
      if (isAscendingSortOrder) {
        return a.count! - b.count!;
      } else {
        return b.count! - a.count!;
      }
    });

    isAscendingSortOrder = !isAscendingSortOrder;

    return {
      sortedFilterArray,
      sortedSelectedFilterArray,
      isAscendingSortOrder,
    };
  }

  static sortGroupItemsCount(
    sortedFilterArray: UserGroup[],
    sortedSelectedFilterArray: UserGroup[],
    isAscendingSortOrder: boolean
  ): {
    sortedFilterArray: UserGroup[];
    sortedSelectedFilterArray: UserGroup[];
    isAscendingSortOrder: boolean;
  } {
    sortedFilterArray.forEach((group) => {
      group.items.sort((a: UserData, b: UserData) => {
        if (isAscendingSortOrder) {
          return a.count! - b.count!;
        } else {
          return b.count! - a.count!;
        }
      });

      group.items.sort((a: UserData, b: UserData) => {
        if (isAscendingSortOrder) {
          return a.count! - b.count!;
        } else {
          return b.count! - a.count!;
        }
      });
    });

    isAscendingSortOrder = !isAscendingSortOrder;

    return {
      sortedFilterArray,
      sortedSelectedFilterArray,
      isAscendingSortOrder,
    };
  }

  static getInitials(name: string | undefined) {
    if (name === undefined) return '';
    const [firstName, lastName] = name.trim().split(' ');
    return (firstName?.[0] || '') + (lastName?.[0] || '').toUpperCase();
  }

  static addOrRemoveFromGroup(
    addOrRemove: 'add' | 'remove',
    groupArray: UserGroup[],
    item: UserData,
    indx: number,
    indx2: number
  ) {
    const id = item.id;
    const newGroupArray: UserGroup[] = [];

    groupArray.forEach((group, groupIndex) => {
      newGroupArray.push({
        ...group,
        items: group.items.map((item, itemIndex) => {
          return item.id === id || (groupIndex === indx && itemIndex === indx2)
            ? { ...item, isSelected: addOrRemove === 'add' || undefined }
            : item;
        }),
      });
    });

    groupArray = newGroupArray;

    const unselectedVisibleCount = groupArray.reduce(
      (count, group) =>
        count + group.items.filter((item) => !item.isSelected).length,
      0
    );

    let hasSelectedUsers = false;

    for (const group of groupArray) {
      if (group.items.some((item: UserData) => item.isSelected)) {
        hasSelectedUsers = true;
        break;
      } else hasSelectedUsers = false;
    }

    return { hasSelectedUsers, unselectedVisibleCount, groupArray };
  }

  static checkFilterActiveValue(
    filterArray: ArrayStatus[],
    selectedFilterArray: ArrayStatus[],
    isButtonAvailable: boolean
  ): {
    isButtonAvailable: boolean;
  } {
    const array1 = [...selectedFilterArray];
    const array2 = [...filterArray];

    array1.sort((a, b) => {
      return a.id! - b.id!;
    });

    array2.sort((a, b) => {
      return a.id! - b.id!;
    });

    const stringfy1 = JSON.stringify(array1);
    const stringfy2 = JSON.stringify(array2);

    if (stringfy1 === stringfy2) {
      isButtonAvailable = false;
    } else {
      isButtonAvailable = true;
    }

    return { isButtonAvailable };
  }

  static checkGroupFilterActiveValue(
    filterArray: UserGroup[],
    isButtonAvailable: boolean
  ): {
    isButtonAvailable: boolean;
  } {
    const array = [...filterArray];

    array.forEach((group) => {
      group.items.sort((a: UserData, b: UserData) => {
        return a.id! - b.id!;
      });
    });

    return { isButtonAvailable };
  }

  static getSvgPath(propertyName: keyof typeof CaFiltersSvgRoutes): string {
    return CaFiltersSvgRoutes[propertyName] as string;
  }

  static handleGroupFilterClose(
    filterArray: UserGroup[],
    selectedFilterArray: UserGroup[],
    removeFunction: (item: UserData, index: number, index2: number) => void,
    addFunction: (item: UserData, index: number, index2: number) => void
  ) {
    filterArray.forEach((group) => {
      const indexNum = selectedFilterArray.indexOf(group);
      group.items.forEach((item: UserData) => {
        if (
          (item.isSelected && !item.currentSet) ||
          (!item.isSelected && item.currentSet)
        ) {
          const indexNum2 = group.items.indexOf(item);
          if (indexNum > -1) removeFunction(item, indexNum, indexNum2);
          else {
            const inactiveIndexNum = filterArray.indexOf(group);
            addFunction(item, inactiveIndexNum, indexNum2);
          }
        }
      });
    });
  }

  static handleFilterClose(
    filterArray: ArrayStatus[],
    selectedFilterArray: ArrayStatus[],
    removeFunction: (item: ArrayStatus, index: number) => void,
    addFunction: (item: ArrayStatus, index: number) => void
  ) {
    filterArray &&
      filterArray.forEach((item) => {
        if (
          (item.isSelected && !item.currentSet) ||
          (!item.isSelected && item.currentSet)
        ) {
          const indexNum = selectedFilterArray.findIndex(
            (selectedItem) => selectedItem.id === item.id
          );
          if (indexNum > -1) removeFunction(item, indexNum);
          else {
            const inactiveIndexNum = filterArray.indexOf(item);
            addFunction(item, inactiveIndexNum);
          }
        }
      });
  }

  static handleAreaFilterClose(
    locationForm: UntypedFormGroup,
    locationNameSet: string | null,
    longVal: number,
    latVal: number,
    longValueSet: number,
    latValSet: number,
    locationRange: number,
    locationRangeSet: number
  ) {
    locationForm.setValue({ address: locationNameSet });
    longVal = longValueSet;
    latVal = latValSet;
    locationRange = locationRangeSet;
  }
}