import { createAsyncThunk, createSlice, PayloadAction } from "@reduxjs/toolkit";
import endpoints from "../../config/apiEndpoints";
import axiosInstance from "../../utils/axiosConfig";
import { toast } from "react-toastify";

export interface AssistedPackage {
    package_id: number;
    package_code_name: string;
    name: string;
    image: string | null;
    express_interest: number;
    photo_gallery: number;
    contact: number;
    feed: number;
    voice: number;
    proposal: number;
    bio_data: number;
    profile_image_view: number;
    gallery_image_view: number;
    auto_profile_match: number;
    price: number|string;
    validity: number;
    features?: string[];
  }

interface AssistedState {
  assisted_video: string;
  assisted_packages: AssistedPackage[];
  loading: boolean;
  error: string | null;
  dataFetched: boolean;
  postDataFetched: boolean;
}

const initialState: AssistedState = {
    assisted_video: '',
    assisted_packages: [],
    loading: false,
    error: null,
    dataFetched: false,
    postDataFetched: false,
  };

  const {assistedPackage: assistedPackageApi, assistedRequestCall: assistedRequestCallApi} = endpoints;

  // Async thunk to fetch packages
  export const fetchAssistedPackages = createAsyncThunk(
      'assistedPackage/fetchPackages',
      async (_, { rejectWithValue }) => {
        try {
          const response = await fetch(assistedPackageApi, {
            method: 'GET',
            headers: {
              'Content-Type': 'application/json',
            },
          });
    
          if (!response.ok) {
            throw new Error(`HTTP error! Status: ${response.status}`);
          }
    
          const json = await response.json();
          const packages = json.data.map((pkg: AssistedPackage) => {
            const features: string[] = [];

            if (pkg.express_interest >= 1) features.push(pkg.express_interest+' Express Interest');
            if (pkg.photo_gallery >= 1) features.push(pkg.photo_gallery+' Photo Gallery');
            if (pkg.contact >= 1) features.push(pkg.contact+' Contact Info Access');
            if (pkg.feed >= 1) features.push(pkg.feed+' Feed Access');
            if (pkg.voice >= 1) features.push(pkg.voice+' Voice Messages');
            if (pkg.proposal >= 1) features.push(pkg.proposal+' Send Proposals');
            if (pkg.bio_data >= 1) features.push(pkg.bio_data+' Bio Data');
            if (pkg.profile_image_view >= 1) features.push(pkg.profile_image_view+' Profile Image View');
            if (pkg.gallery_image_view >= 1) features.push(pkg.gallery_image_view+' Gallery Image View');
            if (pkg.auto_profile_match >= 1) features.push('Auto Profile Match');
    
            return {
              ...pkg,
              features,
            };
          });
    
          return packages;
        } catch (error) {
          return rejectWithValue((error as Error).message);
        }
      }
    );

    export const assistedRequestCall = createAsyncThunk(
        'asisted/requestCall',
        async (payload: {name: string, phone: string, whatsapp: string}, { rejectWithValue }) => {
          try {
            const response = await axiosInstance.post(
              assistedRequestCallApi,
              payload,
              {
                headers: {
                  'Content-Type': 'multipart/form-data',
                },
              }
            );
            return response.data;
          } catch (error) {
            toast.error('Failed to send request. Please try again later.');
            return rejectWithValue((error as Error).message);
          }
        }
      );

    const assistedSlice = createSlice({
    name: 'package',
    initialState,
    reducers: {},
    extraReducers: (builder) => {
        builder
          .addCase(fetchAssistedPackages.pending, (state) => {
            state.loading = true;
            state.error = null;
          })
          .addCase(fetchAssistedPackages.fulfilled, (state, action: PayloadAction<AssistedPackage[]>) => {
            state.loading = false;
            state.assisted_packages = action.payload;
          })
          .addCase(fetchAssistedPackages.rejected, (state, action) => {
            state.loading = false;
            state.error = action.payload as string;
          });
      }
  });

export default assistedSlice.reducer;