'use client';
import { createSlice, createAsyncThunk, PayloadAction } from '@reduxjs/toolkit';
import { getRoles, getAllRoles, getAllFeatures, getAllPermissions } from './service';
import type { RolesState, Role, Feature, Permission, AllCurrentRoles, City, RoleSearchParams, ScopingType } from './interface';

// Define API response types
interface FetchRolesResponse {
  data: {
    data: Role[];
    allCities : City[];
    allCurrentRoles: AllCurrentRoles[];
    scopingTypes: ScopingType[];
  };
}

interface FetchAllRolesResponse {
  data: {
    data: Role[];
  };
}

interface FetchFeaturesResponse {
  data: Feature[];
}

interface FetchPermissionsResponse {
  data: Permission[];
}

// Update the initial state with the correct types
const initialState: RolesState = {
  roles: [],
  allCities: [],
  allCurrentRoles: [],
  scopingTypes: [],
  status: 'loading',
  allRoles: [],
  features: [],
  permissions: [],
  error: null,
};

// Thunks with appropriate types
export const fetchRoles = createAsyncThunk('group/fetchRoles', async(params?: RoleSearchParams): Promise<FetchRolesResponse> => {
  const roles = await getRoles(params);
  return roles;
});

export const fetchAllRoles = createAsyncThunk('group/fetchAllRoles', async(): Promise<FetchAllRolesResponse> => {
  const allRoles = await getAllRoles();
  return allRoles;
});

export const fetchFeaturesList = createAsyncThunk('group/fetchFeaturesList', async(): Promise<FetchFeaturesResponse> => {
  const features = await getAllFeatures();
  return features;
});

export const fetchPermissions = createAsyncThunk(
  'group/fetchPermissions',
  async(params: number): Promise<FetchPermissionsResponse> => {
    const permissions = await getAllPermissions(params);
    return permissions;
  }
);

// Redux slice
const roleSlice = createSlice({
  name: 'role',
  initialState,
  reducers: {},
  extraReducers: (builder) => {
    builder
      .addCase(fetchRoles.pending, (state) => {
        state.status = 'loading';
      })
      .addCase(fetchRoles.fulfilled, (state, action: PayloadAction<FetchRolesResponse>) => {
        state.status = 'succeeded';
        state.roles = action.payload.data.data;
        state.allCities = action.payload.data.allCities;
        state.allCurrentRoles = action.payload.data.allCurrentRoles;
        state.scopingTypes = action.payload.data.scopingTypes;
      })
      .addCase(fetchRoles.rejected, (state, action) => {
        state.status = 'failed';
        state.error = action.error.message || null;
      })
      .addCase(fetchAllRoles.pending, (state) => {
        state.status = 'loading';
      })
      .addCase(fetchAllRoles.fulfilled, (state, action: PayloadAction<FetchAllRolesResponse>) => {
        state.status = 'succeeded';
        state.allRoles = action.payload.data.data;
      })
      .addCase(fetchAllRoles.rejected, (state, action) => {
        state.status = 'failed';
        state.error = action.error.message || null;
      })
      .addCase(fetchFeaturesList.pending, (state) => {
        state.status = 'loading';
      })
      .addCase(fetchFeaturesList.fulfilled, (state, action: PayloadAction<FetchFeaturesResponse>) => {
        state.status = 'succeeded';
        state.features = action.payload.data;
      })
      .addCase(fetchFeaturesList.rejected, (state, action) => {
        state.status = 'failed';
        state.error = action.error.message || null;
      })
      .addCase(fetchPermissions.pending, (state) => {
        state.status = 'loading';
      })
      .addCase(fetchPermissions.fulfilled, (state, action: PayloadAction<FetchPermissionsResponse>) => {
        state.status = 'succeeded';
        state.permissions = action.payload.data;
      })
      .addCase(fetchPermissions.rejected, (state, action) => {
        state.status = 'failed';
        state.error = action.error.message || null;
      });
  },
});

export default roleSlice.reducer;