server.js

const express = require('express');
const http = require('http');
const WebSocket = require('ws');
const mqtt = require('mqtt');
const SerialPort = require('serialport').SerialPort;
const { ReadlineParser } = require('@serialport/parser-readline');
const path = require('path');

const app = express();
const server = http.createServer(app);
const wss = new WebSocket.Server({ server });

app.use(express.static(__dirname));
app.get('/', (req, res) => {
    res.sendFile(path.join(__dirname, 'index.html'));
});

let serialPort;
let isConnected = false;
let serialParser;
let mqttClient;

const MQTT_URL = process.env.MQTT_URL;
const MQTT_TOPIC = process.env.MQTT_TOPIC || 'arduino-shield/dados';

function initMqtt() {
    if (!MQTT_URL) {
        console.log('MQTT desativado. Defina MQTT_URL para publicar os dados do Arduino.');
        return;
    }

    mqttClient = mqtt.connect(MQTT_URL, {
        username: process.env.MQTT_USERNAME,
        password: process.env.MQTT_PASSWORD
    });

    mqttClient.on('connect', () => {
        console.log(`MQTT conectado em ${MQTT_URL}. Publicando em ${MQTT_TOPIC}`);
    });

    mqttClient.on('error', (err) => {
        console.error('Erro MQTT:', err.message);
    });
}

function parseArduinoData(message) {
    const values = {};

    message.split('|').forEach(part => {
        const separatorIndex = part.indexOf(':');
        if (separatorIndex === -1) {
            return;
        }

        const key = part.slice(0, separatorIndex).trim();
        const value = part.slice(separatorIndex + 1).trim();

        if (key) {
            values[key] = value;
        }
    });

    return values;
}

function publishMqtt(message) {
    if (!mqttClient || !mqttClient.connected) {
        return;
    }

    const payload = {
        timestamp: new Date().toISOString(),
        raw: message,
        values: parseArduinoData(message)
    };

    mqttClient.publish(MQTT_TOPIC, JSON.stringify(payload));
}

// Inicializar porta serial
function initSerialPort() {
    try {
        // Procurar por portas COM disponíveis
        SerialPort.list().then(ports => {
            console.log('Portas disponíveis:', ports);

            if (ports.length === 0) {
                console.log('Nenhuma porta serial encontrada');
                setTimeout(initSerialPort, 5000);
                return;
            }

            // Usar a primeira porta encontrada (geralmente a do Arduino)
            const comPort = ports[0].path;
            console.log(`Conectando na porta: ${comPort}`);

            serialPort = new SerialPort({
                path: comPort,
                baudRate: 115200,
                autoOpen: true
            });

            serialParser = serialPort.pipe(new ReadlineParser({ delimiter: '\n' }));

            serialPort.on('open', () => {
                console.log('Porta serial aberta com sucesso');
                isConnected = true;
                broadcast({ status: 'CONECTADO', porta: comPort });
            });

            serialParser.on('data', (line) => {
                const message = line.toString().trim();
                console.log('Arduino:', message);

                // Enviar dados para todos os clientes WebSocket
                broadcast({ type: 'ARDUINO_DATA', data: message, values: parseArduinoData(message) });
                publishMqtt(message);
            });

            serialPort.on('error', (err) => {
                console.error('Erro na porta serial:', err.message);
                isConnected = false;
                broadcast({ status: 'DESCONECTADO', erro: err.message });
                setTimeout(initSerialPort, 5000);
            });

            serialPort.on('close', () => {
                console.log('Porta serial fechada');
                isConnected = false;
                broadcast({ status: 'DESCONECTADO' });
                setTimeout(initSerialPort, 5000);
            });

        }).catch(err => {
            console.error('Erro ao listar portas:', err);
            setTimeout(initSerialPort, 5000);
        });
    } catch (err) {
        console.error('Erro ao iniciar porta serial:', err);
        setTimeout(initSerialPort, 5000);
    }
}

// Enviar mensagem para todos os clientes WebSocket
function broadcast(message) {
    wss.clients.forEach(client => {
        if (client.readyState === WebSocket.OPEN) {
            client.send(JSON.stringify(message));
        }
    });
}

wss.on('connection', (ws) => {
    console.log('Novo cliente WebSocket conectado');

    // Enviar status de conexão ao novo cliente
    ws.send(JSON.stringify({
        status: isConnected ? 'CONECTADO' : 'DESCONECTADO'
    }));

    ws.on('message', (message) => {
        console.log('Mensagem do cliente:', message);
    });

    ws.on('close', () => {
        console.log('Cliente WebSocket desconectado');
    });
});

const PORT = 3000;
server.listen(PORT, () => {
    console.log(`Servidor rodando em http://localhost:${PORT}`);
    console.log('Aguardando conexão com Arduino...');
    initMqtt();
    initSerialPort();
});