Config as Data

const std = @import("std");

/// Configuration structure for an application with sensible defaults
const AppConfig = struct {
    /// Theme options for the application UI
    pub const Theme = enum { system, light, dark };

    // Default configuration values are specified inline
    host: []const u8 = "127.0.0.1",
    port: u16 = 8080,
    log_level: std.log.Level = .info,
    instrumentation: bool = false,
    theme: Theme = .system,
    timeouts: Timeouts = .{},

    /// Nested configuration for timeout settings
    pub const Timeouts = struct {
        connect_ms: u32 = 200,
        read_ms: u32 = 1200,
    };
};

/// Helper function to print configuration values in a human-readable format
/// writer: any type implementing write() and print() methods
/// label: descriptive text to identify this configuration dump
/// config: the AppConfig instance to display
fn dumpConfig(writer: anytype, label: []const u8, config: AppConfig) !void {
    // Print the label header
    try writer.print("{s}\n", .{label});
    
    // Print each field with proper formatting
    try writer.print("  host = {s}\n", .{config.host});
    try writer.print("  port = {}\n", .{config.port});
    
    // Use @tagName to convert enum values to strings
    try writer.print("  log_level = {s}\n", .{@tagName(config.log_level)});
    try writer.print("  instrumentation = {}\n", .{config.instrumentation});
    try writer.print("  theme = {s}\n", .{@tagName(config.theme)});
    
    // Print nested struct in single line
    try writer.print(
        "  timeouts = .{{ connect_ms = {}, read_ms = {} }}\n",
        .{ config.timeouts.connect_ms, config.timeouts.read_ms },
    );
}

pub fn main() !void {
    // Allocate a fixed buffer for stdout operations
    var stdout_buffer: [2048]u8 = undefined;
    
    // Create a buffered writer for stdout to reduce syscalls
    var stdout_writer = std.fs.File.stdout().writer(&stdout_buffer);
    const stdout = &stdout_writer.interface;

    // Create a config using all default values (empty initializer)
    const defaults = AppConfig{};
    try dumpConfig(stdout, "defaults ->", defaults);

    // Create a config with several overridden values
    // Fields not specified here retain their defaults from the struct definition
    const tuned = AppConfig{
        .host = "0.0.0.0",        // Bind to all interfaces
        .port = 9090,              // Custom port
        .log_level = .debug,       // More verbose logging
        .instrumentation = true,   // Enable performance monitoring
        .theme = .dark,            // Dark theme instead of system default
        .timeouts = .{             // Override nested timeout values
            .connect_ms = 75,      // Faster connection timeout
            .read_ms = 1500,       // Longer read timeout
        },
    };

    // Add blank line between the two config dumps
    try stdout.writeByte('\n');
    
    // Display the customized configuration
    try dumpConfig(stdout, "overrides ->", tuned);
    
    // Flush the buffer to ensure all output is written to stdout
    try stdout.flush();
}

const std = @import("std");

/// Configuration structure for an application with sensible defaults
const AppConfig = struct {
    /// Theme options for the application UI
    pub const Theme = enum { system, light, dark };

    host: []const u8 = "127.0.0.1",
    port: u16 = 8080,
    log_level: std.log.Level = .info,
    instrumentation: bool = false,
    theme: Theme = .system,
    timeouts: Timeouts = .{},

    /// Nested configuration for timeout settings
    pub const Timeouts = struct {
        connect_ms: u32 = 200,
        read_ms: u32 = 1200,
    };
};

/// Structure representing optional configuration overrides
/// Each field is optional (nullable) to indicate whether it should override the base config
const Overrides = struct {
    host: ?[]const u8 = null,
    port: ?u16 = null,
    log_level: ?std.log.Level = null,
    instrumentation: ?bool = null,
    theme: ?AppConfig.Theme = null,
    timeouts: ?AppConfig.Timeouts = null,
};

/// Merges a single layer of overrides into a base configuration
/// base: the starting configuration to modify
/// overrides: optional values that should replace corresponding base fields
/// Returns: a new AppConfig with overrides applied
fn merge(base: AppConfig, overrides: Overrides) AppConfig {
    // Start with a copy of the base configuration
    var result = base;
    
    // Iterate over all fields in the Overrides struct at compile time
    inline for (std.meta.fields(Overrides)) |field| {
        // Check if this override field has a non-null value
        if (@field(overrides, field.name)) |value| {
            // If present, replace the corresponding field in result
            @field(result, field.name) = value;
        }
    }
    
    return result;
}

/// Applies a chain of override layers in sequence
/// base: the initial configuration
/// chain: slice of Overrides to apply in order (left to right)
/// Returns: final configuration after all layers are merged
fn apply(base: AppConfig, chain: []const Overrides) AppConfig {
    // Start with the base configuration
    var current = base;
    
    // Apply each override layer in sequence
    // Later layers override earlier ones
    for (chain) |layer| {
        current = merge(current, layer);
    }
    
    return current;
}

/// Helper function to print configuration values in a human-readable format
/// writer: any type implementing write() and print() methods
/// label: descriptive text to identify this configuration dump
/// config: the AppConfig instance to display
fn printSummary(writer: anytype, label: []const u8, config: AppConfig) !void {
    try writer.print("{s}:\n", .{label});
    try writer.print("  host = {s}\n", .{config.host});
    try writer.print("  port = {}\n", .{config.port});
    try writer.print("  log = {s}\n", .{@tagName(config.log_level)});
    try writer.print("  instrumentation = {}\n", .{config.instrumentation});
    try writer.print("  theme = {s}\n", .{@tagName(config.theme)});
    try writer.print("  timeouts = {any}\n", .{config.timeouts});
}

pub fn main() !void {
    // Create base configuration with all default values
    const defaults = AppConfig{};
    
    // Define a profile-level override layer (e.g., development profile)
    // This might come from a profile file or environment-specific settings
    const profile = Overrides{
        .host = "0.0.0.0",
        .port = 9000,
        .log_level = .debug,
        .instrumentation = true,
        .theme = .dark,
        .timeouts = AppConfig.Timeouts{
            .connect_ms = 100,
            .read_ms = 1500,
        },
    };
    
    // Define environment-level overrides (e.g., from environment variables)
    // These override profile settings
    const env = Overrides{
        .host = "config.internal",
        .port = 9443,
        .log_level = .warn,
        .timeouts = AppConfig.Timeouts{
            .connect_ms = 60,
            .read_ms = 1100,
        },
    };
    
    // Define command-line overrides (highest priority)
    // Only overrides specific fields, leaving others unchanged
    const command_line = Overrides{
        .instrumentation = false,
        .theme = .light,
    };

    // Apply all override layers in precedence order:
    // defaults -> profile -> env -> command_line
    // Later layers take precedence over earlier ones
    const final = apply(defaults, &[_]Overrides{ profile, env, command_line });

    // Set up buffered stdout writer to reduce syscalls
    var stdout_buffer: [2048]u8 = undefined;
    var stdout_writer = std.fs.File.stdout().writer(&stdout_buffer);
    const stdout = &stdout_writer.interface;
    
    // Display progression of configuration through each layer
    try printSummary(stdout, "defaults", defaults);
    try printSummary(stdout, "profile", merge(defaults, profile));
    try printSummary(stdout, "env", merge(defaults, env));
    try printSummary(stdout, "command_line", merge(defaults, command_line));
    
    // Add separator before showing final resolved config
    try stdout.writeByte('\n');
    
    // Display the final merged configuration after all layers applied
    try printSummary(stdout, "resolved", final);
    
    // Ensure all buffered output is written
    try stdout.flush();
}

const std = @import("std");

/// Environment mode for the application
/// Determines security requirements and runtime behavior
const Mode = enum { development, staging, production };

/// Main application configuration structure with nested settings
const AppConfig = struct {
    host: []const u8 = "127.0.0.1",
    port: u16 = 8080,
    mode: Mode = .development,
    tls: Tls = .{},
    timeouts: Timeouts = .{},

    /// TLS/SSL configuration for secure connections
    pub const Tls = struct {
        enabled: bool = false,
        cert_path: ?[]const u8 = null,
        key_path: ?[]const u8 = null,
    };

    /// Timeout settings for network operations
    pub const Timeouts = struct {
        connect_ms: u32 = 200,
        read_ms: u32 = 1200,
    };
};

/// Explicit error set for all configuration validation failures
/// Each variant represents a specific invariant violation
const ConfigError = error{
    InvalidPort,
    InsecureProduction,
    MissingTlsMaterial,
    TimeoutOrdering,
};

/// Validates configuration invariants and business rules
/// config: the configuration to validate
/// Returns: ConfigError if any validation rule is violated
fn validate(config: AppConfig) ConfigError!void {
    // Port 0 is reserved and invalid for network binding
    if (config.port == 0) return error.InvalidPort;
    
    // Ports below 1024 require elevated privileges (except standard HTTPS)
    // Reject them to avoid privilege escalation requirements
    if (config.port < 1024 and config.port != 443) return error.InvalidPort;

    // Production environments must enforce TLS to protect data in transit
    if (config.mode == .production and !config.tls.enabled) {
        return error.InsecureProduction;
    }

    // When TLS is enabled, both certificate and private key must be provided
    if (config.tls.enabled) {
        if (config.tls.cert_path == null or config.tls.key_path == null) {
            return error.MissingTlsMaterial;
        }
    }

    // Read timeout must exceed connect timeout to allow data transfer
    // Otherwise connections would time out immediately after establishment
    if (config.timeouts.read_ms < config.timeouts.connect_ms) {
        return error.TimeoutOrdering;
    }
}

/// Reports validation result in human-readable format
/// writer: output destination for the report
/// label: descriptive name for this configuration test case
/// config: the configuration to validate and report on
fn report(writer: anytype, label: []const u8, config: AppConfig) !void {
    try writer.print("{s}: ", .{label});
    
    // Attempt validation and catch any errors
    validate(config) catch |err| {
        // If validation fails, report the error name and return
        return try writer.print("error {s}\n", .{@errorName(err)});
    };
    
    // If validation succeeded, report success
    try writer.print("ok\n", .{});
}

pub fn main() !void {
    // Test case 1: Valid production configuration
    // All security requirements met: TLS enabled with credentials
    const production = AppConfig{
        .host = "example.com",
        .port = 8443,
        .mode = .production,
        .tls = .{
            .enabled = true,
            .cert_path = "certs/app.pem",
            .key_path = "certs/app.key",
        },
        .timeouts = .{
            .connect_ms = 250,
            .read_ms = 1800,
        },
    };

    // Test case 2: Invalid - production mode without TLS
    // Should trigger InsecureProduction error
    const insecure = AppConfig{
        .mode = .production,
        .tls = .{ .enabled = false },
    };

    // Test case 3: Invalid - read timeout less than connect timeout
    // Should trigger TimeoutOrdering error
    const misordered = AppConfig{
        .timeouts = .{
            .connect_ms = 700,
            .read_ms = 500,
        },
    };

    // Test case 4: Invalid - TLS enabled but missing certificate
    // Should trigger MissingTlsMaterial error
    const missing_tls_material = AppConfig{
        .mode = .staging,
        .tls = .{
            .enabled = true,
            .cert_path = null,
            .key_path = "certs/dev.key",
        },
    };

    // Set up buffered stdout writer to reduce syscalls
    var stdout_buffer: [1024]u8 = undefined;
    var stdout_writer = std.fs.File.stdout().writer(&stdout_buffer);
    const stdout = &stdout_writer.interface;
    
    // Run validation reports for all test cases
    // Each report will validate the config and print the result
    try report(stdout, "production", production);
    try report(stdout, "insecure", insecure);
    try report(stdout, "misordered", misordered);
    try report(stdout, "missing_tls_material", missing_tls_material);
    
    // Ensure all buffered output is written to stdout
    try stdout.flush();
}