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

// Define types for the payment plan
export interface PaymentPlan {
  id: number
  name: string
  description: string
  isDefault: boolean
  status: "active" | "inactive"
}

// Define the state type
interface PaymentPlansState {
  items: PaymentPlan[]
  status: "idle" | "loading" | "succeeded" | "failed"
  error: string | null
  selectedPlanId: number | null
  filters: {
    search: string
    status: string[]
  }
}

// Initial state
const initialState: PaymentPlansState = {
  items: [],
  status: "idle",
  error: null,
  selectedPlanId: null,
  filters: {
    search: "",
    status: [],
  },
}

// Sample data for initial development
const samplePaymentPlans: PaymentPlan[] = [
  {
    id: 1,
    name: "Standard Plan",
    description: "Default pricing plan for regular customers",
    isDefault: true,
    status: "active",
  },
  {
    id: 2,
    name: "Corporate Plan",
    description: "Special pricing for corporate clients with volume discounts",
    isDefault: false,
    status: "active",
  },
  {
    id: 3,
    name: "Premium Plan",
    description: "Premium pricing for luxury vehicles and services",
    isDefault: false,
    status: "active",
  },
  {
    id: 4,
    name: "Seasonal Discount",
    description: "Special pricing during holiday seasons",
    isDefault: false,
    status: "inactive",
  },
]

// Define the payload type for adding a new payment plan
export interface AddPaymentPlanPayload {
  name: string
  description: string
  isDefault: boolean
}

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

export const addPaymentPlan = createAsyncThunk(
  "paymentPlans/addPaymentPlan",
  async (payload: AddPaymentPlanPayload, { rejectWithValue, getState }) => {
    try {
      // In a real app, this would be an API call
      await new Promise((resolve) => setTimeout(resolve, 1000))

      // If this is set as default, we need to update other plans
      const state = getState() as any
      const plans = state.paymentPlans.items as PaymentPlan[]

      // Generate a new ID (in a real app, the server would do this)
      return {
        id: Date.now(),
        name: payload.name,
        description: payload.description,
        isDefault: payload.isDefault,
        status: "active" as const,
      }
    } catch (error) {
      return rejectWithValue("Failed to add payment plan")
    }
  },
)

export const updatePaymentPlan = createAsyncThunk(
  "paymentPlans/updatePaymentPlan",
  async (payload: { id: number; updates: Partial<PaymentPlan> }, { rejectWithValue }) => {
    try {
      // In a real app, this would be an API call
      await new Promise((resolve) => setTimeout(resolve, 1000))
      return payload
    } catch (error) {
      return rejectWithValue("Failed to update payment plan")
    }
  },
)

export const deletePaymentPlan = createAsyncThunk(
  "paymentPlans/deletePaymentPlan",
  async (id: number, { rejectWithValue }) => {
    try {
      // In a real app, this would be an API call
      await new Promise((resolve) => setTimeout(resolve, 1000))
      return id
    } catch (error) {
      return rejectWithValue("Failed to delete payment plan")
    }
  },
)

// Create the slice
const paymentPlansSlice = createSlice({
  name: "paymentPlans",
  initialState,
  reducers: {
    setSelectedPlan: (state, action: PayloadAction<number | null>) => {
      state.selectedPlanId = action.payload
    },
    updateFilters: (state, action: PayloadAction<Partial<PaymentPlansState["filters"]>>) => {
      state.filters = { ...state.filters, ...action.payload }
    },
    resetFilters: (state) => {
      state.filters = initialState.filters
    },
  },
  extraReducers: (builder) => {
    builder
      .addCase(fetchPaymentPlans.pending, (state) => {
        state.status = "loading"
      })
      .addCase(fetchPaymentPlans.fulfilled, (state, action) => {
        state.status = "succeeded"
        state.items = action.payload
      })
      .addCase(fetchPaymentPlans.rejected, (state, action) => {
        state.status = "failed"
        state.error = action.payload as string
      })
      .addCase(addPaymentPlan.fulfilled, (state, action) => {
        // If the new plan is default, update other plans
        if (action.payload.isDefault) {
          state.items = state.items.map((plan) => ({
            ...plan,
            isDefault: false,
          }))
        }
        state.items.push(action.payload)
      })
      .addCase(updatePaymentPlan.fulfilled, (state, action) => {
        const { id, updates } = action.payload

        // If this plan is being set as default, update other plans
        if (updates.isDefault) {
          state.items = state.items.map((plan) => ({
            ...plan,
            isDefault: plan.id === id,
          }))
        } else {
          state.items = state.items.map((plan) => (plan.id === id ? { ...plan, ...updates } : plan))
        }
      })
      .addCase(deletePaymentPlan.fulfilled, (state, action) => {
        state.items = state.items.filter((item) => item.id !== action.payload)
      })
  },
})

export const { setSelectedPlan, updateFilters, resetFilters } = paymentPlansSlice.actions

export default paymentPlansSlice.reducer