server.js

const express = require('express');
const http = require('http');
const { Server } = require('socket.io');
const path = require('path');


const app = express();
const server = http.createServer(app);
const io = new Server(server);

app.use(express.static(path.join(__dirname, 'public')));
app.use(express.json({ limit: '10mb' })); // For base64 images

// --- MACHINE STATE ---
let machine = {
    power: false,
    setupComplete: false,
    isRunning: false,
    isPaused: false,
    timeLeft: 45 * 60,
    totalDuration: 45 * 60,
    status: "READY",
    mode: 'MANUAL',
    settings: { temp: 1, rinse: 1, spin: 2, soil: 1 },
    options: {
        preSoak: false, delayEnd: false, steam: false,
        drumLight: false, superSpeed: false, smartControl: false
    },
    // NEW: AI scan result
    aiScan: {
        level: null,        // 0-5
        label: null,        // "Clean" ... "Extreme"
        confidence: null,   // 0-100
        probabilities: [],
        scanning: false,
        scanned: false
    }
};

let timerInterval = null;
const PYTHON_API = 'http://localhost:5001';

io.on('connection', (socket) => {
    socket.emit('update', machine);

    socket.on('setSetting', (data) => {
        if (machine.isRunning || !machine.power) return;
        machine.settings[data.type] = parseInt(data.value);
        recalculateTime();
        io.emit('update', machine);
    });

    socket.on('selectStartMode', (selectedMode) => {
        if (!machine.power) return;
        machine.mode = selectedMode;
        machine.setupComplete = true;
        if (selectedMode === 'AUTO') {
            machine.settings = { temp: 1, rinse: 2, spin: 3, soil: 2 };
            recalculateTime();
            // Reset scan state when entering AUTO
            machine.aiScan = { level: null, label: null, confidence: null, probabilities: [], scanning: false, scanned: false };
        }
        io.emit('update', machine);
    });

    // NEW: Receive image from browser, forward to Python, apply results
    socket.on('analyzeImage', async (imageBase64) => {
        if (!machine.power || machine.mode !== 'AUTO') return;

        machine.aiScan.scanning = true;
        machine.aiScan.scanned = false;
        io.emit('update', machine);

        try {
            const response = await fetch(`${PYTHON_API}/analyze`, {
                method: 'POST',
                headers: { 'Content-Type': 'application/json' },
                body: JSON.stringify({ image: imageBase64 })
            });

            if (!response.ok) throw new Error(`Python API error: ${response.status}`);
            const result = await response.json();

            machine.aiScan = {
                level: result.level,
                label: result.label,
                confidence: result.confidence,
                probabilities: result.probabilities,
                scanning: false,
                scanned: true
            };

            // AUTO: Map dirt level → wash settings
            applyAutoSettings(result.level);
            recalculateTime();

        } catch (err) {
            console.error('AI analysis failed:', err.message);
            machine.aiScan.scanning = false;
        }

        io.emit('update', machine);
    });

    socket.on('toggleOption', (opt) => {
        if (!machine.power || machine.isRunning) return;
        machine.options[opt] = !machine.options[opt];
        recalculateTime();
        io.emit('update', machine);
    });

    socket.on('togglePlay', () => {
        if (!machine.power) return;
        if (!machine.isRunning) startCycle();
        else {
            machine.isPaused = !machine.isPaused;
            machine.status = machine.isPaused ? "PAUSED" : "RUNNING";
            io.emit('update', machine);
        }
    });

    socket.on('togglePower', () => {
        machine.power = !machine.power;
        if (!machine.power) {
            resetMachine();
            machine.setupComplete = false;
            machine.aiScan = { level: null, label: null, confidence: null, probabilities: [], scanning: false, scanned: false };
        }
        io.emit('update', machine);
    });

    socket.on('setMode', (m) => {
        if (!machine.power || machine.isRunning) return;
        machine.mode = m;
        if (m === 'AUTO') {
            machine.settings = { temp: 1, rinse: 2, spin: 3, soil: 2 };
            recalculateTime();
        }
        io.emit('update', machine);
    });
});

// Map dirt level (0-5) → wash settings
function applyAutoSettings(level) {
    const presets = [
        { temp: 0, rinse: 1, spin: 1, soil: 0 }, // 0: Clean
        { temp: 0, rinse: 1, spin: 1, soil: 0 }, // 1: Very Light
        { temp: 1, rinse: 2, spin: 2, soil: 1 }, // 2: Light
        { temp: 1, rinse: 2, spin: 2, soil: 2 }, // 3: Medium
        { temp: 2, rinse: 3, spin: 3, soil: 3 }, // 4: Heavy
        { temp: 2, rinse: 4, spin: 3, soil: 3 }, // 5: Extreme
    ];
    machine.settings = presets[level] || presets[2];
}

function recalculateTime() {
    let base = 25;
    base += machine.settings.temp * 5;
    base += machine.settings.rinse * 12;
    base += machine.settings.spin * 3;
    base += machine.settings.soil * 8;
    if (machine.options.steam) base += 20;
    if (machine.options.preSoak) base += 15;
    if (machine.options.superSpeed) base -= 10;
    if (base < 15) base = 15;
    machine.timeLeft = base * 60;
    machine.totalDuration = machine.timeLeft;
}

function startCycle() {
    machine.isRunning = true;
    machine.isPaused = false;
    machine.status = "WASHING";
    clearInterval(timerInterval);
    timerInterval = setInterval(() => {
        if (machine.isRunning && !machine.isPaused && machine.power) {
            if (machine.timeLeft > 0) {
                machine.timeLeft--;
                io.emit('update', machine);
            } else {
                machine.status = "END";
                machine.isRunning = false;
                clearInterval(timerInterval);
                io.emit('update', machine);
            }
        }
    }, 1000);
}

function resetMachine() {
    machine.isRunning = false;
    machine.isPaused = false;
    machine.status = "OFF";
    clearInterval(timerInterval);
}

server.listen(3000, () => console.log('ProWash running on http://localhost:3000'));