// Export all schemas
export * from './schemas';

// Export types
export * from './types';

// Export errors
export * from './errors';

// Export loaders
export { EnvLoader } from './loaders/env.loader';
export { FileLoader } from './loaders/file.loader';

// Export ConfigManager
export { ConfigManager } from './config-manager';

// Export utilities
export * from './utils/secrets';
export * from './utils/validation';

// Import necessary types for singleton
import { ConfigManager } from './config-manager';
import { AppConfig, appConfigSchema } from './schemas';
import { FileLoader } from './loaders/file.loader';
import { EnvLoader } from './loaders/env.loader';

// Create singleton instance
let configInstance: ConfigManager<AppConfig> | null = null;

/**
 * Initialize the global configuration
 */
export async function initializeConfig(
  configPath?: string
): Promise<AppConfig> {
  if (!configInstance) {
    configInstance = new ConfigManager<AppConfig>({
      configPath,
    });
  }
  return configInstance.initialize(appConfigSchema);
}

/**
 * Initialize configuration for a service in a monorepo
 * Automatically loads configs from:
 * 1. Root config directory (../../config)
 * 2. Service-specific config directory (./config)
 * 3. Environment variables
 */
export async function initializeServiceConfig(): Promise<AppConfig> {
  if (!configInstance) {
    const environment = process.env.NODE_ENV || 'development';
    configInstance = new ConfigManager<AppConfig>({
      loaders: [
        new FileLoader('../../config', environment), // Root config
        new FileLoader('./config', environment),     // Service config  
        new EnvLoader(''), // Environment variables
      ]
    });
  }
  return configInstance.initialize(appConfigSchema);
}

/**
 * Get the current configuration
 */
export function getConfig(): AppConfig {
  if (!configInstance) {
    throw new Error('Configuration not initialized. Call initializeConfig() first.');
  }
  return configInstance.get();
}

/**
 * Get configuration manager instance
 */
export function getConfigManager(): ConfigManager<AppConfig> {
  if (!configInstance) {
    throw new Error('Configuration not initialized. Call initializeConfig() first.');
  }
  return configInstance;
}

/**
 * Reset configuration (useful for testing)
 */
export function resetConfig(): void {
  if (configInstance) {
    configInstance.reset();
    configInstance = null;
  }
}

// Export convenience functions for common configs
export function getDatabaseConfig() {
  return getConfig().database;
}

export function getServiceConfig() {
  return getConfig().service;
}

export function getLoggingConfig() {
  return getConfig().logging;
}

export function getProviderConfig(provider: string) {
  const providers = getConfig().providers;
  if (!providers || !(provider in providers)) {
    throw new Error(`Provider configuration not found: ${provider}`);
  }
  return (providers as Record<string, unknown>)[provider];
}

// Export environment helpers
export function isDevelopment(): boolean {
  return getConfig().environment === 'development';
}

export function isProduction(): boolean {
  return getConfig().environment === 'production';
}

export function isTest(): boolean {
  return getConfig().environment === 'test';
}