/**
 * Rollback Manager - ระบบจัดการ Rollback
 * Chahua Development Thailand
 * CEO: Saharath C.
 * 
 * Purpose: จัดการการ rollback เมื่อเกิดข้อผิดพลาด
 */

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

class RollbackManager {
    constructor(options = {}) {
        this.config = {
            snapshotPath: options.snapshotPath || './logs/snapshots',
            maxSnapshots: options.maxSnapshots || 10,
            enableCompression: options.enableCompression || false,
            retentionDays: options.retentionDays || 7
        };
        
        this.activeTransactions = new Map();
        this.rollbackHistory = [];
        
        this.ensureSnapshotDirectory();
        console.log('Rollback Manager initialized');
    }

    ensureSnapshotDirectory() {
        try {
            if (!fs.existsSync(this.config.snapshotPath)) {
                fs.mkdirSync(this.config.snapshotPath, { recursive: true });
            }
        } catch (error) {
            console.warn('Warning: Could not create snapshot directory:', error.message);
        }
    }

    async createSnapshot(transactionId, data, metadata = {}) {
        try {
            const snapshot = {
                id: transactionId,
                timestamp: new Date().toISOString(),
                data: JSON.parse(JSON.stringify(data)), // Deep clone
                metadata: {
                    source: metadata.source || 'unknown',
                    description: metadata.description || 'Auto snapshot',
                    version: metadata.version || '1.0.0',
                    ...metadata
                },
                size: this.calculateDataSize(data)
            };
            
            // Store in memory
            this.activeTransactions.set(transactionId, snapshot);
            
            // Save to disk
            await this.saveSnapshotToDisk(snapshot);
            
            console.log(`Snapshot created: ${transactionId}`);
            return transactionId;
            
        } catch (error) {
            console.error('Error creating snapshot:', error.message);
            return null;
        }
    }

    async rollback(transactionId) {
        try {
            console.log(`Starting rollback for transaction: ${transactionId}`);
            
            let snapshot = this.activeTransactions.get(transactionId);
            
            // If not in memory, try loading from disk
            if (!snapshot) {
                snapshot = await this.loadSnapshotFromDisk(transactionId);
            }
            
            if (!snapshot) {
                throw new Error(`Snapshot not found for transaction: ${transactionId}`);
            }
            
            // Perform rollback
            const rollbackResult = await this.performRollback(snapshot);
            
            // Log rollback
            this.logRollback(transactionId, rollbackResult);
            
            // Cleanup
            await this.cleanupSnapshot(transactionId);
            
            console.log(`Rollback completed: ${transactionId}`);
            return {
                success: true,
                transactionId,
                timestamp: new Date().toISOString(),
                dataRestored: rollbackResult.itemsRestored || 0
            };
            
        } catch (error) {
            console.error(`Rollback failed for ${transactionId}:`, error.message);
            return {
                success: false,
                transactionId,
                error: error.message,
                timestamp: new Date().toISOString()
            };
        }
    }

    async performRollback(snapshot) {
        // This is a generic rollback implementation
        // In a real system, this would restore actual system state
        
        console.log(`Restoring data from snapshot: ${snapshot.id}`);
        console.log(`Snapshot created: ${snapshot.timestamp}`);
        console.log(`Data size: ${snapshot.size} bytes`);
        
        // Simulate data restoration
        let itemsRestored = 0;
        
        if (snapshot.data && typeof snapshot.data === 'object') {
            itemsRestored = Object.keys(snapshot.data).length;
        }
        
        return {
            itemsRestored,
            snapshotId: snapshot.id,
            originalTimestamp: snapshot.timestamp
        };
    }

    async saveSnapshotToDisk(snapshot) {
        try {
            const filename = `snapshot_${snapshot.id}_${Date.now()}.json`;
            const filepath = path.join(this.config.snapshotPath, filename);
            
            const snapshotData = {
                ...snapshot,
                filename,
                savedAt: new Date().toISOString()
            };
            
            fs.writeFileSync(filepath, JSON.stringify(snapshotData, null, 2));
            
            // Update snapshot with file path
            snapshot.filepath = filepath;
            snapshot.filename = filename;
            
        } catch (error) {
            console.error('Error saving snapshot to disk:', error.message);
        }
    }

    async loadSnapshotFromDisk(transactionId) {
        try {
            const files = fs.readdirSync(this.config.snapshotPath);
            const snapshotFile = files.find(file => file.includes(`snapshot_${transactionId}_`));
            
            if (!snapshotFile) {
                return null;
            }
            
            const filepath = path.join(this.config.snapshotPath, snapshotFile);
            const snapshotData = JSON.parse(fs.readFileSync(filepath, 'utf8'));
            
            console.log(`Snapshot loaded from disk: ${transactionId}`);
            return snapshotData;
            
        } catch (error) {
            console.error('Error loading snapshot from disk:', error.message);
            return null;
        }
    }

    async cleanupSnapshot(transactionId) {
        try {
            // Remove from memory
            this.activeTransactions.delete(transactionId);
            
            // Remove from disk (optional - you might want to keep for audit)
            const files = fs.readdirSync(this.config.snapshotPath);
            const snapshotFile = files.find(file => file.includes(`snapshot_${transactionId}_`));
            
            if (snapshotFile) {
                const filepath = path.join(this.config.snapshotPath, snapshotFile);
                fs.unlinkSync(filepath);
                console.log(`Snapshot file cleaned up: ${snapshotFile}`);
            }
            
        } catch (error) {
            console.error('Error cleaning up snapshot:', error.message);
        }
    }

    logRollback(transactionId, result) {
        const rollbackEntry = {
            transactionId,
            timestamp: new Date().toISOString(),
            success: result.itemsRestored !== undefined,
            itemsRestored: result.itemsRestored || 0,
            details: result
        };
        
        this.rollbackHistory.push(rollbackEntry);
        
        // Keep only recent entries
        if (this.rollbackHistory.length > 100) {
            this.rollbackHistory.shift();
        }
    }

    calculateDataSize(data) {
        try {
            return JSON.stringify(data).length;
        } catch (error) {
            return 0;
        }
    }

    getActiveTransactions() {
        return Array.from(this.activeTransactions.keys());
    }

    getRollbackHistory() {
        return this.rollbackHistory.slice(-20); // Last 20 entries
    }

    getStats() {
        const totalRollbacks = this.rollbackHistory.length;
        const successfulRollbacks = this.rollbackHistory.filter(r => r.success).length;
        
        return {
            activeTransactions: this.activeTransactions.size,
            totalRollbacks,
            successfulRollbacks,
            failedRollbacks: totalRollbacks - successfulRollbacks,
            successRate: totalRollbacks > 0 ? Math.round((successfulRollbacks / totalRollbacks) * 100) : 0
        };
    }

    async cleanupOldSnapshots() {
        try {
            const files = fs.readdirSync(this.config.snapshotPath);
            const cutoffDate = new Date(Date.now() - (this.config.retentionDays * 24 * 60 * 60 * 1000));
            
            let cleanedCount = 0;
            
            for (const file of files) {
                if (file.startsWith('snapshot_')) {
                    const filepath = path.join(this.config.snapshotPath, file);
                    const stats = fs.statSync(filepath);
                    
                    if (stats.mtime < cutoffDate) {
                        fs.unlinkSync(filepath);
                        cleanedCount++;
                    }
                }
            }
            
            if (cleanedCount > 0) {
                console.log(`Cleaned up ${cleanedCount} old snapshot files`);
            }
            
            return cleanedCount;
            
        } catch (error) {
            console.error('Error cleaning up old snapshots:', error.message);
            return 0;
        }
    }
}

module.exports = RollbackManager;