import fs from 'fs';
import path from 'path';
import { fileURLToPath } from 'url';
import os from 'os';
import { t, translate, translateAIResponse, getUserLang } from '../france/translator.js';

const __filename = fileURLToPath(import.meta.url);
const __dirname = path.dirname(__filename);

export const commands = [
    {
        name: 'structure',
        aliases: ['tree'],
        description: 'Analyze the complete structure, files, and folders of the bot',
        category: 'Owner',
        ownerOnly: true,
        execute: async ({ sock, from, text, msg, config }) => {
            const botName = config.BOT_NAME || 'Flash-MD';
            
            const args = text.trim().split(/\s+/);
            const option = args[0]?.toLowerCase() || '';
            
            if (option === 'help') {
                const helpTitle = await t(from, 'structure', 'helpTitle');
                const cmdDefault = await t(from, 'structure', 'cmdDefault');
                const cmdTree = await t(from, 'structure', 'cmdTree');
                const cmdDetails = await t(from, 'structure', 'cmdDetails');
                const cmdSize = await t(from, 'structure', 'cmdSize');
                const cmdFiles = await t(from, 'structure', 'cmdFiles');
                const cmdTreeAlias = await t(from, 'structure', 'cmdTreeAlias');
                const poweredMsg = await t(from, 'structure', 'powered');
                
                return sock.sendMessage(from, {
                    text: `${helpTitle}\n\n` +
                          `${cmdDefault}\n` +
                          `${cmdTree}\n` +
                          `${cmdDetails}\n` +
                          `${cmdSize}\n` +
                          `${cmdFiles}\n` +
                          `${cmdTreeAlias}\n\n` +
                          `${poweredMsg} ${botName}`
                }, { quoted: msg });
            }
            
            const analyzingMsg = await t(from, 'structure', 'analyzing');
            const processingMsg = await sock.sendMessage(from, { text: analyzingMsg }, { quoted: msg });
            
            try {
                const rootDir = process.cwd();
                const excludeDirs = ['node_modules', '.git', 'temp', 'tmp', 'logs', 'sessions', 'backups', 'uploads', 'cache', 'sessions', 'venv', 'env', '__pycache__'];
                const excludeFiles = ['.env', '*.log', '*.zip', 'session.json', 'creds.json', 'package-lock.json', 'yarn.lock'];
                
                const structure = {
                    totalFiles: 0,
                    totalFolders: 0,
                    totalSize: 0,
                    byExtension: {},
                    byFolder: {},
                    files: [],
                    tree: ''
                };
                
                const generateTree = (dir, prefix = '', isLast = true) => {
                    if (!fs.existsSync(dir)) return '';
                    
                    const items = fs.readdirSync(dir).filter(item => {
                        const itemPath = path.join(dir, item);
                        const stat = fs.statSync(itemPath);
                        if (stat.isDirectory()) {
                            return !excludeDirs.includes(item) && !item.startsWith('.');
                        }
                        const ext = path.extname(item).toLowerCase();
                        const shouldExclude = excludeFiles.some(pattern => {
                            if (pattern.includes('*')) {
                                const regex = new RegExp(pattern.replace('*', '.*'));
                                return regex.test(item);
                            }
                            return item === pattern;
                        });
                        return !shouldExclude;
                    });
                    
                    items.sort((a, b) => {
                        const aPath = path.join(dir, a);
                        const bPath = path.join(dir, b);
                        const aIsDir = fs.statSync(aPath).isDirectory();
                        const bIsDir = fs.statSync(bPath).isDirectory();
                        if (aIsDir && !bIsDir) return -1;
                        if (!aIsDir && bIsDir) return 1;
                        return a.localeCompare(b);
                    });
                    
                    let treeString = '';
                    
                    for (let i = 0; i < items.length; i++) {
                        const item = items[i];
                        const itemPath = path.join(dir, item);
                        const stat = fs.statSync(itemPath);
                        const isLastItem = i === items.length - 1;
                        const connector = isLastItem ? '└── ' : '├── ';
                        const newPrefix = prefix + (isLastItem ? '    ' : '│   ');
                        
                        if (stat.isDirectory()) {
                            treeString += `${prefix}${connector}📁 ${item}/\n`;
                            treeString += generateTree(itemPath, newPrefix, isLastItem);
                        } else {
                            const size = (stat.size / 1024).toFixed(1);
                            treeString += `${prefix}${connector}📄 ${item} (${size} KB)\n`;
                        }
                    }
                    
                    return treeString;
                };
                
                const scanDirectory = (dir, folderName = '') => {
                    if (!fs.existsSync(dir)) return { files: 0, size: 0 };
                    
                    const items = fs.readdirSync(dir);
                    let folderFiles = 0;
                    let folderSize = 0;
                    
                    for (const item of items) {
                        const itemPath = path.join(dir, item);
                        const stat = fs.statSync(itemPath);
                        
                        if (stat.isDirectory()) {
                            if (!excludeDirs.includes(item) && !item.startsWith('.')) {
                                structure.totalFolders++;
                                const subResult = scanDirectory(itemPath, path.join(folderName, item));
                                folderFiles += subResult.files;
                                folderSize += subResult.size;
                            }
                        } else {
                            const ext = path.extname(item).toLowerCase() || 'no extension';
                            const shouldExclude = excludeFiles.some(pattern => {
                                if (pattern.includes('*')) {
                                    const regex = new RegExp(pattern.replace('*', '.*'));
                                    return regex.test(item);
                                }
                                return item === pattern;
                            });
                            
                            if (!shouldExclude) {
                                structure.totalFiles++;
                                structure.totalSize += stat.size;
                                folderFiles++;
                                folderSize += stat.size;
                                
                                structure.byExtension[ext] = (structure.byExtension[ext] || 0) + 1;
                                
                                structure.files.push({
                                    name: item,
                                    path: path.join(folderName, item),
                                    size: stat.size,
                                    ext: ext,
                                    modified: stat.mtime
                                });
                            }
                        }
                    }
                    
                    if (folderName && (folderFiles > 0 || folderSize > 0)) {
                        structure.byFolder[folderName] = {
                            files: folderFiles,
                            size: folderSize
                        };
                    }
                    
                    return { files: folderFiles, size: folderSize };
                };
                
                scanDirectory(rootDir);
                
                if (option === 'tree' || text.trim() === 'tree') {
                    const treeOutput = generateTree(rootDir);
                    await sock.sendMessage(from, { delete: processingMsg.key });
                    
                    const treeHeader = await t(from, 'structure', 'treeHeader');
                    const poweredMsg = await t(from, 'structure', 'powered');
                    
                    let resultText = `${treeHeader}\n\n`;
                    resultText += `📁 ${path.basename(rootDir)}/\n`;
                    resultText += treeOutput || 'No files found\n';
                    resultText += `\n${poweredMsg} ${botName}`;
                    
                    if (resultText.length > 3500) {
                        const parts = resultText.match(/[\s\S]{1,3500}/g) || [];
                        const continuedMsg = await t(from, 'structure', 'continued');
                        for (let i = 0; i < parts.length; i++) {
                            await sock.sendMessage(from, { text: parts[i] + (i < parts.length - 1 ? `\n\n${continuedMsg}` : '') }, { quoted: msg });
                        }
                    } else {
                        await sock.sendMessage(from, { text: resultText }, { quoted: msg });
                    }
                    return;
                }
                
                if (option === 'details') {
                    const sortedBySize = [...structure.files].sort((a, b) => b.size - a.size).slice(0, 20);
                    
                    const detailsHeader = await t(from, 'structure', 'detailsHeader');
                    const totalFilesLabel = await t(from, 'structure', 'totalFiles');
                    const totalFoldersLabel = await t(from, 'structure', 'totalFolders');
                    const totalSizeLabel = await t(from, 'structure', 'totalSize');
                    const largestFilesLabel = await t(from, 'structure', 'largestFiles');
                    const poweredMsg = await t(from, 'structure', 'powered');
                    
                    let resultText = `${detailsHeader}\n\n`;
                    resultText += `${totalFilesLabel} ${structure.totalFiles}\n`;
                    resultText += `${totalFoldersLabel} ${structure.totalFolders}\n`;
                    resultText += `${totalSizeLabel} ${(structure.totalSize / 1024 / 1024).toFixed(2)} MB\n\n`;
                    resultText += `${largestFilesLabel}\n`;
                    
                    for (let i = 0; i < sortedBySize.length; i++) {
                        const file = sortedBySize[i];
                        const sizeKB = (file.size / 1024).toFixed(1);
                        resultText += `${i + 1}. ${file.path}\n`;
                        resultText += `   💾 ${sizeKB} KB | 📝 ${file.ext}\n`;
                        resultText += `   🕒 ${file.modified.toLocaleDateString()}\n\n`;
                    }
                    
                    resultText += `${poweredMsg} ${botName}`;
                    
                    await sock.sendMessage(from, { delete: processingMsg.key });
                    
                    if (resultText.length > 3500) {
                        const parts = resultText.match(/[\s\S]{1,3500}/g) || [];
                        const continuedMsg = await t(from, 'structure', 'continued');
                        for (let i = 0; i < parts.length; i++) {
                            await sock.sendMessage(from, { text: parts[i] + (i < parts.length - 1 ? `\n\n${continuedMsg}` : '') }, { quoted: msg });
                        }
                    } else {
                        await sock.sendMessage(from, { text: resultText }, { quoted: msg });
                    }
                    return;
                }
                
                if (option === 'size') {
                    const sortedFolders = Object.entries(structure.byFolder)
                        .sort((a, b) => b[1].size - a[1].size)
                        .slice(0, 20);
                    
                    const sizeHeader = await t(from, 'structure', 'sizeHeader');
                    const totalSizeLabel = await t(from, 'structure', 'totalSize');
                    const totalFilesLabel = await t(from, 'structure', 'totalFiles');
                    const largestFoldersLabel = await t(from, 'structure', 'largestFolders');
                    const poweredMsg = await t(from, 'structure', 'powered');
                    
                    let resultText = `${sizeHeader}\n\n`;
                    resultText += `${totalSizeLabel} ${(structure.totalSize / 1024 / 1024).toFixed(2)} MB\n`;
                    resultText += `${totalFilesLabel} ${structure.totalFiles}\n\n`;
                    resultText += `${largestFoldersLabel}\n`;
                    
                    for (let i = 0; i < sortedFolders.length; i++) {
                        const [folder, data] = sortedFolders[i];
                        const sizeMB = (data.size / 1024 / 1024).toFixed(2);
                        const percent = ((data.size / structure.totalSize) * 100).toFixed(1);
                        resultText += `${i + 1}. 📁 ${folder || 'root'}\n`;
                        resultText += `   💾 ${sizeMB} MB (${percent}%)\n`;
                        resultText += `   📄 ${data.files} files\n\n`;
                    }
                    
                    resultText += `${poweredMsg} ${botName}`;
                    
                    await sock.sendMessage(from, { delete: processingMsg.key });
                    await sock.sendMessage(from, { text: resultText }, { quoted: msg });
                    return;
                }
                
                if (option === 'files') {
                    const extensions = Object.entries(structure.byExtension).sort((a, b) => b[1] - a[1]);
                    
                    const filesHeader = await t(from, 'structure', 'filesHeader');
                    const totalFilesLabel = await t(from, 'structure', 'totalFiles');
                    const totalSizeLabel = await t(from, 'structure', 'totalSize');
                    const poweredMsg = await t(from, 'structure', 'powered');
                    
                    let resultText = `${filesHeader}\n\n`;
                    
                    for (const [ext, count] of extensions) {
                        const percent = ((count / structure.totalFiles) * 100).toFixed(1);
                        resultText += `📝 ${ext || 'no extension'}: ${count} files (${percent}%)\n`;
                    }
                    
                    resultText += `\n${totalFilesLabel} ${structure.totalFiles} files\n`;
                    resultText += `${totalSizeLabel} ${(structure.totalSize / 1024 / 1024).toFixed(2)} MB\n`;
                    resultText += `\n${poweredMsg} ${botName}`;
                    
                    await sock.sendMessage(from, { delete: processingMsg.key });
                    await sock.sendMessage(from, { text: resultText }, { quoted: msg });
                    return;
                }
                
                const extensions = Object.entries(structure.byExtension).sort((a, b) => b[1] - a[1]).slice(0, 10);
                const largestFiles = [...structure.files].sort((a, b) => b.size - a.size).slice(0, 10);
                
                const analysisHeader = await t(from, 'structure', 'analysisHeader');
                const totalFoldersLabel = await t(from, 'structure', 'totalFolders');
                const totalFilesLabel = await t(from, 'structure', 'totalFiles');
                const totalSizeLabel = await t(from, 'structure', 'totalSize');
                const platformLabel = await t(from, 'structure', 'platform');
                const nodeLabel = await t(from, 'structure', 'node');
                const topExtensionsLabel = await t(from, 'structure', 'topExtensions');
                const largestFilesLabel = await t(from, 'structure', 'largestFiles');
                const tipsLabel = await t(from, 'structure', 'tips');
                const cmdDefault = await t(from, 'structure', 'cmdDefault');
                const cmdTree = await t(from, 'structure', 'cmdTree');
                const cmdDetails = await t(from, 'structure', 'cmdDetails');
                const cmdSize = await t(from, 'structure', 'cmdSize');
                const cmdFiles = await t(from, 'structure', 'cmdFiles');
                const cmdTreeAlias = await t(from, 'structure', 'cmdTreeAlias');
                const poweredMsg = await t(from, 'structure', 'powered');
                
                let resultText = `${analysisHeader}\n\n`;
                resultText += `╭━━━━━━━━━━━━━━━━━━━━╮\n`;
                resultText += `│ ${totalFoldersLabel} ${structure.totalFolders}\n`;
                resultText += `│ ${totalFilesLabel} ${structure.totalFiles}\n`;
                resultText += `│ ${totalSizeLabel} ${(structure.totalSize / 1024 / 1024).toFixed(2)} MB\n`;
                resultText += `│ ${platformLabel} ${os.platform()}\n`;
                resultText += `│ ${nodeLabel} ${process.version}\n`;
                resultText += `╰━━━━━━━━━━━━━━━━━━━━╯\n\n`;
                
                resultText += `${topExtensionsLabel}\n`;
                for (const [ext, count] of extensions) {
                    resultText += `   ${ext || 'no ext'}: ${count} files\n`;
                }
                resultText += `\n`;
                
                resultText += `${largestFilesLabel}\n`;
                for (let i = 0; i < largestFiles.length; i++) {
                    const file = largestFiles[i];
                    const sizeKB = (file.size / 1024).toFixed(1);
                    resultText += `   ${i + 1}. ${file.path} (${sizeKB} KB)\n`;
                }
                resultText += `\n`;
                
                resultText += `${tipsLabel}\n`;
                resultText += `   • ${cmdDefault}\n`;
                resultText += `   • ${cmdTree}\n`;
                resultText += `   • ${cmdDetails}\n`;
                resultText += `   • ${cmdSize}\n`;
                resultText += `   • ${cmdFiles}\n`;
                resultText += `   • ${cmdTreeAlias}\n`;
                resultText += `\n${poweredMsg} ${botName}`;
                
                await sock.sendMessage(from, { delete: processingMsg.key });
                await sock.sendMessage(from, { text: resultText }, { quoted: msg });
                
            } catch (error) {
                console.error('Structure error:', error);
                await sock.sendMessage(from, { delete: processingMsg.key });
                const errorMsg = await t(from, 'structure', 'error');
                const poweredMsg = await t(from, 'structure', 'powered');
                await sock.sendMessage(from, { 
                    text: `${errorMsg}\n\n${poweredMsg} ${botName}`
                }, { quoted: msg });
            }
        }
    }
];