---

import { type AuditRouteSearch } from '@/app/router/routes/audit';
import { EquipmentModel } from '@/features/Settings/selects/lib';
import { useGetLocationChildrenQuery } from '@/shared/api/location/client';
import { useAutocompleteDebounce } from '@/shared/hooks';
import { Helpers } from '@/shared/lib';
import { ChangeEvent, useCallback, useEffect, useMemo, useRef } from 'react';

type ModelSelectValue = string | number | boolean | null;
type ModelSelectChangeValue = ModelSelectValue | ModelSelectValue[];

type Params = {
  searchParams: AuditRouteSearch;
  updateParamAndResetPage: (paramName: string, value: unknown) => void;
  updateParamsAndResetPage: (queryObject: Record<string, unknown>) => void;
};

const getEquipmentModelType = (type?: string) => {
  switch (type) {
    case 'controller_delete':
      return EquipmentModel.controller;

    case 'padlet_delete':
      return EquipmentModel.padlet;

    case 'device_delete':
    case 'network_device_delete':
    case 'offline_device_delete':
      return EquipmentModel.device;

    default:
      return undefined;
  }
};

export const useAdditionalFilters = ({
  searchParams,
  updateParamAndResetPage,
  updateParamsAndResetPage,
}: Params) => {
  const equipmentModelType = useMemo(
    () => getEquipmentModelType(searchParams.type),
    [searchParams.type],
  );

  const isEquipmentFiltersAvailable = Boolean(equipmentModelType);

  const {
    inputValue: macValue,
    setInputValue: setMacValue,
    debouncedValue: debouncedMac,
    onInputChange: handleMacInputChange,
  } = useAutocompleteDebounce(searchParams.mac || '');

  const {
    inputValue: ipValue,
    setInputValue: setIpValue,
    debouncedValue: debouncedIp,
    onInputChange: handleIpInputChange,
  } = useAutocompleteDebounce(searchParams.ip || '');

  const isMacDebounceReady = useRef(false);
  const isIpDebounceReady = useRef(false);
  const isResetting = useRef(false);

  useEffect(() => {
    if (!isMacDebounceReady.current) {
      isMacDebounceReady.current = true;
      return;
    }

    if (isResetting.current) {
      return;
    }

    updateParamAndResetPage('mac', debouncedMac || undefined);
  }, [debouncedMac, updateParamAndResetPage]);

  useEffect(() => {
    if (!isIpDebounceReady.current) {
      isIpDebounceReady.current = true;
      return;
    }

    if (isResetting.current) {
      isResetting.current = false;
      return;
    }

    updateParamAndResetPage('ip', debouncedIp || undefined);
  }, [debouncedIp, updateParamAndResetPage]);

  const { data: roomsData } = useGetLocationChildrenQuery(
    {
      parentId: Helpers.convertStringsToNumbers(searchParams.floorId),
    },
    {
      skip: !searchParams.floorId.length,
      refetchOnMountOrArgChange: true,
    },
  );

  const roomIdByTreeId = useMemo(() => {
    const rooms = roomsData || [];

    return new Map(
      rooms
        .filter((room) => room.id && room.treeId)
        .map((room) => [String(room.treeId), String(room.id)]),
    );
  }, [roomsData]);

  const setRegionId = useCallback(
    (value: string[]) => {
      updateParamsAndResetPage({
        regionId: value,
        locationIds: [],
      });
    },
    [updateParamsAndResetPage],
  );

  const setCityId = useCallback(
    (value: string[]) => {
      updateParamsAndResetPage({
        cityId: value,
        locationIds: [],
      });
    },
    [updateParamsAndResetPage],
  );

  const setPlaceId = useCallback(
    (value: string[]) => {
      updateParamsAndResetPage({
        placeId: value,
        locationIds: [],
      });
    },
    [updateParamsAndResetPage],
  );

  const setFloorId = useCallback(
    (value: string[]) => {
      updateParamsAndResetPage({
        floorId: value,
        locationIds: [],
      });
    },
    [updateParamsAndResetPage],
  );

  const setRoomId = useCallback(
    (roomTreeIds: string[]) => {
      const locationIds = roomTreeIds
        .map((treeId) => roomIdByTreeId.get(String(treeId)))
        .filter((id): id is string => Boolean(id));

      updateParamsAndResetPage({
        roomId: roomTreeIds,
        locationIds,
      });
    },
    [roomIdByTreeId, updateParamsAndResetPage],
  );

  const handleChangeModels = useCallback(
    (value: ModelSelectChangeValue) => {
      updateParamAndResetPage(
        'modelIds',
        Array.isArray(value) ? value.map(String) : [],
      );
    },
    [updateParamAndResetPage],
  );

  const handleMacChange = useCallback(
    (event: ChangeEvent<HTMLInputElement>) => {
      handleMacInputChange(event.target.value);
    },
    [handleMacInputChange],
  );

  const handleIpChange = useCallback(
    (value: string) => {
      handleIpInputChange(value);
    },
    [handleIpInputChange],
  );

  const resetAdditionalFilters = useCallback(() => {
    isResetting.current = true;

    setMacValue('');
    setIpValue('');

    updateParamsAndResetPage({
      modelIds: [],
      mac: '',
      ip: '',
      locationIds: [],
      regionId: [],
      cityId: [],
      placeId: [],
      floorId: [],
      roomId: [],
    });
  }, [setIpValue, setMacValue, updateParamsAndResetPage]);

  return {
    isEquipmentFiltersAvailable,
    equipmentModelType,

    modelIds: searchParams.modelIds,
    macValue,
    ipValue,

    cityId: searchParams.cityId,
    floorId: searchParams.floorId,
    placeId: searchParams.placeId,
    regionId: searchParams.regionId,
    roomId: searchParams.roomId,

    setRegionId,
    setCityId,
    setPlaceId,
    setFloorId,
    setRoomId,

    handleChangeModels,
    handleMacChange,
    handleIpChange,
    resetAdditionalFilters,
  };
};