import { useCallback } from 'react';

declare global {
  interface Window {
    axon: (
      action: 'track',
      eventName: string,
      eventData?: Record<string, any>
    ) => void;
  }
}

/**
 * Axon Item object structure following Axon's standard format
 */
export interface AxonItem {
  item_variant_id: string;
  item_id: string;
  item_name: string;
  price: number;
  quantity: number;
  image_url?: string;
  item_category_id: number;
}

/**
 * Hook to manage Applovin Axon Pixel interactions for analytics tracking.
 */
export const useAxon = () => {
  const isAxonAvailable = typeof window !== 'undefined' && Boolean(window.axon);

  const publishAxonEvent = useCallback(
    (
      eventName:
        | 'sign_up'
        | 'subscribe'
        | 'page_view'
        | 'begin_checkout'
        | 'add_to_cart'
        | 'view_item'
        | 'purchase',
      eventData?: Record<string, any>
    ) => {
      if (!isAxonAvailable) {
        console.warn(
          'Axon SDK not available, cannot publish event:',
          eventName
        );
        return;
      }

      try {
        window.axon('track', eventName, eventData);
      } catch (error) {
        console.error(`Error publishing Axon event "${eventName}":`, error);
      }
    },
    [isAxonAvailable]
  );

  const publishSignupEvent = useCallback(
    (userId?: string) => {
      publishAxonEvent('sign_up', {
        method: 'web',
        user_id: userId,
      });
    },
    [publishAxonEvent]
  );

  const publishSubscriptionEvent = useCallback(
    (subscriptionData: {
      currency?: string;
      value?: number;
      user_id?: string;
    }) => {
      publishAxonEvent('subscribe', {
        currency: subscriptionData.currency,
        value: subscriptionData.value,
        user_id: subscriptionData.user_id,
      });
    },
    [publishAxonEvent]
  );

  const publishPageViewEvent = useCallback(() => {
    publishAxonEvent('page_view');
  }, [publishAxonEvent]);

  const publishBeginCheckoutEvent = useCallback(
    (checkoutData: { currency: string; value: number; items: AxonItem[] }) => {
      publishAxonEvent('begin_checkout', {
        currency: checkoutData.currency,
        value: checkoutData.value,
        items: checkoutData.items,
      });
    },
    [publishAxonEvent]
  );

  const publishViewItemEvent = useCallback(
    (eventData: { currency: string; value: number; items: AxonItem[] }) => {
      publishAxonEvent('view_item', {
        currency: eventData.currency,
        value: eventData.value,
        items: eventData.items,
      });
    },
    [publishAxonEvent]
  );

  const publishAddToCartEvent = useCallback(
    (cartData: { currency: string; value: number; items: AxonItem[] }) => {
      publishAxonEvent('add_to_cart', {
        currency: cartData.currency,
        value: cartData.value,
        items: cartData.items,
      });
    },
    [publishAxonEvent]
  );

  const publishPurchaseEvent = useCallback(
    (purchaseData: {
      currency: string;
      value: number;
      items: AxonItem[];
      transaction_id: string;
      user_id?: string;
      shipping?: number;
      tax?: number;
    }) => {
      publishAxonEvent('purchase', {
        currency: purchaseData.currency,
        value: purchaseData.value,
        items: purchaseData.items,
        transaction_id: purchaseData.transaction_id,
        user_id: purchaseData.user_id,
        shipping: purchaseData.shipping,
        tax: purchaseData.tax,
      });
    },
    [publishAxonEvent]
  );

  return {
    publishSignupEvent,
    publishSubscriptionEvent,
    publishPageViewEvent,
    publishBeginCheckoutEvent,
    publishViewItemEvent,
    publishAddToCartEvent,
    publishPurchaseEvent,
  };
};

export const createAxonItemVariantIdForSubscription = (
  planKey: string,
  period: string
): string => {
  return `${planKey}_${period}`;
};