import { create } from 'zustand';
import { CartItem, CartProps } from '~/types/cart';
import { getUserCart } from '~/services/cart';
import {
  syncCartWithCookie,
  getCartDataFromCookie,
  getSelectedItemsFromCookie,
  forceResetAllSelectedItems,
} from '~/utils/cart';

type State = {
  cart: CartProps | null;
  isLoadCart: boolean;
  summary: {
    subtotal: number;
    discount: number;
    total: number;
    tax: number;
    grandTotal: number;
  };
};

type Action = {
  loadCart: (userId: number) => Promise<void>;
  updateCartItem: (updateCart: CartProps) => void;
  forceResetSelection: () => void;
  clearCart: () => void;
};

export const useCartStore = create<State & Action>((set, get) => ({
  cart: null,
  isLoadCart: false,
  summary: {
    subtotal: 0,
    discount: 0,
    total: 0,
    tax: 0,
    grandTotal: 0,
  },

  loadCart: async (userId) => {
    if (get().isLoadCart) return;

    set({ isLoadCart: true });

    try {
      const cart: CartProps = (await getUserCart(userId)) as CartProps;

      // Sync with cookie data
      const syncResult = syncCartWithCookie(cart);

      if (syncResult?.needsUpdate && cart.products) {
        const selectedItems = getSelectedItemsFromCookie();

        const updatedCart = {
          ...cart,
          products: cart.products.map((item) => ({
            ...item,
            selected:
              selectedItems[item.id] !== undefined
                ? selectedItems[item.id]
                : item.selected,
          })),
        };

        set({ cart: updatedCart });
      } else {
        set({ cart });
      }

      // Update summary
      const summary = computeSummary(get().cart!);
      set({ summary });
    } catch (error) {
      console.error('Failed to load cart:', error);

      // Fallback to cookie data
      await handleFallbackFromCookie();
    } finally {
      set({ isLoadCart: false });
    }
  },

  updateCartItem: (updatedCart) => {
    set({ cart: updatedCart });
    syncCartWithCookie(updatedCart);

    const summary = computeSummary(updatedCart);
    set({ summary });
  },

  forceResetSelection: () => {
    const { cart } = get();
    if (!cart) return;

    forceResetAllSelectedItems();

    const updatedCart = {
      ...cart,
      products: cart.products.map((item) => ({ ...item, selected: false })),
    };

    set({ cart: updatedCart });

    const summary = computeSummary(updatedCart);
    set({ summary });
  },

  clearCart: () => {
    set({
      cart: null,
      summary: {
        subtotal: 0,
        discount: 0,
        total: 0,
        tax: 0,
        grandTotal: 0,
      },
    });
  },
}));

// Helper function for cookie fallback
const handleFallbackFromCookie = async () => {
  try {
    const cartData = getCartDataFromCookie();

    if (Object.keys(cartData).length === 0) return;

    const products = Object.values(cartData).map(transformCookieItemToProduct);

    const fallbackCart: CartProps = {
      product_total: products.length,
      products,
    };

    useCartStore.setState({ cart: fallbackCart });

    const summary = computeSummary(fallbackCart);
    useCartStore.setState({ summary });
  } catch (error) {
    console.error('Cookie fallback failed:', error);
  }
};

// Helper function to transform cookie item to product format
const transformCookieItemToProduct = (item: any): CartItem => ({
  cart_id: item.cart_id,
  id: item.id,
  cart_type: item.cart_type,
  product_id: item.product?.id,
  product_name: item.product?.name,
  program_line_id: item.program_line?.id,
  program_line_name: item.program_line?.name,
  quantity: item.quantity,
  selected: item.selected,
  price: item.price,
  package_price: item.package_price,
  source: item.source,
});

// Helper function to compute cart summary
const computeSummary = (cart: CartProps) => {
  if (!cart?.products) {
    return { subtotal: 0, discount: 0, total: 0, grandTotal: 0, tax: 0 };
  }

  const PPN = parseFloat(process.env.NEXT_PUBLIC_PPN || '0');
  let subtotal = 0;
  let discount = 0;

  for (const item of cart.products) {
    if (!item.selected) continue;

    const price =
      item.cart_type === 'promotion'
        ? (item?.package_price || 0) * item.quantity
        : item.price.price * item.quantity;

    subtotal += price;
    discount += price - item.price.price_discount * item.quantity;
  }

  const total = subtotal - discount;
  const grandTotal = total * (1 + PPN);
  const tax = grandTotal - total;

  return { subtotal, discount, total, grandTotal, tax };
};