import { PrismaClient } from '@prisma/client';
import logger from '../utils/logger';

const prisma = new PrismaClient();

export interface SystemConfigData {
  quotaManagementEnabled: boolean;
}

export class SystemConfigService {
  private static instance: SystemConfigService;
  private cachedConfig: SystemConfigData | null = null;
  private lastFetch: number = 0;
  private readonly CACHE_DURATION = 60 * 1000; // 1 minute

  public static getInstance(): SystemConfigService {
    if (!SystemConfigService.instance) {
      SystemConfigService.instance = new SystemConfigService();
    }
    return SystemConfigService.instance;
  }

  /**
   * Get current system configuration
   */
  async getConfig(): Promise<SystemConfigData> {
    const now = Date.now();
    
    // Use cached config if still valid
    if (this.cachedConfig && (now - this.lastFetch) < this.CACHE_DURATION) {
      logger.info('✅ Using cached system configuration', {
        cacheAge: `${now - this.lastFetch}ms`,
        quotaManagementEnabled: this.cachedConfig.quotaManagementEnabled
      });
      return this.cachedConfig;
    }

    try {
      logger.info('🗄️ Querying database for system configuration');
      
      const config = await prisma.systemConfig.findFirst({
        where: { isActive: true },
        orderBy: { createdAt: 'desc' }
      });

      let configData: SystemConfigData;
      
      if (config) {
        configData = {
          quotaManagementEnabled: config.quotaManagementEnabled
        };
        logger.info('✅ System configuration found in database', { 
          configId: config.id,
          quotaManagementEnabled: config.quotaManagementEnabled
        });
      } else {
        // Create default configuration if none exists
        logger.info('⚙️ No system configuration found, creating default');
        
        const defaultConfig = await prisma.systemConfig.create({
          data: {
            quotaManagementEnabled: true
          }
        });
        
        configData = {
          quotaManagementEnabled: defaultConfig.quotaManagementEnabled
        };
        
        logger.info('✅ Default system configuration created', {
          configId: defaultConfig.id,
          quotaManagementEnabled: defaultConfig.quotaManagementEnabled
        });
      }

      // Cache the configuration
      this.cachedConfig = configData;
      this.lastFetch = now;
      
      return configData;
    } catch (error) {
      logger.error('❌ Failed to retrieve system configuration from database', { 
        error: error instanceof Error ? error.message : String(error)
      });
      
      // Return default values if database fails
      const defaultConfig: SystemConfigData = {
        quotaManagementEnabled: true
      };
      
      this.cachedConfig = defaultConfig;
      this.lastFetch = now;
      
      return defaultConfig;
    }
  }

  /**
   * Update system configuration
   */
  async updateConfig(configData: Partial<SystemConfigData>): Promise<void> {
    try {
      logger.info('📝 Updating system configuration', {
        updates: configData
      });

      // Get current active config or create new one
      let existingConfig = await prisma.systemConfig.findFirst({
        where: { isActive: true },
        orderBy: { createdAt: 'desc' }
      });

      if (existingConfig) {
        // Update existing config
        await prisma.systemConfig.update({
          where: { id: existingConfig.id },
          data: {
            ...configData,
            updatedAt: new Date()
          }
        });
        
        logger.info('✅ System configuration updated', {
          configId: existingConfig.id,
          updates: configData
        });
      } else {
        // Create new config with provided data and defaults
        const newConfig = await prisma.systemConfig.create({
          data: {
            quotaManagementEnabled: configData.quotaManagementEnabled ?? true
          }
        });
        
        logger.info('✅ New system configuration created', {
          configId: newConfig.id,
          quotaManagementEnabled: newConfig.quotaManagementEnabled
        });
      }

      // Invalidate cache
      this.invalidateCache();
      
      // Refresh cache
      await this.getConfig();
      
    } catch (error) {
      logger.error('❌ Failed to update system configuration', {
        error: error instanceof Error ? error.message : String(error),
        updates: configData
      });
      throw error;
    }
  }

  /**
   * Invalidate the cached configuration
   */
  public invalidateCache(): void {
    logger.info('🗑️ Invalidating system configuration cache');
    this.cachedConfig = null;
    this.lastFetch = 0;
  }

  /**
   * Check if quota management is enabled (uses cache)
   */
  async isQuotaManagementEnabled(): Promise<boolean> {
    const config = await this.getConfig();
    return config.quotaManagementEnabled;
  }

  /**
   * Check if quota management is enabled, reading directly from DB (no cache).
   * Use this when timer/quota logic must reflect the latest admin setting immediately.
   */
  async isQuotaManagementEnabledFresh(): Promise<boolean> {
    try {
      const config = await prisma.systemConfig.findFirst({
        where: { isActive: true },
        orderBy: { createdAt: 'desc' },
        select: { quotaManagementEnabled: true }
      });
      return config?.quotaManagementEnabled ?? true;
    } catch (error) {
      logger.error('❌ Error reading quota management flag from DB', {
        error: error instanceof Error ? error.message : String(error)
      });
      return true; // default to enabled on error so we don't block users
    }
  }
}

// Export singleton instance
export const systemConfigService = SystemConfigService.getInstance();