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

// Define a type for the vehicle
export interface Vehicle {
  id: number
  carCode: string
  carDescription?: string
  ownerInformation?: string
  registrationNumber: string
  stateRegistered: string
  vehicleLocation: string
  makeId: number
  makeName: string
  modelId: number
  modelName: string
  typeId: number
  typeName: string
  year: number
  color: string
  capacity?: number
  vinNumber: string
  odometer: number
  odometerUnit: "miles" | "km"
  status: "active" | "maintenance" | "breakdown" | "inactive"
  vehicleOwnership: "nuskin" | "driver" | "third-party"
  driverId: number | null
  driverName: string | null
  driverPhone?: string | null
  dispatcherName?: string | null
  dispatcherPhone?: string | null
  stateName?: string | null
  insuranceNumber: string
  insuranceExpiry: string
  lastMaintenanceDate: string
  nextMaintenanceDate: string
}

// Define the state type
interface VehiclesState {
  items: Vehicle[]
  status: "idle" | "loading" | "succeeded" | "failed"
  error: string | null
  filters: {
    search: string
    makes: number[]
    types: number[]
    statuses: string[]
  }
}

// Initial state
const initialState: VehiclesState = {
  items: [],
  status: "idle",
  error: null,
  filters: {
    search: "",
    makes: [],
    types: [],
    statuses: [],
  },
}

// Sample data for initial development
const sampleVehicles: Vehicle[] = [
  {
    id: 1,
    carCode: "CAR001",
    carDescription: "Executive sedan for VIP transportation",
    registrationNumber: "NY-12345",
    stateRegistered: "NY",
    vehicleLocation: "New York, NY",
    makeId: 1,
    makeName: "Toyota",
    modelId: 1,
    modelName: "Camry",
    typeId: 1,
    typeName: "Sedan",
    year: 2022,
    color: "Black",
    capacity: 5,
    vinNumber: "1HGBH41JXMN109186",
    odometer: 25000,
    odometerUnit: "miles",
    status: "active",
    vehicleOwnership: "nuskin",
    driverId: 101,
    driverName: "John Smith",
    driverPhone: "+1 (555) 123-4567",
    dispatcherName: "Sarah Wilson",
    dispatcherPhone: "+1 (555) 987-6543",
    stateName: "New York",
    insuranceNumber: "INS-123456",
    insuranceExpiry: "2025-05-15",
    lastMaintenanceDate: "2023-10-20",
    nextMaintenanceDate: "2024-04-20",
  },
  {
    id: 2,
    carCode: "CAR002",
    carDescription: "Compact sedan for city use",
    registrationNumber: "CA-13579",
    stateRegistered: "CA",
    vehicleLocation: "Los Angeles, CA",
    makeId: 2,
    makeName: "Honda",
    modelId: 4,
    modelName: "Civic",
    typeId: 1,
    typeName: "Sedan",
    year: 2022,
    color: "Blue",
    capacity: 4,
    vinNumber: "1HGCM82633A123456",
    odometer: 15000,
    odometerUnit: "miles",
    status: "active",
    vehicleOwnership: "driver",
    ownerInformation: "John Smith\nPhone: +1 (555) 123-4567\nLicense: DL12345678\nAddress: 123 Main St, Los Angeles, CA",
    driverId: 101,
    driverName: "John Smith",
    driverPhone: "+1 (555) 123-4567",
    dispatcherName: "Sarah Wilson",
    dispatcherPhone: "+1 (555) 987-6543",
    stateName: "California",
    insuranceNumber: "INS-123456",
    insuranceExpiry: "2024-12-31",
    lastMaintenanceDate: "2023-10-01",
    nextMaintenanceDate: "2024-04-01",
  },
  {
    id: 3,
    carCode: "CAR003",
    carDescription: "Family SUV for group transportation",
    registrationNumber: "TX-67890",
    stateRegistered: "TX",
    vehicleLocation: "Houston, TX",
    makeId: 2,
    makeName: "Honda",
    modelId: 5,
    modelName: "CR-V",
    typeId: 2,
    typeName: "SUV",
    year: 2023,
    color: "Silver",
    capacity: 7,
    vinNumber: "2HKRM4H72NH123456",
    odometer: 15000,
    odometerUnit: "miles",
    status: "active",
    vehicleOwnership: "third-party",
    driverId: 103,
    driverName: "Michael Brown",
    driverPhone: "+1 (555) 345-6789",
    dispatcherName: "Emily Chen",
    dispatcherPhone: "+1 (555) 765-4321",
    stateName: "Texas",
    insuranceNumber: "INS-345678",
    insuranceExpiry: "2025-03-10",
    lastMaintenanceDate: "2023-11-05",
    nextMaintenanceDate: "2024-05-05",
  },
  {
    id: 4,
    carCode: "CAR004",
    carDescription: "Premium sedan for business executives",
    registrationNumber: "FL-98765",
    stateRegistered: "FL",
    vehicleLocation: "Miami, FL",
    makeId: 4,
    makeName: "Mercedes-Benz",
    modelId: 8,
    modelName: "C-Class",
    typeId: 1,
    typeName: "Sedan",
    year: 2022,
    color: "Blue",
    capacity: 5,
    vinNumber: "WDDGF4HB1NG123456",
    odometer: 20000,
    odometerUnit: "miles",
    status: "breakdown",
    vehicleOwnership: "driver",
    driverId: null,
    driverName: null,
    driverPhone: null,
    dispatcherName: null,
    dispatcherPhone: null,
    stateName: null,
    insuranceNumber: "INS-901234",
    insuranceExpiry: "2025-01-20",
    lastMaintenanceDate: "2023-12-10",
    nextMaintenanceDate: "2024-06-10",
  },
  {
    id: 5,
    carCode: "CAR005",
    carDescription: "Luxury SUV for premium service",
    registrationNumber: "IL-24680",
    stateRegistered: "IL",
    vehicleLocation: "Chicago, IL",
    makeId: 5,
    makeName: "Audi",
    modelId: 11,
    modelName: "Q5",
    typeId: 2,
    typeName: "SUV",
    year: 2021,
    color: "Red",
    capacity: 7,
    vinNumber: "WA1BNAFY2J2123456",
    odometer: 45000,
    odometerUnit: "miles",
    status: "inactive",
    vehicleOwnership: "third-party",
    ownerInformation: "Premium Ride Services LLC\nContact: Michael Johnson\nPhone: +1 (555) 789-0123\nEmail: info@premiumride.com\nBusiness License: BL987654321",
    driverId: null,
    driverName: null,
    driverPhone: null,
    dispatcherName: null,
    dispatcherPhone: null,
    stateName: null,
    insuranceNumber: "INS-567890",
    insuranceExpiry: "2024-08-05",
    lastMaintenanceDate: "2023-09-15",
    nextMaintenanceDate: "2024-03-15",
  },
];

// Define types for adding a new vehicle
export interface AddVehiclePayload {
  carCode: string
  carDescription?: string
  ownerInformation?: string
  registrationNumber: string
  stateRegistered: string
  vehicleLocation: string
  makeId: number
  modelId: number
  typeId: number
  year: number
  color: string
  capacity?: number
  vinNumber: string
  odometer: number
  odometerUnit: "miles" | "km"
  status: "active" | "maintenance" | "breakdown" | "inactive"
  vehicleOwnership: "nuskin" | "driver" | "third-party"
  driverId: number | null
  driverName: string | null
  insuranceNumber: string
  insuranceExpiry: string
  lastMaintenanceDate: string
  nextMaintenanceDate: string
}

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

// Async thunk for adding a new vehicle
export const addVehicle = createAsyncThunk(
  "vehicles/addVehicle",
  async (payload: AddVehiclePayload, { rejectWithValue, getState }) => {
    try {
      // In a real app, this would be an API call
      await new Promise((resolve) => setTimeout(resolve, 1000))

      // Get make and model names from their respective states
      const state = getState() as any
      const make = state.vehicleMakes.items.find((make: any) => make.id === payload.makeId)
      const model = state.vehicleModels.items.find((model: any) => model.id === payload.modelId)
      const type = state.vehicleTypes.items.find((type: any) => type.id === payload.typeId)

      if (!make || !model || !type) {
        return rejectWithValue("Invalid make, model, or type selected")
      }

      // Use capacity from vehicle model if not provided
      const capacity = payload.capacity || model.capacity || undefined

      // Generate a new ID (in a real app, the server would do this)
      const newVehicle: Vehicle = {
        id: Date.now(),
        makeName: make.name,
        modelName: model.name,
        typeName: type.name,
        capacity,
        ...payload,
      }

      return newVehicle
    } catch (error) {
      return rejectWithValue("Failed to add vehicle")
    }
  }
)

// Async thunk for deleting a vehicle
export const deleteVehicle = createAsyncThunk(
  "vehicles/deleteVehicle",
  async (vehicleId: number, { rejectWithValue }) => {
    try {
      // In a real app, this would be an API call
      await new Promise((resolve) => setTimeout(resolve, 1000))
      return vehicleId
    } catch (error) {
      return rejectWithValue("Failed to delete vehicle")
    }
  }
)

// Async thunk for updating a vehicle
export const updateVehicle = createAsyncThunk(
  "vehicles/updateVehicle",
  async (
    { id, vehicleData }: { id: number; vehicleData: Partial<AddVehiclePayload> },
    { rejectWithValue, getState }
  ) => {
    try {
      // In a real app, this would be an API call
      await new Promise((resolve) => setTimeout(resolve, 1000))

      const state = getState() as any
      const vehicle = state.vehicles.items.find((v: Vehicle) => v.id === id)

      if (!vehicle) {
        return rejectWithValue("Vehicle not found")
      }

      // Get updated names if IDs have changed
      let makeName = vehicle.makeName
      let modelName = vehicle.modelName
      let typeName = vehicle.typeName
      let capacity = vehicle.capacity

      if (vehicleData.makeId && vehicleData.makeId !== vehicle.makeId) {
        const make = state.vehicleMakes.items.find((make: any) => make.id === vehicleData.makeId)
        if (make) makeName = make.name
      }

      if (vehicleData.modelId && vehicleData.modelId !== vehicle.modelId) {
        const model = state.vehicleModels.items.find((model: any) => model.id === vehicleData.modelId)
        if (model) {
          modelName = model.name
          capacity = model.capacity || undefined
        }
      }

      if (vehicleData.typeId && vehicleData.typeId !== vehicle.typeId) {
        const type = state.vehicleTypes.items.find((type: any) => type.id === vehicleData.typeId)
        if (type) typeName = type.name
      }

      return {
        ...vehicle,
        ...vehicleData,
        makeName,
        modelName,
        typeName,
        capacity,
      }
    } catch (error) {
      return rejectWithValue("Failed to update vehicle")
    }
  }
)

// Create the vehicles slice
const vehiclesSlice = createSlice({
  name: "vehicles",
  initialState,
  reducers: {
    updateFilters: (state, action: PayloadAction<Partial<VehiclesState["filters"]>>) => {
      state.filters = { ...state.filters, ...action.payload }
    },
    resetFilters: (state) => {
      state.filters = initialState.filters
    },
  },
  extraReducers: (builder) => {
    builder
      .addCase(fetchVehicles.pending, (state) => {
        state.status = "loading"
      })
      .addCase(fetchVehicles.fulfilled, (state, action) => {
        state.status = "succeeded"
        state.items = action.payload
      })
      .addCase(fetchVehicles.rejected, (state, action) => {
        state.status = "failed"
        state.error = action.payload as string
      })
      .addCase(addVehicle.fulfilled, (state, action) => {
        state.items.push(action.payload)
      })
      .addCase(deleteVehicle.fulfilled, (state, action) => {
        state.items = state.items.filter((item) => item.id !== action.payload)
      })
      .addCase(updateVehicle.fulfilled, (state, action) => {
        const index = state.items.findIndex((item) => item.id === action.payload.id)
        if (index !== -1) {
          state.items[index] = action.payload
        }
      })
  },
})

export const { updateFilters, resetFilters } = vehiclesSlice.actions

export default vehiclesSlice.reducer