import { createSlice, createAsyncThunk, PayloadAction } from '@reduxjs/toolkit'
import axios from 'axios'
import {fulfilledNotify, rejectNotify, resetNotify} from "../../helpers/notifyStateHandler";

interface MainState {
    image_generations: any
    loading: boolean
    count: number
    refetch: boolean;
    rolesWidgets: any[];
    generatedImages: string[];
    isGenerating: boolean;
    notify: {
        showNotification: boolean
        textNotification: string
        typeNotification: string
    }
}

const initialState: MainState = {
    image_generations: [],
    loading: false,
    count: 0,
    refetch: false,
    rolesWidgets: [],
    generatedImages: [],
    isGenerating: false,
    notify: {
        showNotification: false,
        textNotification: '',
        typeNotification: 'warn',
    },
}

export const fetch = createAsyncThunk('image_generations/fetch', async (data: any) => {
    const { id, query } = data
    const result = await axios.get(
        `image_generations${
            query || (id ? `/${id}` : '')
        }`
    )
    return id ? result.data : {rows: result.data.rows, count: result.data.count};
})

export const generate = createAsyncThunk('image_generations/generate', async (data: any, { rejectWithValue }) => {
    try {
        const result = await axios.post(
          'image_generations/generate',
          data
        )
        return result.data
    } catch (error) {
        if (!error.response) {
            throw error;
        }

        return rejectWithValue(error.response.data);
    }
})

export const deleteItemsByIds = createAsyncThunk(
  'image_generations/deleteByIds',
  async (data: any, { rejectWithValue }) => {
    try {
      await axios.post('image_generations/deleteByIds', { data });
    } catch (error) {
      if (!error.response) {
        throw error;
      }

      return rejectWithValue(error.response.data);
    }
  },
);

export const deleteItem = createAsyncThunk('image_generations/deleteImage_generations', async (id: string, { rejectWithValue }) => {
    try {
        await axios.delete(`image_generations/${id}`)
    } catch (error) {
        if (!error.response) {
            throw error;
        }

        return rejectWithValue(error.response.data);
    }
})

export const create = createAsyncThunk('image_generations/createImage_generations', async (data: any, { rejectWithValue }) => {
    try {
        const result = await axios.post(
          'image_generations',
          { data }
        )
        return result.data
    } catch (error) {
        if (!error.response) {
            throw error;
        }

        return rejectWithValue(error.response.data);
    }
})

export const uploadCsv = createAsyncThunk(
  'image_generations/uploadCsv',
  async (file: File, { rejectWithValue }) => {
      try {
          const data = new FormData();
          data.append('file', file);
          data.append('filename', file.name);

          const result = await axios.post('image_generations/bulk-import', data, {
              headers: {
                  'Content-Type': 'multipart/form-data',
              },
          });

          return result.data;
      } catch (error) {
          if (!error.response) {
              throw error;
          }

          return rejectWithValue(error.response.data);
      }
  },
);

export const update = createAsyncThunk('image_generations/updateImage_generations', async (payload: any, { rejectWithValue }) => {
    try {
        const result = await axios.put(
          `image_generations/${payload.id}`,
          { id: payload.id, data: payload.data }
        )
        return result.data
    } catch (error) {
        if (!error.response) {
            throw error;
        }

        return rejectWithValue(error.response.data);
    }
})


export const image_generationsSlice = createSlice({
    name: 'image_generations',
    initialState,
    reducers: {
        setRefetch: (state, action: PayloadAction<boolean>) => {
            state.refetch = action.payload;
        },
        resetGeneratedImages: (state) => {
            state.generatedImages = [];
        }
    },
    extraReducers: (builder) => {
        builder.addCase(fetch.pending, (state) => {
            state.loading = true
            resetNotify(state);
        })
        builder.addCase(fetch.rejected, (state, action) => {
            state.loading = false
            rejectNotify(state, action);
        })

        builder.addCase(fetch.fulfilled, (state, action) => {
            if (action.payload.rows && action.payload.count >= 0) {
                state.image_generations = action.payload.rows;
                state.count = action.payload.count;
            } else {
                state.image_generations = action.payload;
            }
            state.loading = false
        })

        builder.addCase(generate.pending, (state) => {
            state.isGenerating = true;
            resetNotify(state);
        });
        builder.addCase(generate.fulfilled, (state, action) => {
            state.isGenerating = false;
            state.generatedImages = action.payload.urls;
            state.refetch = true;
            fulfilledNotify(state, 'Images generated successfully');
        });
        builder.addCase(generate.rejected, (state, action) => {
            state.isGenerating = false;
            rejectNotify(state, action);
        });

        builder.addCase(deleteItemsByIds.pending, (state) => {
            state.loading = true;
            resetNotify(state);
        });

        builder.addCase(deleteItemsByIds.fulfilled, (state) => {
            state.loading = false;
            fulfilledNotify(state, 'Image_generations has been deleted');
        });

        builder.addCase(deleteItemsByIds.rejected, (state, action) => {
            state.loading = false;
            rejectNotify(state, action);
        });

        builder.addCase(deleteItem.pending, (state) => {
            state.loading = true
            resetNotify(state);
        })

        builder.addCase(deleteItem.fulfilled, (state) => {
            state.loading = false
            fulfilledNotify(state, `${'Image_generations'.slice(0, -1)} has been deleted`);
        })

        builder.addCase(deleteItem.rejected, (state, action) => {
            state.loading = false
            rejectNotify(state, action);
        })

        builder.addCase(create.pending, (state) => {
            state.loading = true
            resetNotify(state);
        })
        builder.addCase(create.rejected, (state, action) => {
            state.loading = false
            rejectNotify(state, action);
        })

        builder.addCase(create.fulfilled, (state) => {
            state.loading = false
            fulfilledNotify(state, `${'Image_generations'.slice(0, -1)} has been created`);
        })

        builder.addCase(update.pending, (state) => {
            state.loading = true
            resetNotify(state);
        })
        builder.addCase(update.fulfilled, (state) => {
            state.loading = false
            fulfilledNotify(state, `${'Image_generations'.slice(0, -1)} has been updated`);
        })
        builder.addCase(update.rejected, (state, action) => {
            state.loading = false
            rejectNotify(state, action);
        })

        builder.addCase(uploadCsv.pending, (state) => {
            state.loading = true;
            resetNotify(state);
        })
        builder.addCase(uploadCsv.fulfilled, (state) => {
            state.loading = false;
            fulfilledNotify(state, 'Image_generations has been uploaded');
        })
        builder.addCase(uploadCsv.rejected, (state, action) => {
            state.loading = false;
            rejectNotify(state, action);
        })

        
    },
})

// Action creators are generated for each case reducer function
 export const { setRefetch, resetGeneratedImages } = image_generationsSlice.actions

export default image_generationsSlice.reducer