Dwinzo_dev/app/src/store/simulation/useVehicleStore.ts

import { create } from 'zustand';
import { immer } from 'zustand/middleware/immer';

interface VehicleStatus extends VehicleSchemaEvent {
    productId: string;
    isActive: boolean;
    idleTime: number;
    activeTime: number;
    currentLoad: number;
    distanceTraveled: number;
}

interface VehiclesStore {
    vehicles: Record<string, VehicleStatus>;

    // Vehicle actions
    addVehicle: (productId: string, event: VehicleSchemaEvent) => void;
    removeVehicle: (modelUuid: string) => void;
    updateVehicle: (
        modelUuid: string,
        updates: Partial<Omit<VehicleStatus, 'modelUuid' | 'productId'>>
    ) => void;

    // Status updates
    setVehicleActive: (modelUuid: string, isActive: boolean) => void;
    updateVehicleLoad: (modelUuid: string, load: number) => void;

    // State management
    setVehicleState: (modelUuid: string, newState: VehicleStatus['state']) => void;

    // Time tracking
    incrementActiveTime: (modelUuid: string, incrementBy: number) => void;
    incrementIdleTime: (modelUuid: string, incrementBy: number) => void;

    // Helper functions
    getVehicleById: (modelUuid: string) => VehicleStatus | undefined;
    getVehiclesByProduct: (productId: string) => VehicleStatus[];
    getActiveVehicles: () => VehicleStatus[];
    getIdleVehicles: () => VehicleStatus[];
}

export const useVehicleStore = create<VehiclesStore>()(
    immer((set, get) => ({
        vehicles: {},

        addVehicle: (productId, event) => {
            set((state) => {
                state.vehicles[event.modelUuid] = {
                    ...event,
                    isActive: false,
                    productId,
                    idleTime: 0,
                    activeTime: 0,
                    currentLoad: 0,
                    distanceTraveled: 0,
                };
            });
        },

        removeVehicle: (modelUuid) => {
            set((state) => {
                delete state.vehicles[modelUuid];
            });
        },

        updateVehicle: (modelUuid, updates) => {
            set((state) => {
                const vehicle = state.vehicles[modelUuid];
                if (vehicle) {
                    Object.assign(vehicle, updates);
                }
            });
        },

        // Status updates
        setVehicleActive: (modelUuid, isActive) => {
            set((state) => {
                const vehicle = state.vehicles[modelUuid];
                if (vehicle) {
                    vehicle.isActive = isActive;
                    if (isActive) {
                        vehicle.state = 'running';
                    } else {
                        vehicle.state = vehicle.currentLoad > 0 ? 'idle' : 'stopped';
                    }
                }
            });
        },

        updateVehicleLoad: (modelUuid, load) => {
            set((state) => {
                const vehicle = state.vehicles[modelUuid];
                if (vehicle) {
                    vehicle.currentLoad = load;
                }
            });
        },

        // State management
        setVehicleState: (modelUuid, newState) => {
            set((state) => {
                const vehicle = state.vehicles[modelUuid];
                if (vehicle) {
                    vehicle.state = newState;
                }
            });
        },

        // Time tracking
        incrementActiveTime: (modelUuid, incrementBy) => {
            set((state) => {
                const vehicle = state.vehicles[modelUuid];
                if (vehicle) {
                    vehicle.activeTime += incrementBy;
                }
            });
        },

        incrementIdleTime: (modelUuid, incrementBy) => {
            set((state) => {
                const vehicle = state.vehicles[modelUuid];
                if (vehicle) {
                    vehicle.idleTime += incrementBy;
                }
            });
        },

        // Getters
        getVehicleById: (modelUuid) => {
            return get().vehicles[modelUuid];
        },

        getVehiclesByProduct: (productId) => {
            return Object.values(get().vehicles).filter(
                v => v.productId === productId
            );
        },

        getActiveVehicles: () => {
            return Object.values(get().vehicles).filter(v => v.isActive);
        },

        getIdleVehicles: () => {
            return Object.values(get().vehicles).filter(
                v => !v.isActive && v.currentLoad > 0
            );
        }
    }))
);