Assist_Design/apps/portal/src/features/subscriptions/hooks/useSubscriptions.ts

/**
 * Subscriptions Hooks
 * React hooks for subscription functionality using shared types
 */

import { useQuery } from "@tanstack/react-query";
import { apiClient, queryKeys } from "@/core/api";
import { getDataOrDefault, getDataOrThrow, getNullableData } from "@/core/api/response-helpers";
import { useAuthSession } from "@/features/auth/services/auth.store";
import type { InvoiceList, Subscription, SubscriptionList } from "@customer-portal/domain";

interface UseSubscriptionsOptions {
  status?: string;
}

const emptySubscriptionList: SubscriptionList = {
  subscriptions: [],
  totalCount: 0,
};

const emptyStats = {
  total: 0,
  active: 0,
  suspended: 0,
  cancelled: 0,
  pending: 0,
};

const emptyInvoiceList: InvoiceList = {
  invoices: [],
  pagination: {
    page: 1,
    totalItems: 0,
    totalPages: 0,
  },
};

function toSubscriptionList(
  payload?: SubscriptionList | Subscription[] | null
): SubscriptionList {
  if (!payload) {
    return emptySubscriptionList;
  }
  if (Array.isArray(payload)) {
    return {
      subscriptions: payload,
      totalCount: payload.length,
    };
  }
  return payload;
}

/**
 * Hook to fetch all subscriptions
 */
export function useSubscriptions(options: UseSubscriptionsOptions = {}) {
  const { status } = options;
  const { isAuthenticated, hasValidToken } = useAuthSession();

  return useQuery<SubscriptionList>({
    queryKey: queryKeys.subscriptions.list(status ? { status } : undefined),
    queryFn: async () => {
      const response = await apiClient.GET("/api/subscriptions",
        status ? { params: { query: { status } } } : undefined
      );
      return toSubscriptionList(getNullableData(response));
    },
    staleTime: 5 * 60 * 1000,
    gcTime: 10 * 60 * 1000,
    enabled: isAuthenticated && hasValidToken,
  });
}

/**
 * Hook to fetch active subscriptions only
 */
export function useActiveSubscriptions() {
  const { isAuthenticated, hasValidToken } = useAuthSession();

  return useQuery<Subscription[]>({
    queryKey: queryKeys.subscriptions.active(),
    queryFn: async () => {
      const response = await apiClient.GET("/api/subscriptions/active");
      return getDataOrDefault(response, [] as Subscription[]);
    },
    staleTime: 5 * 60 * 1000,
    gcTime: 10 * 60 * 1000,
    enabled: isAuthenticated && hasValidToken,
  });
}

/**
 * Hook to fetch subscription statistics
 */
export function useSubscriptionStats() {
  const { isAuthenticated, hasValidToken } = useAuthSession();

  return useQuery({
    queryKey: queryKeys.subscriptions.stats(),
    queryFn: async () => {
      const response = await apiClient.GET("/api/subscriptions/stats");
      return getDataOrDefault(response, emptyStats);
    },
    staleTime: 5 * 60 * 1000,
    gcTime: 10 * 60 * 1000,
    enabled: isAuthenticated && hasValidToken,
  });
}

/**
 * Hook to fetch a specific subscription
 */
export function useSubscription(subscriptionId: number) {
  const { isAuthenticated, hasValidToken } = useAuthSession();

  return useQuery<Subscription>({
    queryKey: queryKeys.subscriptions.detail(String(subscriptionId)),
    queryFn: async () => {
      const response = await apiClient.GET("/api/subscriptions/{id}", {
        params: { path: { id: subscriptionId } },
      });
      return getDataOrThrow<Subscription>(response, "Subscription not found");
    },
    staleTime: 5 * 60 * 1000,
    gcTime: 10 * 60 * 1000,
    enabled: isAuthenticated && hasValidToken && subscriptionId > 0,
  });
}

/**
 * Hook to fetch subscription invoices
 */
export function useSubscriptionInvoices(
  subscriptionId: number,
  options: { page?: number; limit?: number } = {}
) {
  const { page = 1, limit = 10 } = options;
  const { isAuthenticated, hasValidToken } = useAuthSession();

  return useQuery<InvoiceList>({
    queryKey: queryKeys.subscriptions.invoices(subscriptionId, { page, limit }),
    queryFn: async () => {
      const response = await apiClient.GET("/api/subscriptions/{id}/invoices", {
        params: {
          path: { id: subscriptionId },
          query: { page, limit },
        },
      });
      return getDataOrDefault(response, {
        ...emptyInvoiceList,
        pagination: {
          ...emptyInvoiceList.pagination,
          page,
        },
      });
    },
    staleTime: 60 * 1000,
    gcTime: 5 * 60 * 1000,
    enabled: isAuthenticated && hasValidToken && subscriptionId > 0,
  });
}