/*
  Challenge 1: Basic usage of process.env without validation.
  Illustrates potential runtime errors due to missing or mistyped variables.
*/

// Imagine this in a file like 'src/server.ts'
const port = process.env.PORT; // Type is 'string | undefined'
const dbUrl = process.env.DATABASE_URL; // Type is 'string | undefined'
const enableFeature = process.env.ENABLE_FEATURE; // Type is 'string | undefined'

// Problem 1: Missing variables
// If PORT is not set, port becomes undefined. `Number(undefined)` is NaN.
// This crashes the application when trying to listen on NaN.
const actualPort = Number(port); 
if (isNaN(actualPort)) {
  console.error('Error: PORT environment variable is missing or invalid.');
  process.exit(1);
}

// Problem 2: Incorrect types / String-only nature
// ENABLE_FEATURE is always a string. If it's 'true' or 'false',
// direct boolean conversion `!!'false'` evaluates to true.
// Requires manual conversion and careful checks.
const featureEnabled = enableFeature === 'true'; 

console.log(`Server starting on port: ${actualPort}`);
console.log(`Database URL: ${dbUrl}`);
console.log(`Feature enabled: ${featureEnabled}`);

// To run this example:
// 1. Save as 'example.ts'
// 2. npm install typescript ts-node @types/node
// 3. Add to package.json scripts: "start:example": "ts-node example.ts"
// 4. Test without PORT: npm run start:example
// 5. Test with PORT: PORT=3000 npm run start:example
// 6. Test with ENABLE_FEATURE=false: ENABLE_FEATURE=false PORT=3000 npm run start:example

/*
  Challenge 2: Architecting a typed configuration schema using Zod.
  This code defines a clear, validated structure for environment variables.
*/

// 1. Install Zod: npm install zod
// 2. Create a file, e.g., 'src/config/env.schema.ts'

import { z } from 'zod';

/**
 * Defines the Zod schema for our application's environment variables.
 * This enforces types, presence, and specific formats at runtime.
 */
export const envSchema = z.object({
  // NODE_ENV: Enforce specific string values for environment type
  NODE_ENV: z.enum(['development', 'production', 'test']),

  // PORT: Must be a number. Coerce from string. Default to 3000 if not provided.
  // .transform allows custom parsing logic.
  PORT: z.preprocess(
    (val) => Number(val), // Attempt to convert to number
    z.number().min(1024).max(65535) // Validate as a number within port range
  ).default(3000),

  // DATABASE_URL: Must be a string and a valid URL format.
  DATABASE_URL: z.string().url().nonempty(),

  // API_KEY: Must be a non-empty string. Mark as sensitive.
  API_KEY: z.string().nonempty({
    message: 'API_KEY is required for external service authentication.'
  }),

  // FEATURE_FLAG_ANALYTICS: Must be a boolean. Coerce from string 'true'/'false'.
  // Defaults to false if not specified.
  FEATURE_FLAG_ANALYTICS: z.preprocess(
    (val) => val === 'true', // Convert 'true' string to true, anything else to false
    z.boolean()
  ).default(false),

  // Optional variable: e.g., a specific log level
  LOG_LEVEL: z.enum(['debug', 'info', 'warn', 'error']).optional().default('info'),
});

/**
 * Infer the TypeScript type from the Zod schema.
 * This provides static type checking for our validated config object.
 */
export type Env = z.infer<typeof envSchema>;

// To test this schema definition:
// No direct execution needed for schema definition, but it's used in the next step.
// Ensure 'npm install zod' is run.

/*
  Challenge 3: Forging the validated, typed config object.
  This code uses the Zod schema to validate process.env and create an immutable config.
*/

// 1. Ensure 'src/config/env.schema.ts' from Challenge 2 is created.
// 2. Install dotenv for local development: npm install dotenv
// 3. Create a '.env' file in your project root:
//    NODE_ENV=development
//    PORT=4000
//    DATABASE_URL=postgres://user:password@host:5432/mydb
//    API_KEY=mySecretApiKey123
//    FEATURE_FLAG_ANALYTICS=true

// 4. Create a file, e.g., 'src/config/index.ts'

import { envSchema, Env } from './env.schema';
import dotenv from 'dotenv';
import { join } from 'path';

// Load environment variables from .env file during development.
// Do this FIRST, before parsing process.env.
// Note: dotenv only loads if the variable is not already set in process.env
// (e.g., from your hosting provider).
// We explicitly specify the path to ensure it's found from anywhere.
dotenv.config({ path: join(process.cwd(), '.env') });

// Declare a mutable variable for the config initially.
let validatedConfig: Env | undefined = undefined;

/**
 * Function to get the validated and typed environment configuration.
 * Implements a singleton pattern to ensure the config is parsed only once.
 * Throws an error if validation fails, preventing the application from starting
 * with an invalid configuration.
 * @returns The frozen, validated environment configuration object.
 */
export function getValidatedConfig(): Env {
  // If config is already validated, return it immediately.
  if (validatedConfig) {
    return validatedConfig;
  }

  // Attempt to parse and validate process.env against the schema.
  const parseResult = envSchema.safeParse(process.env);

  // Handle validation errors.
  if (!parseResult.success) {
    const errorMessages = parseResult.error.errors.map(err => {
      return `Env var '${err.path.join('.') || 'root'}': ${err.message}`;
    });
    console.error('Environment configuration validation failed:\n', errorMessages.join('\n'));
    // Exit the process immediately if config is invalid. This prevents running with bad config.
    process.exit(1);
  }

  // Assign the successful parse result.
  validatedConfig = parseResult.data;

  // Freeze the object to ensure immutability at runtime.
  // This prevents accidental modification of config values after startup.
  Object.freeze(validatedConfig);

  return validatedConfig;
}

// Example of how to use the config in your application (e.g., 'src/app.ts' or 'src/server.ts')
import { getValidatedConfig } from './config';

const config = getValidatedConfig();

console.log('Application Configuration:');
console.log(`Node Environment: ${config.NODE_ENV}`);
console.log(`Server Port: ${config.PORT}`);
console.log(`Database URL: ${config.DATABASE_URL.slice(0, 20)}...`); // Censor sensitive parts
console.log(`Analytics Feature Flag: ${config.FEATURE_FLAG_ANALYTICS}`);
console.log(`Log Level: ${config.LOG_LEVEL}`);
// console.log(`API Key: ${config.API_KEY}`); // WARNING: Do not log sensitive keys in production!

// Now 'config' is fully typed! No more 'string | undefined'.
// const portNumber: number = config.PORT; // TypeScript knows it's a number

// To run this example:
// 1. Ensure steps 1-3 are done.
// 2. Save as 'src/config/index.ts' (and the import example in another file).
// 3. Add to package.json scripts: "start:app": "ts-node src/config/index.ts"
// 4. Run: npm run start:app
// 5. To test failure: Remove PORT from .env and run again.

/*
  Challenge 4: Advanced strategies for security, dev/prod parity, and testing.
  This section demonstrates sensitive variable handling and testing mocks.
*/

// 1. Assuming 'src/config/index.ts' and '.env' are set up.

// --- Part A: Sensitive Variable Handling Best Practices ---
// (No specific code here, but conceptual guidance)

/*
   Good Practice: NEVER commit sensitive .env files to version control.
   Add '.env' to your '.gitignore' file:

   # .gitignore
   .env
   .env.local
   .env.development.local
   .env.test.local
   .env.production.local
*/

/*
   Production: Do not rely on .env files. Use secure methods:
   - Environment variables injected by your hosting platform (e.g., Heroku, Vercel, AWS ECS).
   - Dedicated secrets management services (e.g., AWS Secrets Manager, Google Secret Manager, HashiCorp Vault).
   - Kubernetes Secrets (for containerized deployments).
*/

// --- Part B: Environment-Specific Configuration Example ---
// Adjusting behavior based on NODE_ENV is a common pattern.

// Example: src/services/database.ts
import { getValidatedConfig } from '../config';

const config = getValidatedConfig();

export class DatabaseService {
  private readonly dbUrl: string;
  private readonly isProd: boolean;

  constructor() {
    this.dbUrl = config.DATABASE_URL;
    this.isProd = config.NODE_ENV === 'production';

    if (!this.isProd && config.LOG_LEVEL === 'debug') {
      console.log('Running in development/test mode, enabling verbose DB logging.');
    }
  }

  connect() {
    console.log(`Connecting to database: ${this.dbUrl.slice(0, 20)}...`);
    // Actual DB connection logic here
    if (this.isProd) {
      console.log('Production database connection established.');
    } else {
      console.log('Development/Test database connection established.');
    }
  }

  // ... other database operations
}

// --- Part C: Mocking Environment Variables for Testing ---

// Example: tests/config.test.ts (using Jest)
// 1. Install Jest and its types: npm install jest @types/jest ts-jest
// 2. Configure ts-jest (npx ts-jest config:init)

/*
// Mock dotenv and process.env for isolated testing of config validation.
// This ensures tests are deterministic and don't depend on actual .env files.

// Note: This example assumes your getValidatedConfig() function is in 'src/config/index.ts'
// and that it *does not* globally load dotenv if not explicitly called.

// To mock process.env, you typically need to reset it before each test and set specific values.

describe('Environment Configuration', () => {
  // Store original process.env to restore later
  const originalEnv = process.env;

  beforeEach(() => {
    // Reset process.env before each test to ensure isolation
    jest.resetModules(); // Clears module cache for re-importing config
    process.env = { ...originalEnv }; // Restore a clean copy
  });

  afterAll(() => {
    // Restore the original process.env after all tests are done
    process.env = originalEnv;
  });

  test('should load valid environment variables successfully', () => {
    process.env.NODE_ENV = 'test';
    process.env.PORT = '5000';
    process.env.DATABASE_URL = 'sqlite://test.db';
    process.env.API_KEY = 'test_key';
    process.env.FEATURE_FLAG_ANALYTICS = 'true';
    process.env.LOG_LEVEL = 'debug';

    // Dynamically import the config module *after* setting env vars for the test
    const { getValidatedConfig } = require('../src/config'); 
    const config = getValidatedConfig();

    expect(config.NODE_ENV).toBe('test');
    expect(config.PORT).toBe(5000); // Zod converts to number
    expect(config.DATABASE_URL).toBe('sqlite://test.db');
    expect(config.API_KEY).toBe('test_key');
    expect(config.FEATURE_FLAG_ANALYTICS).toBe(true);
    expect(config.LOG_LEVEL).toBe('debug');
  });

  test('should throw error for missing required variable', () => {
    process.env.NODE_ENV = 'test';
    process.env.PORT = '5000';
    // Omit DATABASE_URL to cause validation failure
    process.env.API_KEY = 'test_key';

    // We expect the process to exit, so we mock process.exit
    const mockExit = jest.spyOn(process, 'exit').mockImplementation(() => { 
        throw new Error('process.exit was called'); // Throw to break out of test
    });

    expect(() => {
      const { getValidatedConfig } = require('../src/config');
      getValidatedConfig();
    }).toThrow('process.exit was called');

    expect(mockExit).toHaveBeenCalledWith(1);
    mockExit.mockRestore(); // Clean up the mock
  });

  // Add more tests for invalid types, default values, etc.
});
*/

// To run the database service example:
// 1. Ensure getValidatedConfig() is correctly implemented.
// 2. Save as 'src/services/database.ts'
// 3. In another file (e.g., src/app.ts):
//    import { DatabaseService } from './services/database';
//    const db = new DatabaseService();
//    db.connect();
// 4. Run: npm run start:app

// To run the tests:
// 1. Set up Jest as described.
// 2. Uncomment the test block.
// 3. Run: npm test