const express = require('express');
const fs = require('fs');
const path = require('path');
const { execFile } = require('child_process');
const cors = require('cors');

const router = express.Router();
const RECEIPT_DIR = path.join(__dirname, 'bonuri');
const CMD_PATH = path.join(__dirname, 'datecs', 'dude-cmd.exe');

router.use(express.json());
router.use(cors()); // Permite cereri de la orice IP

function runDudeCmdWithInputFile(inputFilePath, callback) {
    const command = [
        "--rs232", 
        "--rs232-port", "1",
        "--rs232-baud", "115200",
        "--input", inputFilePath,
        "--language", "ro"
    ];

    console.log(`Executing: ${CMD_PATH} ${command.join(" ")}`);

    execFile(CMD_PATH, command, (error, stdout, stderr) => {
        if (error) {
            console.error("ERROR executing dude-cmd.exe");
            console.error("Exit Code:", error.code);
            console.error("STDOUT:", stdout.trim());
            console.error("STDERR:", stderr.trim());

            let errorMessage = "Eroare la procesarea comenzii.";

            if (stdout.includes("Timeout expired. (-6)")) {
                errorMessage = "Casa de marcat nu răspunde. Verificați conexiunea.";
            } else if (stdout.includes("-100403")) {  // Verificăm eroarea -100403
                errorMessage = "Lipsa hartie";
            } else if (stdout.includes("-100404")) {  // Verificăm eroarea -100403
                errorMessage = "Capac Deschis";
            } else if (stdout.includes("-100405")) {  // Verificăm eroarea -100403
                errorMessage = "Atentie! Se termina hartia";
            } else if (stdout.includes("-110811")) {  // Verificăm eroarea -100403
                errorMessage = "S-au depasit 24 ore de la deschiderea turei Emiteti un Raport Z";
            }

            return callback(false, errorMessage);
        }

        console.log("Command executed successfully!");
        console.log("STDOUT:", stdout.trim());
        console.log("STDERR:", stderr.trim());

        callback(true, "Raport generat cu succes.");
    });
}

router.post('/print-receipt', (req, res) => {
    console.log("Received request on /print-receipt");
    const data = req.body;

    if (!data || !Array.isArray(data.products) || data.products.length === 0) {
        return res.status(400).json({ status: "error", message: "No products provided" });
    }

    const modIncasare = Array.isArray(data.mod_incasare) ? data.mod_incasare : [];
    const cuiBon = data.CuiBon || {};
    const cuiClient = cuiBon.cuiclient || '';
    
    let commands = [];
    let total_price = 0.0;

    // Generarea comenzilor pentru fiecare produs (format Daisy)
    data.products.forEach(product => {
        const product_name = product.product_name || 'Product';
        const quantity = product.quantity || 0;
        const unit_price = product.unit_price || 0;
        const total_price_product = product.total_price || (quantity * unit_price);
        const vat_rate = product.vat_rate || 0;
        const id_cota = product.id_cota || 0;

        total_price += total_price_product;

        // P linie - pentru denumire produs
        commands.push(`P,1,______,_,__;${product_name};;;;;`);
        // E linie - pentru detalii produs (preț, cantitate, TVA)
        commands.push(`E,1,______,_,__;;${unit_price.toFixed(2)};${quantity.toFixed(3)};;;${id_cota};0;;0;`);
    });

    // Adăugăm comanda cu cuiclient după ultimul produs, înainte de metoda de plată
    if (cuiClient) {
        commands.push(`39,1,______,_,__;${cuiClient};;;`);
    }

    // Adăugăm comenzile pentru metodele de plată
    modIncasare.forEach(payment => {
        const id_incasare = payment.id_incasare;
        const valoare_total = payment.valoare_total;
        
        if (id_incasare != null && valoare_total != null) {
            commands.push(`T,1,______,_,__;${id_incasare};${valoare_total.toFixed(2)};;;`);
        }
    });

    // Generare nume fișier unic cu timestamp
    const now = new Date();
    const timestamp = `${now.getFullYear()}${(now.getMonth()+1).toString().padStart(2,'0')}${now.getDate().toString().padStart(2,'0')}${now.getHours().toString().padStart(2,'0')}${now.getMinutes().toString().padStart(2,'0')}${now.getSeconds().toString().padStart(2,'0')}`;
    const uniqueFilename = `bon_${timestamp}.txt`;
    const receiptPath = path.join(RECEIPT_DIR, uniqueFilename);

    // Asigură-te că directorul există
    if (!fs.existsSync(RECEIPT_DIR)) {
        fs.mkdirSync(RECEIPT_DIR, { recursive: true });
    }

    try {
        // Scrie comenzile în fișier (fiecare comandă pe linie separată)
        fs.writeFileSync(receiptPath, commands.join("\n") + "\n", 'utf8');
        
        console.log(`✅ Bon fiscal generat și salvat în: ${receiptPath}`);
        console.log(`📋 Comenzi generate: ${commands.length} linii`);
        console.log(`💰 Valoare totală: ${total_price.toFixed(2)}`);
        
        // Returnează răspunsul de succes
        return res.json({ 
            status: "success", 
            message: "Receipt saved successfully",
            commands: commands,
            total_price: total_price.toFixed(2),
            fileName: uniqueFilename,
            filePath: receiptPath,
            timestamp: timestamp
        });
        
    } catch (error) {
        console.error("Error writing file:", error);
        return res.status(500).json({ 
            status: "error", 
            message: "Failed to write receipt file",
            error: error.message 
        });
    }
});

router.post('/introducere', async (req, res) => {
    try {
        const { suma, actiune } = req.body;

        // Verificăm dacă `suma` și `actiune` sunt valide
        if (typeof suma !== 'number') {
            return res.status(400).json({ status: "error", message: "Invalid or missing 'suma'" });
        }
        if (![0, 1].includes(actiune)) {
            return res.status(400).json({ status: "error", message: "'actiune' must be 0 (introducere) or 1 (scoatere)" });
        }

        // Creăm comanda în formatul Daisy
        const command = `I,1,______,_,__;${actiune};${suma.toFixed(2)};;;;`;

        // Creăm directorul dacă nu există
        if (!fs.existsSync(RECEIPT_DIR)) {
            fs.mkdirSync(RECEIPT_DIR, { recursive: true });
        }

        // Calea fișierului - la fel ca în Python (bon.txt)
        const receiptPath = path.join(RECEIPT_DIR, `bon.txt`);

        // Scriem fișierul
        try {
            fs.writeFileSync(receiptPath, command + "\n", 'utf8');
            console.log(`✅ Operație de ${actiune === 0 ? 'introducere' : 'scoatere'} salvată în: ${receiptPath}`);
            console.log(`📄 Comanda generată: ${command}`);
            console.log(`💰 Suma: ${suma.toFixed(2)}`);
            
            return res.json({ 
                status: "success", 
                message: "Cash amount recorded and saved",
                command: command.trim(),
                actiune: actiune,
                suma: suma,
                filePath: receiptPath
            });
            
        } catch (error) {
            console.error("Error writing file:", error);
            return res.status(500).json({ 
                status: "error", 
                message: "Failed to write receipt file",
                error: error.message 
            });
        }

    } catch (error) {
        console.error("Unexpected error:", error);
        return res.status(500).json({ 
            status: "error", 
            message: "Internal server error",
            error: error.message 
        });
    }
});

router.post('/raport', async (req, res) => {
    try {
        const { suma, actiune, actiune2 } = req.body;

        // Validare - suma este obligatorie și trebuie să fie număr
        if (suma === undefined || !isFinite(suma)) {
            const errorMessage = "Invalid or missing 'suma'";
            console.log(" Error sent to frontend:", errorMessage);
            return res.status(400).json({ status: "error", message: errorMessage });
        }

        // Validare - actiune este obligatorie și trebuie să fie string
        if (!actiune || typeof actiune !== 'string') {
            const errorMessage = "Invalid or missing 'actiune'";
            console.log(" Error sent to frontend:", errorMessage);
            return res.status(400).json({ status: "error", message: errorMessage });
        }

        // Creăm comanda în formatul Daisy
        const command = `X,1,______,_,__;${actiune};${suma.toFixed(2)};${actiune2 || ''};;;`;

        // Asigură-te că directorul există
        if (!fs.existsSync(RECEIPT_DIR)) {
            fs.mkdirSync(RECEIPT_DIR, { recursive: true });
        }

        // Calea către fișierul raport_x.txt (la fel ca în Python)
        const receiptPath = path.join(RECEIPT_DIR, 'raport_x.txt');

        try {
            // Scrie comanda în fișier
            fs.writeFileSync(receiptPath, command + "\n", 'utf8');
            
            console.log(`✅ Comanda pentru raportul X a fost salvată în: ${receiptPath}`);
            console.log(`📄 Comanda generată: ${command}`);
            
            return res.json({ 
                status: "success", 
                message: "Raportul X a fost printat și salvat",
                command: command.trim(),
                actiune: actiune,
                suma: suma.toFixed(2),
                actiune2: actiune2 || '',
                filePath: receiptPath
            });
            
        } catch (error) {
            const errorMessage = "Failed to write receipt file";
            console.log("❌ Error sent to frontend:", errorMessage);
            console.error("Error writing file:", error);
            return res.status(500).json({ status: "error", message: errorMessage });
        }

    } catch (error) {
        const errorMessage = "Internal server error";
        console.log("❌ Error sent to frontend:", errorMessage);
        console.error("Unexpected error:", error);
        return res.status(500).json({ status: "error", message: errorMessage }); 
    }
});
module.exports = router;
