const args = process.argv;

// Vérification si un paramètre est passé, si c'est le cas c'est qu'on fournis un fichier de score pour reprendre le jeu la ou il était 
if (args[2] !== undefined) {
    global.ScoreFile = args[2]
} else {
    global.ScoreFile = "XXX.json"
}

const fs = require('fs');
const path = require('path');
const mqtt = require('mqtt');

// Fonction pour générer un nom de fichier unique
function generateUniqueFileName(baseName) {
    const now = new Date();
    const timestamp = `${now.getFullYear()}-${String(now.getMonth() + 1).padStart(2, '0')}-${String(now.getDate()).padStart(2, '0')}_${String(now.getHours()).padStart(2, '0')}H${String(now.getMinutes()).padStart(2, '0')}`;
    return `${baseName}_${timestamp}.json`;
}

// Chemin vers le dossier "score" et le fichier
global.scoreDir = path.join(__dirname, 'score');
global.filePath = path.join(scoreDir, ScoreFile); // Remplace "XX.json" par le nom de ton fichier JSON

// Vérifie si le dossier "score" existe, sinon le crée
if (!fs.existsSync(scoreDir)) {
    fs.mkdirSync(scoreDir, { recursive: true });
}

// Vérifie si le fichier existe dans le dossier "score"
fs.access(filePath, fs.constants.F_OK, (err) => {
    if (!err) {
        // Le fichier existe, on le lit et on le parse en JSON
        fs.readFile(filePath, 'utf8', (err, data) => {
            if (err) {
                console.error("Erreur de lecture du fichier :", err);
                return;
            }
            try {
                global.jsonData = JSON.parse(data);
                console.log("Propriétés importées depuis le fichier JSON :");
            } catch (parseErr) {
                console.error("Erreur de parsing JSON :", parseErr);
            }
        });
    } else {
        // Le fichier n'existe pas, on en crée un nouveau avec un nom unique dans "score"
        const newFileName = generateUniqueFileName('Score');
        const newFilePath = path.join(scoreDir, newFileName);
        const initialContent = {
            "TEAM": {
                "Red": {
                    "Name": "XXX",
                    "TotalScore": 0,
                    "RoundScore": 0,
                    "Penality": 0,
                    "MasterPoint": 0
                },
                "Blue": {
                    "Name": "XXX",
                    "TotalScore": 0,
                    "RoundScore": 0,
                    "Penality": 0,
                    "MasterPoint": 0
                },
                "Yellow": {
                    "Name": "XXX",
                    "TotalScore": 0,
                    "RoundScore": 0,
                    "Penality": 0,
                    "MasterPoint": 0
                },
                "Green": {
                    "Name": "XXX",
                    "TotalScore": 0,
                    "RoundScore": 0,
                    "Penality": 0,
                    "MasterPoint": 0
                }
            }
        };

        fs.writeFile(newFilePath, JSON.stringify(initialContent, null, 2), (err) => {
            if (err) {
                console.error("Erreur de création du fichier :", err);
                return;
            }
            console.log(`Fichier JSON créé avec succès : ${newFilePath}`);
            // Mettre à jour ScoreFile et filePath

            // Charger les données initiales si nécessaire
            global.jsonData = initialContent;
            global.filePath = newFilePath
        });
    }
});

// Fonction pour mettre à jour le score d'une équipe
function updateTeamTotalScore(teamColor, points) {
    fs.readFile(filePath, 'utf8', (err, data) => {
        if (err) {
            console.error("Erreur de lecture du fichier :", err);
            return;
        }
        try {
            const jsonData = JSON.parse(data);
            // Vérifier si l'équipe existe
            if (!jsonData.TEAM.hasOwnProperty(teamColor)) {
                console.error(`L'équipe ${teamColor} n'existe pas.`);
                return;
            }

            const change = parseInt(points, 10);

            // Mettre à jour le score
            jsonData.TEAM[teamColor].TotalScore += points;
            console.log(`Le score total pour l'équipe ${teamColor} est de ${jsonData.TEAM[teamColor].TotalScore} points !`)
            // Enregistrer les modifications dans le fichier
            client.publish(mqttScoreTopic, JSON.stringify(jsonData));
            fs.writeFile(filePath, JSON.stringify(jsonData, null, 2), (err) => {
                if (err) {
                    console.error("Erreur lors de l'écriture du fichier :", err);
                } else {
                    console.log(`Le score total de l'équipe ${teamColor} a été mis à jour avec succès dans le fichier json !`);
                }
            });
        } catch (parseErr) {
            console.error("Erreur de parsing JSON :", parseErr);
        }
    });
}


// Lecture du fichier de configuration
const configPath = path.join(__dirname, '../config/configuration.json');
const config = JSON.parse(fs.readFileSync(configPath, 'utf8'));

// Extraction des informations de config
const { mqttHost, services: { score: { MQTTconfig: { mqttScoreTopic, mqttScoreChangeTopic } } } } = config;
console.log("DEBUG: Config loaded from:", configPath);
console.log("DEBUG: MQTT Host:", mqttHost);
console.log("DEBUG: Topics:", mqttScoreTopic, mqttScoreChangeTopic);

// Connexion au broker MQTT
const client = mqtt.connect(mqttHost);

client.on('connect', () => {
    console.log(`Connecté au broker MQTT à ${mqttHost}`);

    client.subscribe(mqttScoreChangeTopic, (err) => {
        if (err) console.error('[ERROR] impossible de souscrire au topic de gestion du score total');
        else console.log(`[INFO] Souscription réalisée avec succès au topic ${mqttScoreChangeTopic}]`);
    });

});

// Gestion des messages entrants
client.on('message', (topic, message) => {
    let payload;
    let process;
    let Team;
    let Action;
    let TotalScore = null;
    let RoundScore = null;

    try {
        // Analyse du message reçu
        payload = JSON.parse(message.toString());
    } catch (e) {
        console.error(`[ERROR] Invalid JSON message received on topic ${topic}: ${message.toString()}`);
        return;
    }
    // Vérifie que le payload est bien un objet
    if (payload && typeof payload === 'object') {
        // Extraire la clé (la couleur) et la valeur associée
        Team = Object.keys(payload)[0]; // La première (et unique) clé
        let value = payload[Team];         // La valeur associée

        if (typeof value === 'object') {
            // Mode SET (valeur absolue)
            if (value.hasOwnProperty('Total')) TotalScore = parseInt(value.Total, 10);
            if (value.hasOwnProperty('Round')) RoundScore = parseInt(value.Round, 10);
            Action = "SET";
        } else {
            // Mode ADD (relatif)
            Action = value;
        }

        process = true;
    } else {
        console.error(typeof payload);
        process = false;
    }

    if (process === true) {
        if (Action === "SET") {
            // Mise à jour absolue
            updateTeamScoreAbsolute(Team, TotalScore, RoundScore);
        } else {
            // Mise à jour relative (existant)
            let change = parseInt(Action, 10);
            if (!isNaN(change)) {
                updateTeamTotalScore(Team, change);
            } else {
                console.error(`Action invalide : ${Action}`);
            }
        }
    }

});

// Fonction pour mettre à jour le score d'une équipe (Absolu)
function updateTeamScoreAbsolute(teamColor, totalScore, roundScore) {
    fs.readFile(filePath, 'utf8', (err, data) => {
        if (err) {
            console.error("Erreur de lecture du fichier :", err);
            return;
        }
        try {
            const jsonData = JSON.parse(data);
            if (!jsonData.TEAM.hasOwnProperty(teamColor)) {
                console.error(`L'équipe ${teamColor} n'existe pas.`);
                return;
            }

            if (totalScore !== null && !isNaN(totalScore)) {
                jsonData.TEAM[teamColor].TotalScore = totalScore;
            }
            if (roundScore !== null && !isNaN(roundScore)) {
                jsonData.TEAM[teamColor].RoundScore = roundScore;
            }

            console.log(`Mise à jour absolue pour ${teamColor} -> Total: ${jsonData.TEAM[teamColor].TotalScore}, Round: ${jsonData.TEAM[teamColor].RoundScore}`);

            client.publish(mqttScoreTopic, JSON.stringify(jsonData));
            fs.writeFile(filePath, JSON.stringify(jsonData, null, 2), (err) => {
                if (err) console.error("Erreur d'écriture :", err);
            });
        } catch (parseErr) {
            console.error("Erreur JSON :", parseErr);
        }
    });
}

(async () => {
    while (true) {
        console.log("Boucle en arrière-plan");

        await new Promise((resolve) => setTimeout(resolve, 2000)); // Pause de 2 secondes
        //client.publish(mqttScoreTopic, JSON.stringify(global.jsonData));
    }
})();

client.on('error', (error) => {
    console.error('Erreur de connexion au broker MQTT:', error.message);
});