import { createSlice, createAsyncThunk, type PayloadAction } from "@reduxjs/toolkit"

// Define a type for the role
export interface Role {
  id: number
  name: string
  parentRole: string | null
  departmentId: number
  departmentName: string
  teamMembersCount: number
  businessVerticalId: number | null
  businessVerticalName: string
  permissionsCount: number
}

// Define the state type
interface RolesState {
  items: Role[]
  status: "idle" | "loading" | "succeeded" | "failed"
  error: string | null
  selectedRole: Role | null
  filters: {
    search: string
    departments: string[]
    businessVerticals: string[]
  }
}

// Initial state
const initialState: RolesState = {
  items: [],
  status: "idle",
  error: null,
  selectedRole: null,
  filters: {
    search: "",
    departments: [],
    businessVerticals: [],
  },
}

// Sample data for initial development
const sampleRoles: Role[] = [
  {
    id: 1,
    name: "Super Admin",
    parentRole: null,
    departmentId: 2,
    departmentName: "Administration",
    teamMembersCount: 3,
    businessVerticalId: null,
    businessVerticalName: "All",
    permissionsCount: 42,
  },
  {
    id: 2,
    name: "Driver",
    parentRole: null,
    departmentId: 1,
    departmentName: "Operations",
    teamMembersCount: 18,
    businessVerticalId: 1,
    businessVerticalName: "Transport",
    permissionsCount: 8,
  },
  // More sample data can be added here
]

// Async thunks for API calls
export const fetchRoles = createAsyncThunk("roles/fetchRoles", async (_, { rejectWithValue }) => {
  try {
    // In a real app, this would be an API call
    await new Promise((resolve) => setTimeout(resolve, 1000))
    return sampleRoles
  } catch (error) {
    return rejectWithValue("Failed to fetch roles")
  }
})

// Create the slice
const rolesSlice = createSlice({
  name: "roles",
  initialState,
  reducers: {
    setSelectedRole: (state, action: PayloadAction<Role | null>) => {
      state.selectedRole = action.payload
    },
    updateFilters: (state, action: PayloadAction<Partial<RolesState["filters"]>>) => {
      state.filters = { ...state.filters, ...action.payload }
    },
    resetFilters: (state) => {
      state.filters = initialState.filters
    },
  },
  extraReducers: (builder) => {
    builder
      .addCase(fetchRoles.pending, (state) => {
        state.status = "loading"
      })
      .addCase(fetchRoles.fulfilled, (state, action) => {
        state.status = "succeeded"
        state.items = action.payload
      })
      .addCase(fetchRoles.rejected, (state, action) => {
        state.status = "failed"
        state.error = action.payload as string
      })
  },
})

export const { setSelectedRole, updateFilters, resetFilters } = rolesSlice.actions

export default rolesSlice.reducer