import { createSlice, createAsyncThunk } from "@reduxjs/toolkit";
import type { RootState } from "@/store/store";

export interface Package {
  id: number;
  package_type: number;
  name: string;
  price: number;
  image: string;
  time: string;
  type: string; // "Month" | "Year"
  is_ads_free: number;
  is_premium_news: number;
  is_epaper: number;
  web_product_package: string;
  status: number;
  is_buy: number;
}

export interface PaymentOption {
  id: number;
  name: string;
  visibility: string; // "0" | "1"
  is_live: string;
  key_1: string;
  key_2: string;
  key_3: string;
  key_4: string;
}

interface PackageResponse  { status: number; result: Package[] }
interface PaymentResponse  { status: number; result: Record<string, PaymentOption> }

export const fetchPackages = createAsyncThunk<Package[]>(
  "subscribe/fetchPackages",
  async (_, { rejectWithValue }) => {
    try {
      const { default: apiClient } = await import("@/services/api.client");
      const { API_ENDPOINTS } = await import("@/lib/constants/apiEndpoints");
      const { data } = await apiClient.post<PackageResponse>(
        API_ENDPOINTS.GET_PACKAGE, {},
      );
      return (data.result ?? []).filter((p) => p.status === 1);
    } catch (err) {
      return rejectWithValue((err as Error)?.message ?? "Failed.");
    }
  },
);

export const fetchPaymentOptions = createAsyncThunk<PaymentOption[]>(
  "subscribe/fetchPaymentOptions",
  async (_, { rejectWithValue }) => {
    try {
      const { default: apiClient } = await import("@/services/api.client");
      const { API_ENDPOINTS } = await import("@/lib/constants/apiEndpoints");
      const { data } = await apiClient.post<PaymentResponse>(
        API_ENDPOINTS.GET_PAYMENT_OPTION, {},
      );
      // Only return gateways with visibility "1"
      return Object.values(data.result ?? {}).filter((o) => o.visibility === "1");
    } catch (err) {
      return rejectWithValue((err as Error)?.message ?? "Failed.");
    }
  },
);

export const addTransaction = createAsyncThunk<
  void,
  { userId: number; packageId: number; price: number; transactionId: string; description: string }
>("subscribe/addTransaction", async (payload, { rejectWithValue }) => {
  try {
    const { default: apiClient } = await import("@/services/api.client");
    const { API_ENDPOINTS } = await import("@/lib/constants/apiEndpoints");
    await apiClient.post(API_ENDPOINTS.ADD_TRANSACTION, {
      user_id: payload.userId,
      package_id: payload.packageId,
      price: payload.price,
      transaction_id: payload.transactionId,
      description: payload.description,
    });
  } catch (err) {
    return rejectWithValue((err as Error)?.message ?? "Failed.");
  }
});

export const updateTransactionStatus = createAsyncThunk<
  void,
  { userId: number; transactionId: string; status: 1 | 2 | 3 } // 1=Processing, 2=Success, 3=Failed
>("subscribe/updateStatus", async ({ userId, transactionId, status }, { rejectWithValue }) => {
  try {
    const { default: apiClient } = await import("@/services/api.client");
    const { API_ENDPOINTS } = await import("@/lib/constants/apiEndpoints");
    await apiClient.post(API_ENDPOINTS.UPDATE_TRANSACTION_STATUS, {
      user_id: userId,
      trasaction_id: transactionId, // API typo preserved
      transaction_status: status,
    });
  } catch (err) {
    return rejectWithValue((err as Error)?.message ?? "Failed.");
  }
});

interface SubscribeState {
  packages: Package[];
  paymentOptions: PaymentOption[];
  packagesLoaded: boolean;
  isLoading: boolean;
  isProcessing: boolean;
}

const initialState: SubscribeState = {
  packages: [],
  paymentOptions: [],
  packagesLoaded: false,
  isLoading: false,
  isProcessing: false,
};

export const subscribeSlice = createSlice({
  name: "subscribe",
  initialState,
  reducers: {},
  extraReducers: (builder) => {
    builder
      .addCase(fetchPackages.pending, (state) => { state.isLoading = true; })
      .addCase(fetchPackages.fulfilled, (state, action) => {
        state.isLoading = false;
        state.packages = action.payload;
        state.packagesLoaded = true;
      })
      .addCase(fetchPackages.rejected, (state) => { state.isLoading = false; })
      .addCase(fetchPaymentOptions.fulfilled, (state, action) => {
        state.paymentOptions = action.payload;
      })
      .addCase(addTransaction.pending, (state) => { state.isProcessing = true; })
      .addCase(addTransaction.fulfilled, (state) => { state.isProcessing = false; })
      .addCase(addTransaction.rejected, (state) => { state.isProcessing = false; });
  },
});

export default subscribeSlice.reducer;

export const selectPackages        = (s: RootState) => s.subscribe.packages;
export const selectPaymentOptions  = (s: RootState) => s.subscribe.paymentOptions;
export const selectPackagesLoaded  = (s: RootState) => s.subscribe.packagesLoaded;
export const selectSubscribeLoading = (s: RootState) => s.subscribe.isLoading;
export const selectSubscribeProcessing = (s: RootState) => s.subscribe.isProcessing;