// Centralized environment loader
import path from 'path';
import { fileURLToPath } from 'url';
import dotenv from 'dotenv';
import fs from 'fs';

const __filename = fileURLToPath(import.meta.url);
const __dirname = path.dirname(__filename);

const quietEnv = process.env.QUIET_ENV_LOGS === '1';
const dotenvQuiet = quietEnv || process.env.DOTENV_CONFIG_QUIET === '1';

function log(...args) {
  if (!quietEnv) console.log(...args);
}
function warn(...args) {
  console.warn(...args);
}

// Versuche zuerst Produktions-.env, dann lokale .env
const productionEnvPath = '/opt/yourpart/backend/.env';
const localEnvPath = path.resolve(__dirname, '../.env');

let envPath = localEnvPath; // Fallback
let usingProduction = false;
if (fs.existsSync(productionEnvPath)) {
  // Prüfe Lesbarkeit bevor wir versuchen, sie zu laden
  try {
    fs.accessSync(productionEnvPath, fs.constants.R_OK);
    envPath = productionEnvPath;
    usingProduction = true;
    log('[env] Produktions-.env gefunden und lesbar:', productionEnvPath);
  } catch (err) {
    if (!quietEnv) {
      warn('[env] Produktions-.env vorhanden, aber nicht lesbar - verwende lokale .env stattdessen:', productionEnvPath);
      warn('[env] Fehler:', err && err.message);
    }
    envPath = localEnvPath;
  }
} else {
  log('[env] Produktions-.env nicht gefunden, lade lokale .env:', localEnvPath);
}

// Lade .env-Datei (robust gegen Fehler)
log('[env] Versuche .env zu laden von:', envPath);
log('[env] Datei existiert:', fs.existsSync(envPath));
let result;
try {
  result = dotenv.config({ path: envPath, quiet: dotenvQuiet });
  if (result.error) {
    warn('[env] Konnte .env nicht laden:', result.error.message);
    warn('[env] Fehler-Details:', result.error);
  } else {
    log('[env] .env erfolgreich geladen von:', envPath, usingProduction ? '(production)' : '(local)');
    log('[env] Geladene Variablen:', Object.keys(result.parsed || {}));
  }
} catch (err) {
  // Sollte nicht passieren, aber falls dotenv intern eine Exception wirft (z.B. EACCES), fange sie ab
  warn('[env] Unerwarteter Fehler beim Laden der .env:', err && err.message);
  warn('[env] Stack:', err && err.stack);
  if (envPath !== localEnvPath && fs.existsSync(localEnvPath)) {
    log('[env] Versuche stattdessen lokale .env:', localEnvPath);
    try {
      result = dotenv.config({ path: localEnvPath, quiet: dotenvQuiet });
      if (!result.error) {
        log('[env] Lokale .env erfolgreich geladen von:', localEnvPath);
      }
    } catch (err2) {
      warn('[env] Konnte lokale .env auch nicht laden:', err2 && err2.message);
    }
  }
}

// Lokale Überschreibungen (nicht committen): z. B. SSH-Tunnel DB_HOST=127.0.0.1 DB_PORT=60000
const localOverridePath = path.resolve(__dirname, '../.env.local');
if (fs.existsSync(localOverridePath)) {
  const overrideResult = dotenv.config({ path: localOverridePath, override: true, quiet: dotenvQuiet });
  if (!overrideResult.error) {
    log('[env] .env.local geladen (überschreibt Werte, z. B. SSH-Tunnel)');
  } else {
    warn('[env] .env.local vorhanden, aber Laden fehlgeschlagen:', overrideResult.error?.message);
  }
}

if (!quietEnv) {
  console.log('[env] Redis-Konfiguration:');
  console.log('[env] REDIS_HOST:', process.env.REDIS_HOST);
  console.log('[env] REDIS_PORT:', process.env.REDIS_PORT);
  console.log('[env] REDIS_PASSWORD:', process.env.REDIS_PASSWORD ? '***gesetzt***' : 'NICHT GESETZT');
  console.log('[env] REDIS_URL:', process.env.REDIS_URL);
}

if (!process.env.SECRET_KEY) {
  warn('[env] SECRET_KEY nicht gesetzt in .env');
}
export {};