/**
 * سیستم پشتیبان‌گیری خودکار و مدیریت داده‌ها
 */
const fs = require('fs');
const path = require('path');

const BACKUP_DIR = 'backups';
const BACKUP_INTERVAL = 24 * 60 * 60 * 1000; // 24 ساعت
const MAX_BACKUPS = 30; // حداکثر تعداد پشتیبان

// اطمینان از وجود دایرکتوری پشتیبان
function ensureBackupDir() {
    if (!fs.existsSync(BACKUP_DIR)) {
        fs.mkdirSync(BACKUP_DIR, { recursive: true });
    }
}

// تولید نام فایل پشتیبان
function generateBackupFilename(prefix) {
    const now = new Date();
    const timestamp = now.toISOString().replace(/[:.]/g, '-').slice(0, -5);
    return `${prefix}_${timestamp}.json`;
}

// پشتیبان‌گیری از فایل
function backupFile(filePath, backupName) {
    try {
        if (!fs.existsSync(filePath)) {
            console.log(`⚠️ فایل ${filePath} وجود ندارد، پشتیبان‌گیری رد شد`);
            return false;
        }

        const content = fs.readFileSync(filePath, 'utf8');
        const backupPath = path.join(BACKUP_DIR, backupName);

        fs.writeFileSync(backupPath, content, 'utf8');
        console.log(`✅ پشتیبان‌گیری موفق: ${backupName}`);
        return true;
    } catch (error) {
        console.error(`❌ خطا در پشتیبان‌گیری ${filePath}:`, error);
        return false;
    }
}

// پشتیبان‌گیری کامل داده‌ها
function createFullBackup() {
    ensureBackupDir();

    const filesToBackup = [
        { path: 'tasks.json', name: 'tasks' },
        { path: 'stickers.json', name: 'stickers' },
        { path: 'gamification.json', name: 'gamification' }
    ];

    const timestamp = new Date().toISOString().slice(0, 10);
    const backupDir = path.join(BACKUP_DIR, `full_backup_${timestamp}`);

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

    let successCount = 0;
    filesToBackup.forEach(({ path: filePath, name }) => {
        const backupName = `${name}.json`;
        const backupPath = path.join(backupDir, backupName);

        try {
            if (fs.existsSync(filePath)) {
                const content = fs.readFileSync(filePath, 'utf8');
                fs.writeFileSync(backupPath, content, 'utf8');
                successCount++;
            }
        } catch (error) {
            console.error(`خطا در پشتیبان‌گیری ${filePath}:`, error);
        }
    });

    // ایجاد فایل metadata
    const metadata = {
        timestamp: new Date().toISOString(),
        files: successCount,
        total: filesToBackup.length
    };

    fs.writeFileSync(path.join(backupDir, 'backup_info.json'), JSON.stringify(metadata, null, 2));

    console.log(`📦 پشتیبان‌گیری کامل انجام شد: ${backupDir}`);
    return backupDir;
}

// پاکسازی پشتیبان‌های قدیمی
function cleanupOldBackups() {
    try {
        if (!fs.existsSync(BACKUP_DIR)) return;

        const items = fs.readdirSync(BACKUP_DIR)
            .map(item => ({
                name: item,
                path: path.join(BACKUP_DIR, item),
                stats: fs.statSync(path.join(BACKUP_DIR, item))
            }))
            .filter(item => item.stats.isDirectory() && item.name.startsWith('full_backup_'))
            .sort((a, b) => b.stats.mtime - a.stats.mtime);

        if (items.length > MAX_BACKUPS) {
            const toDelete = items.slice(MAX_BACKUPS);
            toDelete.forEach(item => {
                fs.rmSync(item.path, { recursive: true, force: true });
                console.log(`🗑️ پشتیبان قدیمی حذف شد: ${item.name}`);
            });
        }
    } catch (error) {
        console.error('خطا در پاکسازی پشتیبان‌های قدیمی:', error);
    }
}

// بازیابی از پشتیبان
function restoreFromBackup(backupPath, targetFiles = null) {
    try {
        if (!fs.existsSync(backupPath)) {
            throw new Error(`پوشه پشتیبان ${backupPath} وجود ندارد`);
        }

        const filesToRestore = targetFiles || [
            { backup: 'tasks.json', target: 'tasks.json' },
            { backup: 'stickers.json', target: 'stickers.json' },
            { backup: 'gamification.json', target: 'gamification.json' }
        ];

        let successCount = 0;
        filesToRestore.forEach(({ backup, target }) => {
            const backupFilePath = path.join(backupPath, backup);

            if (fs.existsSync(backupFilePath)) {
                const content = fs.readFileSync(backupFilePath, 'utf8');
                fs.writeFileSync(target, content, 'utf8');
                successCount++;
                console.log(`🔄 فایل ${target} بازیابی شد`);
            } else {
                console.log(`⚠️ فایل پشتیبان ${backup} یافت نشد`);
            }
        });

        console.log(`✅ بازیابی ${successCount} فایل از ${backupPath}`);
        return successCount;
    } catch (error) {
        console.error('❌ خطا در بازیابی پشتیبان:', error);
        return 0;
    }
}

// لیست پشتیبان‌های موجود
function listBackups() {
    try {
        if (!fs.existsSync(BACKUP_DIR)) return [];

        const items = fs.readdirSync(BACKUP_DIR)
            .filter(item => fs.statSync(path.join(BACKUP_DIR, item)).isDirectory() && item.startsWith('full_backup_'))
            .map(item => {
                const backupPath = path.join(BACKUP_DIR, item);
                const metadataPath = path.join(backupPath, 'backup_info.json');

                let metadata = null;
                if (fs.existsSync(metadataPath)) {
                    try {
                        metadata = JSON.parse(fs.readFileSync(metadataPath, 'utf8'));
                    } catch (e) {
                        // ignore
                    }
                }

                return {
                    name: item,
                    path: backupPath,
                    timestamp: metadata?.timestamp || item.replace('full_backup_', '').replace(/_/g, '-'),
                    files: metadata?.files || 0
                };
            })
            .sort((a, b) => new Date(b.timestamp) - new Date(a.timestamp));

        return items;
    } catch (error) {
        console.error('خطا در لیست پشتیبان‌ها:', error);
        return [];
    }
}

// شروع سیستم پشتیبان‌گیری خودکار
function startAutoBackup() {
    console.log('🔄 سیستم پشتیبان‌گیری خودکار شروع شد...');

    // پشتیبان‌گیری فوری
    createFullBackup();

    // پشتیبان‌گیری دوره‌ای
    setInterval(() => {
        console.log('⏰ زمان پشتیبان‌گیری دوره‌ای فرا رسیده');
        createFullBackup();
        cleanupOldBackups();
    }, BACKUP_INTERVAL);

    console.log(`📅 پشتیبان‌گیری هر ${BACKUP_INTERVAL / (60 * 60 * 1000)} ساعت یکبار انجام می‌شود`);
}

// پشتیبان‌گیری قبل از تغییرات مهم
function backupBeforeChanges(userId, action) {
    const timestamp = new Date().toISOString().replace(/[:.]/g, '-').slice(0, -5);
    const backupName = `before_${action}_${userId}_${timestamp}.json`;

    return backupFile('tasks.json', backupName);
}

module.exports = {
    createFullBackup,
    restoreFromBackup,
    listBackups,
    startAutoBackup,
    backupBeforeChanges,
    cleanupOldBackups
};
