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

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

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

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

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

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

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

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

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

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

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

      const result = await axios.post(
        'historico_alteracoes_projeto/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(
  'historico_alteracoes_projeto/updateHistorico_alteracoes_projeto',
  async (payload: any, { rejectWithValue }) => {
    try {
      const result = await axios.put(
        `historico_alteracoes_projeto/${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 historico_alteracoes_projetoSlice = createSlice({
  name: 'historico_alteracoes_projeto',
  initialState,
  reducers: {
    setRefetch: (state, action: PayloadAction<boolean>) => {
      state.refetch = action.payload;
    },
  },
  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.historico_alteracoes_projeto = action.payload.rows;
        state.count = action.payload.count;
      } else {
        state.historico_alteracoes_projeto = action.payload;
      }
      state.loading = false;
    });

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

    builder.addCase(deleteItemsByIds.fulfilled, (state) => {
      state.loading = false;
      fulfilledNotify(state, 'Historico_alteracoes_projeto 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,
        `${'Historico_alteracoes_projeto'.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,
        `${'Historico_alteracoes_projeto'.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,
        `${'Historico_alteracoes_projeto'.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, 'Historico_alteracoes_projeto 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 } = historico_alteracoes_projetoSlice.actions;

export default historico_alteracoes_projetoSlice.reducer;
