import React from "react";
import { demoOrderGroups } from "../data/mockAppData";
import { fetchOrderGroups, updateOrderGroupDeliveryChoice } from "../services/supabase/orderGroupRepository";
import {
  buildOrderGroupBuckets,
  filterOrderGroups,
  groupOrderGroupsByDate,
  ORDER_GROUP_DISPLAY_STATUS_OPTIONS,
} from "../services/orderGroupViews";
import { hasSupabaseConfig } from "../supabaseClient";

const cloneLiveGroups = (groups) => (Array.isArray(groups) ? groups.map((group) => ({ ...group })) : []);

const getErrorMessage = (error, fallbackMessage) => {
  if (!error) {
    return fallbackMessage;
  }

  if (error instanceof Error) {
    return error.message || fallbackMessage;
  }

  if (typeof error === "string") {
    return error || fallbackMessage;
  }

  return error?.message || fallbackMessage;
};

export const useOrderGroups = () => {
  const [orderGroups, setOrderGroups] = React.useState(() =>
    hasSupabaseConfig ? [] : cloneLiveGroups(demoOrderGroups),
  );
  const [filters, setFilters] = React.useState({
    query: "",
    displayStatus: "all",
  });
  const [selectedOrderGroupId, setSelectedOrderGroupId] = React.useState(() =>
    hasSupabaseConfig ? null : demoOrderGroups[0]?.id ?? null,
  );
  const [isLoading, setIsLoading] = React.useState(hasSupabaseConfig);
  const [loadError, setLoadError] = React.useState("");
  const [isSavingDeliveryChoice, setIsSavingDeliveryChoice] = React.useState(false);

  React.useEffect(() => {
    let cancelled = false;

    const loadLiveData = async () => {
      if (!hasSupabaseConfig) {
        setOrderGroups(cloneLiveGroups(demoOrderGroups));
        setIsLoading(false);
        setLoadError("");
        return;
      }

      setIsLoading(true);
      setLoadError("");

      const groupsResult = await fetchOrderGroups();

      if (cancelled) {
        return;
      }

      if (groupsResult.error) {
        setLoadError(groupsResult.error?.message || "Не удалось загрузить группы доставки");
        setOrderGroups([]);
        setIsLoading(false);
        return;
      }

      setOrderGroups(groupsResult.data || []);
      setIsLoading(false);
    };

    loadLiveData();

    return () => {
      cancelled = true;
    };
  }, []);

  React.useEffect(() => {
    if (!orderGroups.length) {
      setSelectedOrderGroupId(null);
      return;
    }

    if (!selectedOrderGroupId || !orderGroups.some((group) => group.id === selectedOrderGroupId)) {
      setSelectedOrderGroupId(orderGroups[0].id);
    }
  }, [orderGroups, selectedOrderGroupId]);

  const statusOptions = ORDER_GROUP_DISPLAY_STATUS_OPTIONS;

  const filteredOrderGroups = React.useMemo(
    () => filterOrderGroups(orderGroups, filters),
    [filters, orderGroups],
  );

  const visibleOrderGroups = filteredOrderGroups;
  const selectedOrderGroup =
    visibleOrderGroups.find((group) => group.id === selectedOrderGroupId) ||
    orderGroups.find((group) => group.id === selectedOrderGroupId) ||
    visibleOrderGroups[0] ||
    null;

  const orderGroupsByDate = React.useMemo(() => groupOrderGroupsByDate(orderGroups), [orderGroups]);
  const deliveryGroupBuckets = React.useMemo(() => buildOrderGroupBuckets(orderGroups), [orderGroups]);

  const saveManualDeliveryChoice = React.useCallback(async ({
    orderGroupId,
    deliveryDate,
    deliveryTime,
  }) => {
    setIsSavingDeliveryChoice(true);

    try {
      if (!hasSupabaseConfig) {
        const updatedAt = new Date().toISOString();
        setOrderGroups((currentGroups) =>
          currentGroups.map((group) =>
            group.id === orderGroupId
              ? {
                  ...group,
                  deliveryStatus: "agreed",
                  delivery_status: "agreed",
                  deliveryDate,
                  deliveryTime,
                  deliveryHalfDay: deliveryTime,
                  updatedAt,
                }
              : group,
          ),
        );
        return { success: true };
      }

      const result = await updateOrderGroupDeliveryChoice({
        orderGroupId,
        deliveryDate,
        deliveryTime,
      });

      if (result.error) {
        return {
          success: false,
          error: getErrorMessage(result.error, "Не удалось сохранить согласование доставки"),
        };
      }

      setOrderGroups((currentGroups) =>
        currentGroups.map((group) => (group.id === orderGroupId ? result.data : group)),
      );
      return { success: true, data: result.data };
    } catch (error) {
      return {
        success: false,
        error: getErrorMessage(error, "Не удалось сохранить согласование доставки"),
      };
    } finally {
      setIsSavingDeliveryChoice(false);
    }
  }, []);

  return {
    orderGroups,
    allOrderGroups: orderGroups,
    filteredOrderGroups,
    visibleOrderGroups,
    selectedOrderGroup,
    selectedOrderGroupId,
    setSelectedOrderGroupId,
    filters,
    setFilters,
    statusOptions,
    orderGroupsByDate,
    deliveryGroupBuckets,
    saveManualDeliveryChoice,
    isSavingDeliveryChoice,
    isLoading,
    loadError,
  };
};