const express = require('express');
const path = require('path');
const fs = require('fs');
const yaml = require('js-yaml');

const app = express();

// Activer le middleware JSON pour parser le corps des requêtes
app.use(express.json());
app.use(express.urlencoded({ extended: true })); // Si vous utilisez des requêtes POST de type formulaire

// Charger config.yaml
const config = yaml.load(fs.readFileSync('config.yaml', 'utf8'));

// Route pour récupérer les données utilisateur
app.get('/user/:username', (req, res) => {
    const username = req.params.username;
    const userFilePath = path.join(__dirname, `data/${username}.yaml`);

    try {
        const userData = yaml.load(fs.readFileSync(userFilePath, 'utf8'));
        res.json(userData);
    } catch (error) {
        res.status(404).json({ error: "Utilisateur non trouvé" });
    }
});

// Route pour mettre à jour la position d'un utilisateur
app.post('/update-position', (req, res) => {
    const { username, latitude, longitude } = req.body;
    const filePath = `./data/${username}.yaml`;

    try {
        if (fs.existsSync(filePath)) {
            const data = yaml.load(fs.readFileSync(filePath, 'utf8'));
            data.position_actuelle = {
                latitude,
                longitude,
                last_update: new Date().toISOString(),
            };
            fs.writeFileSync(filePath, yaml.dump(data));
            res.status(200).json({ message: 'Position mise à jour avec succès.' });
        } else {
            res.status(404).json({ error: 'Fichier utilisateur introuvable.' });
        }
    } catch (error) {
        res.status(500).json({ error: 'Erreur lors de la mise à jour de la position.' });
    }
});



// Servir les fichiers statiques
app.use('/static', express.static(path.join(__dirname, 'static')));

// Page principale
app.get('/', (req, res) => res.sendFile(path.join(__dirname, 'index.html')));

app.listen(config.port, () => {
    console.log(`Serveur démarré sur http://localhost:${config.port}`);
});

// Route pour servir la page de supervision
app.get('/supervise', (req, res) => {
    res.sendFile(path.join(__dirname, 'supervise.html'));
});
// Route pour récupérer les données de Baptiste
app.get('/data/baptiste.yaml', (req, res) => {
    const userFilePath = path.join(__dirname, 'data/baptiste.yaml');
    const configFilePath = path.join(__dirname, 'config.yaml');

    try {
        const userData = yaml.load(fs.readFileSync(userFilePath, 'utf8'));
        const config = yaml.load(fs.readFileSync(configFilePath, 'utf8'));
// Inclure le décalage des pins dans la réponse
userData.pin_offset = config.pin_offset;

        res.json(userData);
    } catch (error) {
        console.error("Erreur lors de la récupération des données :", error.message);
        res.status(500).json({ error: "Impossible de récupérer les données" });
    }
});

// Route pour la page de Julien
app.get('/julien', (req, res) => {
    res.sendFile(path.join(__dirname, 'index_julien.html'));
});

/// Route pour récupérer les données de Julien
app.get('/data/julien.yaml', (req, res) => {
    const userFilePath = path.join(__dirname, 'data/julien.yaml');
    const configFilePath = path.join(__dirname, 'config.yaml');

    try {
        const userData = yaml.load(fs.readFileSync(userFilePath, 'utf8'));
        const config = yaml.load(fs.readFileSync(configFilePath, 'utf8'));
// Inclure le décalage des pins dans la réponse
userData.pin_offset = config.pin_offset;

        res.json(userData);
    } catch (error) {
        console.error("Erreur lors de la récupération des données :", error.message);
        res.status(500).json({ error: "Impossible de récupérer les données" });
    }
});

// Servir les fichiers statiques des tuiles
app.use('/tiles', express.static(path.join(__dirname, 'tiles')));


// Route pour marquer un défi comme résolu
app.post('/mark-challenge-resolved', (req, res) => {
    const { username, challengeKey,  } = req.body; // Extraction des données de la requête

    if (!username || !challengeKey) {
        console.error("Requête invalide : données manquantes");
        return res.status(400).json({ error: "Les champs username et challengeKey sont requis." });
    }

    const userFilePath = path.join(__dirname, `data/${username}.yaml`);

    // Vérification que le fichier existe
    if (!fs.existsSync(userFilePath)) {
        console.error(`Fichier utilisateur non trouvé : ${userFilePath}`);
        return res.status(404).json({ error: `Utilisateur ${username} non trouvé.` });
    }

    try {
        console.log(`Tentative de marquer comme résolu pour ${username}, défi : ${challengeKey}`);

        const userData = yaml.load(fs.readFileSync(userFilePath, 'utf8'));

        // Vérification de l'existence du défi
        if (!userData.defis || !userData.defis[challengeKey]) {
            console.error(`Défi ${challengeKey} non trouvé pour ${username}`);
            return res.status(400).json({ error: `Défi ${challengeKey} non trouvé.` });
        }

        // Mise à jour du statut "resolu" pour le défi
        userData.defis[challengeKey].resolu = "oui";

        // Sauvegarde des données dans le fichier YAML
        fs.writeFileSync(userFilePath, yaml.dump(userData), 'utf8');

        console.log(`Défi ${challengeKey} mis à jour avec succès pour ${username}`);
        res.json({ success: true, message: `Défi ${challengeKey} marqué comme résolu.` });
    } catch (error) {
        console.error(`Erreur lors de la mise à jour du défi pour ${username} :`, error.message);
        res.status(500).json({ error: "Impossible de mettre à jour le défi." });
    }
});

// Route pour la page "perdu"
app.get('/perdu', (req, res) => {
    res.sendFile(path.join(__dirname, 'perdu.html'));
});

// Route pour la page "gagne_b"
app.get('/gagne_b', (req, res) => {
    res.sendFile(path.join(__dirname, 'gagne_b.html'));
});

// Route pour la page "gagne_j"
app.get('/gagne_j', (req, res) => {
    res.sendFile(path.join(__dirname, 'gagne_j.html'));
});

// Route pour la page "defi1_b"
app.get('/defi1_b', (req, res) => { 
    res.sendFile(path.join(__dirname, 'defi1_b.html'));
}
);

// Route pour la page "defi2_b"
app.get('/defi2_b', (req, res) => { 
    res.sendFile(path.join(__dirname, 'defi2_b.html'));
}           
);
// Route pour la page "defi3_b"
app.get('/defi3_b', (req, res) => {
    res.sendFile(path.join(__dirname, 'defi3_b.html'));
}       
);
// Route pour la page "defi4_b"
app.get('/defi4_b', (req, res) => { 
    res.sendFile(path.join(__dirname, 'defi4_b.html'));
}       
);
// Route pour la page "defi5_b"
app.get('/defi5_b', (req, res) => {
    res.sendFile(path.join(__dirname, 'defi5_b.html'));
}   
);
// Route pour la page "defi6_b"
app.get('/defi6_b', (req, res) => { 
    res.sendFile(path.join(__dirname, 'defi6_b.html'));
}   
);
// Route pour la page "defi1_j"
app.get('/defi1_j', (req, res) => {
    res.sendFile(path.join(__dirname, 'defi1_j.html'));
}   
);
// Route pour la page "defi2_j"
app.get('/defi2_j', (req, res) => {
    res.sendFile(path.join(__dirname, 'defi2_j.html'));
}
);
// Route pour la page "defi3_j"
app.get('/defi3_j', (req, res) => { 
    res.sendFile(path.join(__dirname, 'defi3_j.html'));
}   
);
// Route pour la page "defi4_j" 
app.get('/defi4_j', (req, res) => { 
    res.sendFile(path.join(__dirname, 'defi4_j.html'));
}
);
// Route pour la page "defi5_j" 
app.get('/defi5_j', (req, res) => {
    res.sendFile(path.join(__dirname, 'defi5_j.html'));
}
);
// Route pour la page "defi6_j"
app.get('/defi6_j', (req, res) => {
    res.sendFile(path.join(__dirname, 'defi6_j.html'));
}
);

// Route pour la page "final1_j"
app.get('/final1_j', (req, res) => {
    res.sendFile(path.join(__dirname, 'final1_j.html'));
}
);
// Route pour la page "final1_b"
app.get('/final1_b', (req, res) => {
    res.sendFile(path.join(__dirname, 'final1_b.html'));
}
);

// Route pour récupérer les données du fichier YAML
app.get('/defis', (req, res) => {
    try {
        const data = yaml.load(fs.readFileSync('./data/defi_j.yaml', 'utf8'));
        console.log('Données chargées depuis YAML :', data);
        res.json(data.defis);
    } catch (error) {
        res.status(500).json({ error: 'Erreur lors de la lecture du fichier YAML.' });
    }
});

// Route pour récupérer les données du fichier YAML
app.get('/defis_b', (req, res) => {
    try {
        const data = yaml.load(fs.readFileSync('./data/defi_b.yaml', 'utf8'));
        console.log('Données chargées depuis YAML :', data);
        res.json(data.defis);
    } catch (error) {
        res.status(500).json({ error: 'Erreur lors de la lecture du fichier YAML.' });
    }
});

app.use(express.static('static'));

// Charger les données d'un utilisateur
app.get('/data/:username.yaml', (req, res) => {
    const username = req.params.username;
    const filePath = `./data/${username}.yaml`; // Chemin vers le fichier YAML

    try {
        if (fs.existsSync(filePath)) {
            const userData = yaml.load(fs.readFileSync(filePath, 'utf8'));
            res.json(userData);
        } else {
            res.status(404).json({ error: 'Fichier utilisateur non trouvé' });
        }
    } catch (error) {
        res.status(500).json({ error: 'Erreur lors de la lecture du fichier utilisateur' });
    }
});

function updateDefisAsResolved() {
    fetch(`/resolve-defi`, {
        method: 'POST',
        headers: {
            'Content-Type': 'application/json',
        },
        body: JSON.stringify({
            username,
            defi,
        }),
    })
        .then((response) => {
            if (response.ok) {
                console.log(`Défi ${defi} pour l'utilisateur ${username} marqué comme résolu.`);
                console.log('Mise à jour effectuée sur le serveur.');
                window.location.href = 'https://jeu.maison43.duckdns.org/final1_j';
            } else {
                console.error('Erreur lors de la mise à jour du défi.');
            }
        })
        .catch((error) => {
            console.error('Erreur réseau lors de la mise à jour du défi :', error);
        });
}

app.post('/resolve-defi', (req, res) => {
    const { username, defi } = req.body;
    const userFile = `./data/${username}.yaml`;
    const globalFile = './data/defi_j.yaml';

    try {
        // Charger et modifier julien.yaml
        const userData = yaml.load(fs.readFileSync(userFile, 'utf8'));
        userData.defis[`defi_${defi}`].resolu = 'oui';
        fs.writeFileSync(userFile, yaml.dump(userData));
        console.log(`Fichier ${userFile} mis à jour pour le défi ${defi}.`);

        // Charger et modifier defi_j.yaml
        const globalData = yaml.load(fs.readFileSync(globalFile, 'utf8'));
        globalData.defis[`defi_${defi}`].resolu = 'oui';
        fs.writeFileSync(globalFile, yaml.dump(globalData));
        console.log(`Fichier ${globalFile} mis à jour pour le défi ${defi}.`);

        res.status(200).send({ message: 'Défi résolu.' });
    } catch (error) {
        console.error('Erreur lors de la mise à jour des fichiers :', error);
        res.status(500).send({ error: 'Erreur lors de la mise à jour.' });
    }
});

app.post('/resolve-defi_b', (req, res) => {
    const { username, defi } = req.body;
    const userFile = `./data/${username}.yaml`;
    const globalFile = './data/defi_b.yaml';

    try {
        // Charger et modifier baptiste.yaml
        const userData = yaml.load(fs.readFileSync(userFile, 'utf8'));
        userData.defis[`defi_${defi}`].resolu = 'oui';
        fs.writeFileSync(userFile, yaml.dump(userData));
        console.log(`Fichier ${userFile} mis à jour pour le défi ${defi}.`);

        // Charger et modifier defi_j.yaml
        const globalData = yaml.load(fs.readFileSync(globalFile, 'utf8'));
        globalData.defis[`defi_${defi}`].resolu = 'oui';
        fs.writeFileSync(globalFile, yaml.dump(globalData));
        console.log(`Fichier ${globalFile} mis à jour pour le défi ${defi}.`);

        res.status(200).send({ message: 'Défi résolu.' });
    } catch (error) {
        console.error('Erreur lors de la mise à jour des fichiers :', error);
        res.status(500).send({ error: 'Erreur lors de la mise à jour.' });
    }
});


// Servir les fichiers statiques
app.use(express.static(path.join(__dirname, 'public')));

// Route pour la page de lecture de QR Code
app.get('/qrcode-reader', (req, res) => {
    res.sendFile(path.join(__dirname, 'public', 'qrcode_reader.html'));
});

// Route pour la page final2_b.html
app.get('/final2_b', (req, res) => {
    res.sendFile(path.join(__dirname, 'final2_b.html'));
});

// Route pour la page final2_j.html
app.get('/final2_j', (req, res) => {
    res.sendFile(path.join(__dirname, 'final2_j.html'));
});

// Route pour mettre à jour le fichier YAML
app.post('/update_yaml', (req, res) => {
    const data = req.body;
    console.log('--- Requête reçue pour mise à jour du YAML ---');
    console.log('Données reçues :', JSON.stringify(data, null, 2));

    try {
        // Convertir les données JSON en YAML
        const yamlData = yaml.dump(data);
        console.log('Données converties en YAML :');
        console.log(yamlData);

        // Écrire dans le fichier YAML
        fs.writeFileSync('data/baptiste_final.yaml', yamlData, 'utf8');
        console.log('Fichier YAML mis à jour avec succès.');
        res.status(200).send({ message: 'Fichier YAML mis à jour avec succès' });
    } catch (error) {
        console.error('Erreur lors de la mise à jour du fichier YAML:', error);
        res.status(500).send({ message: 'Erreur lors de la mise à jour du fichier YAML' });
    }
});