import React, { useEffect, useState } from 'react';
import { useSceneContext } from '../../scene/sceneContext';
import { determineExecutionMachineSequences } from './functions/determineExecutionMachineSequences';
import { usePlayButtonStore } from '../../../store/ui/usePlayButtonStore';
import { useSimulationManager } from '../../../store/rough/useSimulationManagerStore';
import { useParams } from 'react-router-dom';
import { useSimulateId } from '../../../store/builder/store';

interface SimulationUsageRecord {
    activeTime: number;
    isActive: boolean;
    idleTime: number;
    type: "roboticArm" | "vehicle" | "transfer" | "storageUnit" | "crane" | "human" | "machine";
    assetId: string;
}

// Product → holds multiple usage records
interface ProductSimulation {
    productId: string;
    data: SimulationUsageRecord[];
}

// Version → holds multiple products
interface VersionSimulation {
    versionId: string;
    products: ProductSimulation[];
}

// Project → holds multiple versions
interface ProjectSimulation {
    projectId: string | undefined;
    versions: VersionSimulation[];
}
const SimulationHandler = () => {
    const { materialStore, armBotStore, machineStore, conveyorStore, vehicleStore, storageUnitStore, productStore, craneStore, humanStore, versionStore } = useSceneContext();
    const { armBots, getArmBotById } = armBotStore();
    const { vehicles, getVehicleById } = vehicleStore();
    const { getConveyorById } = conveyorStore();
    const { materialHistory, materials } = materialStore();
    const { getProductById, selectedProduct } = productStore();
    const { machines, getMachineById } = machineStore();
    const { getHumanById } = humanStore();
    const { getCraneById } = craneStore();
    const { getStorageUnitById } = storageUnitStore();
    const { isPlaying, setIsPlaying } = usePlayButtonStore();
    const { simulationRecords, addSimulationRecord } = useSimulationManager();
    const { projectId } = useParams();
    const [simulationEntry, setSimulationEntry] = useState<any>();
    const { setSimulateId } = useSimulateId();
    const COST_RATES: Record<SimulationUsageRecord["type"], number> = {
        roboticArm: 5,
        vehicle: 2,
        transfer: 1,
        storageUnit: 1,
        crane: 6,
        human: 4,
        machine: 3,
    };
    const { selectedVersion } = versionStore();

    // Calculate totals for one product
    function calculateProductMetrics(product: ProductSimulation) {
        let totalActiveTime = 0;
        let totalIdleTime = 0;
        let totalCost = 0;

        product.data.forEach((record) => {
            const resourceTime = record.activeTime + record.idleTime;
            const costRate = COST_RATES[record.type] || 0;

            totalActiveTime += record.activeTime;
            totalIdleTime += record.idleTime;
            totalCost += resourceTime * costRate;
        });

        return {
            totalTime: totalActiveTime + totalIdleTime,
            totalActiveTime,
            totalIdleTime,
            totalCost,
        };
    }

    // Calculate totals for a version
    function calculateVersionMetrics(version: VersionSimulation) {
        return version.products.reduce(
            (acc, product) => {
                const metrics = calculateProductMetrics(product);

                acc.totalTime += metrics.totalTime;
                acc.totalActiveTime += metrics.totalActiveTime;
                acc.totalIdleTime += metrics.totalIdleTime;
                acc.totalCost += metrics.totalCost;
                return acc;
            },
            { totalTime: 0, totalActiveTime: 0, totalIdleTime: 0, totalCost: 0 }
        );
    }

    // Efficiency score (compare across versions)
    function calculateEfficiencyScores(versions: VersionSimulation[]) {
        const versionMetrics = versions.map((v) => ({
            versionId: v.versionId,
            ...calculateVersionMetrics(v),
        }));

        const minTime = Math.min(...versionMetrics.map((m) => m.totalTime));
        const minCost = Math.min(...versionMetrics.map((m) => m.totalCost));

        return versionMetrics.map((m) => {
            const timeFactor = minTime / m.totalTime;
            const costFactor = minCost / m.totalCost;

            const efficiencyScore = 0.5 * timeFactor + 0.5 * costFactor;

            return { ...m, efficiencyScore };
        });
    }

    // useEffect(() => {
    //     const runSimulation = async () => {
    //         console.log("simulationRecords: ", simulationRecords);
    //         if (!projectId || !selectedVersion || !selectedProduct.productUuid || simulationRecords.length === 0) return;

    //         const project = simulationRecords[0];

    //         if (project) {
    //             // const scores = calculateEfficiencyScores(project.versions);
    //             // console.log("Version Comparisons:", scores);
    //         }
    //         console.log("simulationEntry: ", simulationEntry);
    //         console.log("simulationEntrysaddasd: ", useSimulationManager.getState().getProductById(projectId, selectedVersion?.versionId, selectedProduct.productUuid)?.simulateData);

    //         const data = {
    //             projectId: projectId,
    //             versionId: selectedVersion.versionId,
    //             productUuid: selectedProduct.productUuid,
    //             simulateData: useSimulationManager.getState().getProductById(projectId, selectedVersion?.versionId, selectedProduct.productUuid)?.simulateData,
    //         };

    //         const simulations = await saveSimulationData(data);
    //         console.log("simulations: ", simulations);
    //         const simulateId = localStorage.getItem("simulateId");
    //         console.log("simulateId: ", simulateId);
    //         if (simulations.message === "SimulatedData created Successfully") {
    //             console.log("simulations.data: ", simulations.data);
    //             setSimulationEntry(simulations.data);
    //             localStorage.setItem("simulateId", simulations.data);
    //             setSimulateId(simulations.data);
    //         }

    //         // else {
    //         //     console.log("djh");
    //         //     const data = {
    //         //         projectId: projectId,
    //         //         versionId: selectedVersion.versionId,
    //         //         productUuid: selectedProduct.productUuid,
    //         //         simulateId: simulateId,
    //         //         simulateData: useSimulationManager.getState().getProductById(projectId, selectedVersion?.versionId, selectedProduct.productUuid)?.simulateData,
    //         //     };
    //         //     const update = await updateSimulateData(data);
    //         //     console.log("update: ", update);
    //         // }
    //     };

    //     runSimulation();
    // }, [simulationRecords, projectId, selectedVersion, selectedProduct]);

    // useEffect(() => {
    //     console.log('simulationRecords: ', simulationRecords);
    //     if (!projectId || !selectedVersion || !selectedProduct.productUuid || simulationRecords.length === 0) return;

    //     const project = simulationRecords[0];

    //     if (project) {
    //         const scores = calculateEfficiencyScores(project.versions);
    //         console.log("Version Comparisons:", scores);
    //     }

    //     saveSimulationData({
    //         key: selectedProduct.productUuid,
    //         data: simulationRecords,
    //     });
    //     // saveSimulationData({
    //     //     key: selectedProduct.productUuid,
    //     //     data: simulationRecords,
    //     // });
    // }, [simulationRecords]);

    useEffect(() => {
        let checkTimer: ReturnType<typeof setTimeout>;
        if (!projectId) return;
        async function checkActiveMachines() {
            const currentProduct = getProductById(selectedProduct.productUuid);
            let hasActiveEntity = false;

            if (currentProduct) {
                const executionSequences = await determineExecutionMachineSequences([currentProduct]);
                if (executionSequences?.length > 0) {
                    executionSequences.forEach((sequence) => {
                        sequence.forEach((entity) => {
                            if (entity.type === "roboticArm") {
                                const roboticArm = getArmBotById(entity.modelUuid);
                                if (roboticArm?.isActive) {
                                    hasActiveEntity = true;
                                }
                            }
                            if (entity.type === "vehicle") {
                                const vehicle = getVehicleById(entity.modelUuid);
                                if (vehicle?.isActive) {
                                    hasActiveEntity = true;
                                }
                            }
                            if (entity.type === "machine") {
                                const machine = getMachineById(entity.modelUuid);
                                if (machine?.isActive) {
                                    hasActiveEntity = true;
                                }
                            }
                            if (entity.type === "human") {
                                const human = getHumanById(entity.modelUuid);
                                if (human?.isActive) {
                                    hasActiveEntity = true;
                                }
                            }
                            if (entity.type === "crane") {
                                const crane = getCraneById(entity.modelUuid);
                                if (crane?.isActive) {
                                    hasActiveEntity = true;
                                }
                            }
                            if (entity.type === "storageUnit") {
                                const storageUnit = getStorageUnitById(entity.modelUuid);
                                if (storageUnit?.isActive) {
                                    hasActiveEntity = true;
                                }
                            }
                            if (entity.type === "transfer") {
                                const storageUnit = getConveyorById(entity.modelUuid);
                                if (storageUnit?.isActive) {
                                    hasActiveEntity = true;
                                }
                            }
                        });
                    });
                }

                if (materials.length === 0 && materialHistory.length >= 0 && !hasActiveEntity) {
                    if (executionSequences?.length > 0) {
                        executionSequences.forEach((sequence) => {
                            sequence.forEach((entity) => {
                                const typeToGetter: Record<string, (id: string) => any> = {
                                    roboticArm: getArmBotById,
                                    vehicle: getVehicleById,
                                    machine: getMachineById,
                                    human: getHumanById,
                                    crane: getCraneById,
                                    storageUnit: getStorageUnitById,
                                    transfer: getConveyorById,
                                };

                                const getter = typeToGetter[entity.type];
                                if (!getter) return; // skip unknown entity types

                                const obj = getter(entity.modelUuid);
                                if (!obj) return; // skip if not found

                                addSimulationRecord(projectId, selectedVersion?.versionId || "", selectedProduct?.productUuid, {
                                    activeTime: obj.activeTime ?? 0,
                                    isActive: obj.isActive ?? false,
                                    idleTime: obj.idleTime ?? 0,
                                    type: entity.type as "roboticArm" | "vehicle" | "machine" | "human" | "crane" | "storageUnit" | "transfer",
                                    assetId: entity.modelUuid,
                                });
                            });
                        });
                    }
                    setIsPlaying(false);
                }
            }
        }

        if (isPlaying) {
            checkTimer = setTimeout(() => {
                checkActiveMachines();
            }, 1500);
        }

        return () => {
            if (checkTimer) clearTimeout(checkTimer);
        };
    }, [materials, materialHistory, selectedVersion, selectedProduct?.productUuid, isPlaying, armBots, vehicles, machines]);

    return null;
};

export default SimulationHandler;
