const express = require('express');
const fs = require('fs');
const path = require('path');
const router = express.Router();
const fileUpload = require('express-fileupload');
const authMiddleware = require('../../../Middlewares/authMiddleware');
const { loggers } = require('winston');
const ncp = require('ncp').ncp;
const bodyParser = require('body-parser');
const crypto = require('crypto');
const os = require('os');
const { getUserData, getSetupData } = require('../../../Middlewares/watcherMiddleware');

let configFile = fs.readFileSync(path.join(__dirname, '../../../data', 'setup.json'), 'utf-8');
let config = JSON.parse(configFile)[0];
let setupData = getSetupData();
let userData = getUserData();

// Fonction utilitaire pour lire le fichier de collaboration
async function getCollaborativeAccess(userId) {
    try {
        const collaborationFilePath = path.join(__dirname, '../../../data', 'collaboration.json');
        if (!fs.existsSync(collaborationFilePath)) {
            return [];
        }
        const data = JSON.parse(await fs.promises.readFile(collaborationFilePath, 'utf8'));
        
        const sharedFolders = [];

        for (const [itemId, item] of Object.entries(data.activeFiles)) {
            // Ne chercher que les utilisateurs qui ne sont pas le propriétaire
            if (item.type === 'folder' && 
                item.isCollaborative && 
                item.activeUsers.some(u => u.id === userId)) {
                
                // Extraire le nom du propriétaire du dossier depuis cdn-files
                const folderPath = item.name;
                const ownerFolder = path.join(__dirname, '../../../cdn-files');
                
                // Parcourir tous les dossiers utilisateurs
                const users = await fs.promises.readdir(ownerFolder);
                for (const user of users) {
                    const userFolderPath = path.join(ownerFolder, user, folderPath);
                    if (fs.existsSync(userFolderPath)) {
                        sharedFolders.push({
                            originalPath: `${user}/${folderPath}`,
                            displayName: `${user}/${folderPath}`,
                            owner: user,
                            folderName: folderPath,
                            activeUsers: item.activeUsers
                        });
                        break; // On a trouvé le propriétaire, on peut arrêter
                    }
                }
            }
        }
        return sharedFolders;
    } catch (error) {
        console.error('Error getting collaborative access:', error);
        return [];
    }
}

router.use(bodyParser.json());

router.get('/', authMiddleware, async (req, res) => {
    const folderName = req.params.folderName || '';  
   
    if (!req.userData || !req.userData.name) {
        return res.render('error-recovery-file', { error: 'User data is undefined or incomplete' });
    }

    const userId = req.userData.id;
    const userName = req.userData.name;
    const downloadDir = path.join('cdn-files', userName);
    const domain = config.domain || 'swiftlogic-labs.com';

    if (!fs.existsSync(downloadDir)) {
        fs.mkdirSync(downloadDir, { recursive: true });
    }

    try {
        // Lire les fichiers du répertoire de l'utilisateur
        const files = await fs.promises.readdir(downloadDir);
        
        // Séparer les fichiers et les dossiers
        const fileDetails = await Promise.all(files.map(async file => {
            const filePath = path.join(downloadDir, file);
            const stats = await fs.promises.stat(filePath);
            const isDirectory = stats.isDirectory();
            const fileExtension = isDirectory ? null : path.extname(file).toLowerCase();
            const encodedFileName = encodeURIComponent(file);
            const fileLink = isDirectory ? null : `https://${domain}/attachments/${userId}/${encodedFileName}`;
            
            return {
                name: file,
                size: stats.size,
                url: fileLink,
                extension: fileExtension,
                type: isDirectory ? 'folder' : 'file',
                isPersonal: true,
                owner: userName,
                isCollaborative: false,
                activeUsers: []
            };
        }));

        // Séparer les dossiers personnels et les fichiers
        const personalFolders = fileDetails.filter(item => item.type === 'folder');
        const personalFiles = fileDetails.filter(item => item.type === 'file');
        
        // Obtenir les dossiers partagés
        const sharedFolders = await getCollaborativeAccess(userId);

        // Formater les dossiers partagés
        const sharedFolderDetails = sharedFolders.map(folder => ({
            name: folder.displayName,
            type: 'shared-folder',
            isCollaborative: true,
            originalPath: folder.originalPath,
            owner: folder.owner,
            folderName: folder.folderName,
            activeUsers: folder.activeUsers
        }));

        // Combiner tous les éléments dans l'ordre souhaité
        const allItems = [
            ...personalFolders,     // Dossiers personnels en premier
            ...sharedFolderDetails, // Puis les dossiers partagés
            ...personalFiles        // Et enfin les fichiers
        ];

        const availableExtensions = Array.from(new Set(
            allItems
                .filter(item => item.type === 'file')
                .map(file => file.extension)
        ));

        res.render('dashboard', {
            files: allItems,            // Liste complète pour la compatibilité
            folders: personalFolders,   // Uniquement les dossiers personnels
            extensions: availableExtensions,
            allFolders: personalFolders,
            folderName: folderName,
            fileInfoNames: [],
            userData: userData,
            sharedFolders: sharedFolderDetails  // Les dossiers partagés séparément
        });
    } catch (err) {
        console.error('Error reading directory:', err);
        return res.render('error-recovery-file', { error: err.message });
    }
});

module.exports = router;