/**
 * Middleware برای logging و error handling حرفه‌ای
 */

// سیستم لاگ پیشرفته
class Logger {
    static log(level, message, data = null) {
        const timestamp = new Date().toISOString();
        const emoji = {
            info: 'ℹ️',
            success: '✅',
            warning: '⚠️',
            error: '❌',
            debug: '🔍'
        };

        const logMessage = `[${timestamp}] ${emoji[level] || '📝'} ${message}`;
        
        if (data) {
            console.log(logMessage, data);
        } else {
            console.log(logMessage);
        }
    }

    static info(message, data) {
        this.log('info', message, data);
    }

    static success(message, data) {
        this.log('success', message, data);
    }

    static warning(message, data) {
        this.log('warning', message, data);
    }

    static error(message, error) {
        this.log('error', message, error);
        if (error && error.stack) {
            console.error(error.stack);
        }
    }

    static debug(message, data) {
        if (process.env.NODE_ENV === 'development') {
            this.log('debug', message, data);
        }
    }
}

// Middleware برای logging درخواست‌ها
function requestLogger() {
    return async (ctx, next) => {
        const start = Date.now();
        const userId = ctx.from?.id || 'unknown';
        const username = ctx.from?.username || ctx.from?.first_name || 'unknown';
        const updateType = ctx.updateType;

        Logger.debug(`📥 Incoming ${updateType} from ${username} (${userId})`);

        try {
            await next();
            
            const duration = Date.now() - start;
            Logger.debug(`📤 Processed ${updateType} in ${duration}ms`);
        } catch (error) {
            const duration = Date.now() - start;
            Logger.error(`💥 Error processing ${updateType} after ${duration}ms`, error);
            throw error;
        }
    };
}

// Middleware برای مدیریت خطاهای جهانی
function errorHandler() {
    return async (ctx, next) => {
        try {
            await next();
        } catch (error) {
            Logger.error('Unhandled error in middleware', error);
            
            // ارسال پیام دوستانه به کاربر
            try {
                const errorMessages = [
                    'اوه! یه مشکلی پیش اومد عشقم! 😅 ولی نگران نباش، الان درستش می‌کنم 💕',
                    'ببخشید مائده جان! یه مشکل کوچیکی پیش اومد 😊 الان برطرفش می‌کنم',
                    'اوه عزیزم! یه خطای کوچیکی رخ داد ولی الان حلش کردم! 💖'
                ];
                
                const randomMessage = errorMessages[Math.floor(Math.random() * errorMessages.length)];
                await ctx.reply(randomMessage).catch(() => {});
            } catch (replyError) {
                Logger.error('Failed to send error message to user', replyError);
            }
        }
    };
}

// Middleware برای rate limiting ساده
const userRateLimits = new Map();

function rateLimiter(options = {}) {
    const maxRequests = options.maxRequests || 30;
    const windowMs = options.windowMs || 60000; // 1 دقیقه

    return async (ctx, next) => {
        const userId = ctx.from?.id;
        if (!userId) {
            return next();
        }

        const now = Date.now();
        const userLimit = userRateLimits.get(userId) || { count: 0, resetAt: now + windowMs };

        // Reset if window passed
        if (now > userLimit.resetAt) {
            userLimit.count = 0;
            userLimit.resetAt = now + windowMs;
        }

        // Check limit
        if (userLimit.count >= maxRequests) {
            Logger.warning(`Rate limit exceeded for user ${userId}`);
            await ctx.reply('مائده جان! یه کم آرومتر پیام بفرست 😅 الان زیادی سریع پیام فرستادی! 💕').catch(() => {});
            return;
        }

        // Increment counter
        userLimit.count++;
        userRateLimits.set(userId, userLimit);

        // Cleanup old entries periodically
        if (Math.random() < 0.01) { // 1% chance
            for (const [uid, limit] of userRateLimits.entries()) {
                if (now > limit.resetAt + windowMs) {
                    userRateLimits.delete(uid);
                }
            }
        }

        return next();
    };
}

// Middleware برای اعتبارسنجی کاربر
function validateUser() {
    return async (ctx, next) => {
        if (!ctx.from || !ctx.from.id) {
            Logger.warning('Request without user info');
            return;
        }
        return next();
    };
}

// Helper برای retry با exponential backoff
async function retryWithBackoff(fn, maxRetries = 3, initialDelay = 1000) {
    let lastError;
    
    for (let attempt = 1; attempt <= maxRetries; attempt++) {
        try {
            return await fn();
        } catch (error) {
            lastError = error;
            
            // Don't retry on certain errors
            if (error.code === 400 || error.code === 403 || error.code === 404) {
                throw error;
            }
            
            if (attempt < maxRetries) {
                const delay = initialDelay * Math.pow(2, attempt - 1);
                Logger.warning(`Retry attempt ${attempt}/${maxRetries} after ${delay}ms`, error.message);
                await new Promise(resolve => setTimeout(resolve, delay));
            }
        }
    }
    
    throw lastError;
}

module.exports = {
    Logger,
    requestLogger,
    errorHandler,
    rateLimiter,
    validateUser,
    retryWithBackoff
};

