import type { SearchApiService } from "../../searchWidget/types";
import type { Filter } from "../types";
import { useSearchStateManager } from "../../sharedState/composables/useSearchStateManager";
import { useBarneoConfig } from "../../../config/BarneoConfigManager";

export function useFiltersApi(apiService: SearchApiService | undefined) {
  const { productsWidgetConfig } = useBarneoConfig();
  const searchStateManager = useSearchStateManager(apiService, {
    productsWidget: productsWidgetConfig,
  });

  // Проверка, является ли range фильтр дефолтным
  const isDefaultRangeFilter = (
    filterCode: string,
    gte?: string,
    lte?: string,
    availableRangeFilter?: any
  ): boolean => {
    if (!availableRangeFilter) return false;

    const defaultGte = availableRangeFilter.gte || "0";
    const defaultLte = availableRangeFilter.lte || "999999999";

    // Проверяем, совпадают ли значения с дефолтными
    const isDefaultGte = !gte || gte === defaultGte;
    const isDefaultLte = !lte || lte === defaultLte;

    return isDefaultGte && isDefaultLte;
  };

  /**
   * Применяет фильтры к поиску
   */
  const applyFilters = async (
    query: string,
    filters: Record<string, string[]>,
    activeFilters?: Array<{
      id: string;
      name: string;
      code: string;
      values: Array<{
        id: string;
        name: string;
        isSelected: boolean;
      }>;
    }>,
    options?: {
      sort?: string;
      pagination?: {
        limit_products?: number;
        limit_categories?: number;
        limit_brands?: number;
        offset_products?: number;
      };
      rangeFilters?: Array<{ code: string; gte?: string; lte?: string }>;
      availableRangeFilters?: Array<{
        code: string;
        name: string;
        gte: string;
        lte: string;
      }>;
    }
  ) => {
    if (!apiService || !query.trim()) return null;

    try {
      // Преобразуем фильтры в правильный формат для API
      const transformedFilters: Record<string, string[]> = {};

      Object.entries(filters).forEach(([key, values]) => {
        if (values && values.length > 0) {
          switch (key) {
            case "brand":
              transformedFilters.brands = values;
              break;
            case "category":
              transformedFilters.category_ids = values;
              break;
            case "country":
              transformedFilters.countries = values;
              break;
            default:
              transformedFilters[key] = values;
          }
        }
      });

      // Преобразуем range фильтры в формат products для API
      const products: Array<{
        code: string;
        value_gte?: string;
        value_lte?: string;
      }> = [];

      if (options?.rangeFilters) {
        options.rangeFilters.forEach(({ code, gte, lte }) => {
          // Получаем доступный range фильтр для получения максимальных значений
          const availableRangeFilter = options.availableRangeFilters?.find(
            (filter: any) => filter.code === code
          );

          if (gte || lte) {
            // Если заполнено только одно поле, используем максимальные значения для второго
            const finalGte = gte || availableRangeFilter?.gte || "0";
            const finalLte = lte || availableRangeFilter?.lte || "999999999";

            // Проверяем, не являются ли значения дефолтными
            const isDefaultRange = isDefaultRangeFilter(
              code,
              finalGte,
              finalLte,
              availableRangeFilter
            );

            if (!isDefaultRange) {
              products.push({
                code,
                value_gte: finalGte,
                value_lte: finalLte,
              });
            } else {
            }
          }
        });
      }

      return await searchStateManager.performSearchWithFilters(query, {
        filters: transformedFilters,
        products: products.length > 0 ? products : undefined,
        activeFilters: activeFilters || [],
        sort: options?.sort,
        pagination: options?.pagination,
        updateSharedState: true,
      });
    } catch (error) {
      console.error("Ошибка применения фильтров:", error);
      throw error;
    }
  };

  /**
   * Сбрасывает все фильтры
   */
  const resetFilters = async (query: string) => {
    if (!apiService || !query.trim()) return null;

    try {
      return await searchStateManager.performSearchWithFilters(query, {
        updateSharedState: true,
      });
    } catch (error) {
      console.error("Ошибка сброса фильтров:", error);
      throw error;
    }
  };

  /**
   * Получает фильтры для запроса
   */
  const getFiltersForQuery = async (query: string): Promise<Filter[]> => {
    if (!apiService || !query.trim()) return [];

    try {
      const response = await searchStateManager.performSearchWithFilters(
        query,
        {
          pagination: {
            limit_products: 0,
            limit_categories: 0,
            limit_brands: 0,
            offset_products: 0,
          },
          updateSharedState: false,
        }
      );

      if (response && response.data && response.data.filters) {
        return response.data.filters as Filter[];
      }

      return [];
    } catch (error) {
      console.error("Ошибка получения фильтров:", error);
      return [];
    }
  };

  return {
    applyFilters,
    resetFilters,
    getFiltersForQuery,
  };
}