import { create } from 'zustand';
import {
  paymentsService,
  CreditPackage,
  Payment,
  CreatePaymentRequest,
  PaymentResponse,
} from '@services/api/payments.service';

interface PaymentsState {
  packages: CreditPackage[];
  payments: Payment[];
  currentPayment: PaymentResponse | null;
  total: number;
  page: number;
  hasMore: boolean;
  isLoading: boolean;
  isProcessing: boolean;
  error: string | null;
  // Actions
  fetchPackages: () => Promise<void>;
  fetchPayments: (refresh?: boolean) => Promise<void>;
  createPayment: (data: CreatePaymentRequest) => Promise<PaymentResponse | null>;
  getPaymentById: (paymentId: string) => Promise<Payment | null>;
  clearCurrentPayment: () => void;
  clearError: () => void;
}

export const usePaymentsStore = create<PaymentsState>((set, get) => ({
  packages: [],
  payments: [],
  currentPayment: null,
  total: 0,
  page: 1,
  hasMore: false,
  isLoading: false,
  isProcessing: false,
  error: null,

  fetchPackages: async () => {
    set({ isLoading: true, error: null });

    try {
      const packages = await paymentsService.getPackages();
      set({ packages, isLoading: false });
    } catch (error: unknown) {
      const message = error instanceof Error ? error.message : 'Error al cargar paquetes';
      set({ error: message, isLoading: false });
    }
  },

  fetchPayments: async (refresh = false) => {
    const state = get();
    if (state.isLoading) return;

    const page = refresh ? 1 : state.page;

    set({ isLoading: true, error: null });

    try {
      const response = await paymentsService.getPaymentHistory(page, 20);
      set({
        payments: refresh
          ? response.payments
          : [...state.payments, ...response.payments],
        total: response.total,
        page: response.page + 1,
        hasMore: response.hasMore,
        isLoading: false,
      });
    } catch (error: unknown) {
      const message = error instanceof Error ? error.message : 'Error al cargar pagos';
      set({ error: message, isLoading: false });
    }
  },

  createPayment: async (data: CreatePaymentRequest) => {
    set({ isProcessing: true, error: null });

    try {
      const response = await paymentsService.createPayment(data);
      set({ currentPayment: response, isProcessing: false });
      return response;
    } catch (error: unknown) {
      const message = error instanceof Error ? error.message : 'Error al procesar pago';
      set({ error: message, isProcessing: false });
      return null;
    }
  },

  getPaymentById: async (paymentId: string) => {
    try {
      const payment = await paymentsService.getPaymentById(paymentId);
      return payment;
    } catch (error: unknown) {
      const message = error instanceof Error ? error.message : 'Error al obtener pago';
      set({ error: message });
      return null;
    }
  },

  clearCurrentPayment: () => set({ currentPayment: null }),

  clearError: () => set({ error: null }),
}));