frontend/src/store/reducers/sourcesSlice.js

import { createSlice, createAsyncThunk } from '@reduxjs/toolkit';
import sourceService from '../../services/sourceService';

// Initial state
const initialState = {
  items: [],
  loading: false,
  error: null
};

// Async thunks
export const fetchSources = createAsyncThunk(
  'sources/fetchSources',
  async (_, { rejectWithValue }) => {
    try {
      const response = await sourceService.getAll();
      return response.data.sources;
    } catch (error) {
      return rejectWithValue(error.response.data);
    }
  }
);

export const addSource = createAsyncThunk(
  'sources/addSource',
  async (sourceData, { rejectWithValue }) => {
    try {
      const response = await sourceService.create(sourceData);
      return response.data;
    } catch (error) {
      return rejectWithValue(error.response.data);
    }
  }
);

export const deleteSource = createAsyncThunk(
  'sources/deleteSource',
  async (sourceId, { rejectWithValue }) => {
    try {
      const response = await sourceService.delete(sourceId);
      return { ...response.data, sourceId };
    } catch (error) {
      return rejectWithValue(error.response.data);
    }
  }
);

export const analyzeKeyword = createAsyncThunk(
  'sources/analyzeKeyword',
  async (keywordData, { rejectWithValue }) => {
    try {
      const response = await sourceService.analyzeKeyword(keywordData);
      return response.data;
    } catch (error) {
      return rejectWithValue(error.response.data);
    }
  }
);

// Sources slice
const sourcesSlice = createSlice({
  name: 'sources',
  initialState,
  reducers: {
    clearError: (state) => {
      state.error = null;
    }
  },
  extraReducers: (builder) => {
    // Fetch sources
    builder
      .addCase(fetchSources.pending, (state) => {
        state.loading = true;
        state.error = null;
      })
      .addCase(fetchSources.fulfilled, (state, action) => {
        state.loading = false;
        state.items = action.payload;
      })
      .addCase(fetchSources.rejected, (state, action) => {
        state.loading = false;
        state.error = action.payload?.message || 'Failed to fetch sources';
      })
      // Add source
      .addCase(addSource.pending, (state) => {
        state.loading = true;
        state.error = null;
      })
      .addCase(addSource.fulfilled, (state, action) => {
        state.loading = false;
        // Add the new source to the list
        // The payload now contains the full source object
        if (action.payload && action.payload.source) {
          state.items = [...state.items, action.payload.source];
        }
      })
      .addCase(addSource.rejected, (state, action) => {
        state.loading = false;
        state.error = action.payload?.message || 'Failed to add source';
      })
      // Delete source
      .addCase(deleteSource.pending, (state) => {
        state.loading = true;
        state.error = null;
      })
      .addCase(deleteSource.fulfilled, (state, action) => {
        state.loading = false;
        // Remove the deleted source from the list
        state.items = state.items.filter(source => source.id !== action.payload.sourceId);
      })
      .addCase(deleteSource.rejected, (state, action) => {
        state.loading = false;
        state.error = action.payload?.message || 'Failed to delete source';
      })
      // Keyword analysis
      .addCase(analyzeKeyword.pending, (state) => {
        state.loading = true;
        state.error = null;
      })
      .addCase(analyzeKeyword.fulfilled, (state, action) => {
        state.loading = false;
        // Handle keyword analysis response
        // The action.payload contains the keyword analysis data
        console.log('Keyword analysis completed:', action.payload);
      })
      .addCase(analyzeKeyword.rejected, (state, action) => {
        state.loading = false;
        state.error = action.payload?.message || 'Failed to analyze keyword';
      });
  }
});

export const { clearError } = sourcesSlice.actions;
export default sourcesSlice.reducer;