const Redis = require('ioredis');
const logger = require('./logger');

/**
 * Redis Connection Configuration
 * Supports both single instance and cluster modes
 */

const redisConfig = {
  host: process.env.REDIS_HOST || 'localhost',
  port: parseInt(process.env.REDIS_PORT) || 6379,
  password: process.env.REDIS_PASSWORD || undefined,
  db: parseInt(process.env.REDIS_DB) || 0,
  retryStrategy: (times) => {
    // Stop retrying after 3 attempts in development
    if (process.env.NODE_ENV === 'development' && times > 3) {
      logger.info('Redis unavailable - caching disabled (optional feature)');
      return null; // Stop retrying
    }
    const delay = Math.min(times * 50, 2000);
    return delay;
  },
  maxRetriesPerRequest: 3,
  enableReadyCheck: true,
  enableOfflineQueue: true,
  lazyConnect: true, // Don't connect immediately
  connectTimeout: 5000, // Reduced timeout
  keepAlive: 30000,
  family: 4, // IPv4
  // Connection pool settings
  minReconnectInterval: 100,
  maxReconnectInterval: 3000,
  // Reduce logging noise
  showFriendlyErrorStack: process.env.NODE_ENV !== 'development'
};

// Create Redis client
let redisClient = null;
let isConnected = false;

try {
  redisClient = new Redis(redisConfig);
  
  // Attempt initial connection
  redisClient.connect().catch(() => {
    // Silently fail if Redis is not available in development
    if (process.env.NODE_ENV === 'development') {
      logger.info('Redis not available - continuing without cache (optional)');
    }
  });
  
  // Connection events
  redisClient.on('connect', () => {
    logger.info('Redis client connecting...');
  });
  
  redisClient.on('ready', () => {
    isConnected = true;
    logger.info('Redis client connected and ready');
  });
  
  redisClient.on('error', (err) => {
    isConnected = false;
    // Only log errors in production or first error
    if (process.env.NODE_ENV === 'production' || !errorLogged) {
      logger.error('Redis client error:', err.message || err);
      errorLogged = true;
    }
  });
  
  redisClient.on('close', () => {
    if (isConnected) {
      isConnected = false;
      logger.warn('Redis client connection closed');
    }
  });
  
  redisClient.on('reconnecting', () => {
    // Only log once
    if (isConnected === false) {
      logger.info('Redis client reconnecting...');
    }
  });
  
  redisClient.on('end', () => {
    if (isConnected) {
      isConnected = false;
      logger.info('Redis connection ended');
    }
  });
  
} catch (error) {
  logger.error('Failed to create Redis client:', error);
}

// Track if error has been logged
let errorLogged = false;

/**
 * Check if Redis is connected
 */
const isRedisConnected = () => {
  return isConnected && redisClient && redisClient.status === 'ready';
};

/**
 * Get Redis client
 */
const getRedisClient = () => {
  if (!isRedisConnected()) {
    logger.warn('Redis client not connected');
    return null;
  }
  return redisClient;
};

/**
 * Close Redis connection gracefully
 */
const closeRedis = async () => {
  if (redisClient) {
    await redisClient.quit();
    logger.info('Redis connection closed');
  }
};

/**
 * Cache helper functions
 */

/**
 * Get cached data
 * @param {string} key - Cache key
 * @returns {Promise<any>} - Parsed JSON data or null
 */
const getCache = async (key) => {
  try {
    if (!isRedisConnected()) {
      logger.warn('Redis not connected, cache miss');
      return null;
    }
    
    const data = await redisClient.get(key);
    if (!data) return null;
    
    logger.debug(`Cache hit: ${key}`);
    return JSON.parse(data);
  } catch (error) {
    logger.error(`Cache get error for key ${key}:`, error);
    return null;
  }
};

/**
 * Set cached data
 * @param {string} key - Cache key
 * @param {any} value - Data to cache
 * @param {number} ttl - Time to live in seconds (default: 300 = 5 minutes)
 * @returns {Promise<boolean>} - Success status
 */
const setCache = async (key, value, ttl = 300) => {
  try {
    if (!isRedisConnected()) {
      logger.warn('Redis not connected, skipping cache set');
      return false;
    }
    
    const serialized = JSON.stringify(value);
    await redisClient.setex(key, ttl, serialized);
    
    logger.debug(`Cache set: ${key} (TTL: ${ttl}s)`);
    return true;
  } catch (error) {
    logger.error(`Cache set error for key ${key}:`, error);
    return false;
  }
};

/**
 * Delete cached data
 * @param {string} key - Cache key or pattern
 * @returns {Promise<boolean>} - Success status
 */
const deleteCache = async (key) => {
  try {
    if (!isRedisConnected()) {
      return false;
    }
    
    // Support pattern deletion (e.g., "user:*")
    if (key.includes('*')) {
      const keys = await redisClient.keys(key);
      if (keys.length > 0) {
        await redisClient.del(...keys);
        logger.debug(`Cache deleted: ${keys.length} keys matching ${key}`);
      }
    } else {
      await redisClient.del(key);
      logger.debug(`Cache deleted: ${key}`);
    }
    
    return true;
  } catch (error) {
    logger.error(`Cache delete error for key ${key}:`, error);
    return false;
  }
};

/**
 * Clear all cache
 * @returns {Promise<boolean>} - Success status
 */
const clearCache = async () => {
  try {
    if (!isRedisConnected()) {
      return false;
    }
    
    await redisClient.flushdb();
    logger.info('All cache cleared');
    return true;
  } catch (error) {
    logger.error('Cache clear error:', error);
    return false;
  }
};

/**
 * Get multiple keys at once
 * @param {string[]} keys - Array of cache keys
 * @returns {Promise<object>} - Object with key-value pairs
 */
const getCacheMultiple = async (keys) => {
  try {
    if (!isRedisConnected() || !keys || keys.length === 0) {
      return {};
    }
    
    const values = await redisClient.mget(...keys);
    const result = {};
    
    keys.forEach((key, index) => {
      if (values[index]) {
        try {
          result[key] = JSON.parse(values[index]);
        } catch (err) {
          result[key] = null;
        }
      } else {
        result[key] = null;
      }
    });
    
    return result;
  } catch (error) {
    logger.error('Cache mget error:', error);
    return {};
  }
};

/**
 * Increment a counter
 * @param {string} key - Cache key
 * @param {number} increment - Amount to increment (default: 1)
 * @param {number} ttl - Time to live in seconds (optional)
 * @returns {Promise<number>} - New value
 */
const incrementCache = async (key, increment = 1, ttl = null) => {
  try {
    if (!isRedisConnected()) {
      return 0;
    }
    
    const newValue = await redisClient.incrby(key, increment);
    
    if (ttl) {
      await redisClient.expire(key, ttl);
    }
    
    return newValue;
  } catch (error) {
    logger.error(`Cache increment error for key ${key}:`, error);
    return 0;
  }
};

/**
 * Check if key exists
 * @param {string} key - Cache key
 * @returns {Promise<boolean>} - Exists status
 */
const cacheExists = async (key) => {
  try {
    if (!isRedisConnected()) {
      return false;
    }
    
    const exists = await redisClient.exists(key);
    return exists === 1;
  } catch (error) {
    logger.error(`Cache exists error for key ${key}:`, error);
    return false;
  }
};

module.exports = {
  redisClient,
  isRedisConnected,
  getRedisClient,
  closeRedis,
  getCache,
  setCache,
  deleteCache,
  clearCache,
  getCacheMultiple,
  incrementCache,
  cacheExists
};