#include "yini.hpp"
#include <iostream>

int main() {
    try {
        // Create a new configuration
        yini::Parser config;
        
        // Set values
        config["app_name"] = "MyApplication";
        config["port"] = 8080;
        config["debug"] = true;
        config["timeout"] = 30.5;
        
        // Create nested sections
        config.section("database")["host"] = "localhost";
        config.section("database")["port"] = 5432;
        config.section("database")["ssl_enabled"] = true;
        
        // Create arrays
        std::vector<yini::Value> features = {
            yini::Value("auth"),
            yini::Value("logging"),
            yini::Value("caching")
        };
        config["features"] = features;
        
        // Write to file
        config.write_file("config.yini");
        
        // Read from file
        yini::Parser reader;
        reader.parse_file("config.yini");
        
        // Access values
        std::cout << "App: " << reader["app_name"].as_string() << std::endl;
        std::cout << "Port: " << reader["port"].as_int() << std::endl;
        std::cout << "Debug: " << reader["debug"].as_bool() << std::endl;
        
        // Access nested values
        std::cout << "DB Host: " << reader.section("database")["host"].as_string() << std::endl;
        
    } catch (const std::exception& e) {
        std::cerr << "Error: " << e.what() << std::endl;
        return 1;
    }
    
    return 0;
}

#include "yini.hpp"
#include <iostream>

int main() {
    yini::Parser parser;
    parser.parse_string(R"(
        numbers = [1, 2, 3, 4, 5]
        names = ['alice', 'bob', 'charlie']
        mixed = [true, 42, 'hello', 3.14]
    )");

    // Access arrays
    auto numbers = parser["numbers"].as_array();
    for (const auto& num : numbers) {
        std::cout << "Number: " << num.as_int() << std::endl;
    }

    // Create arrays programmatically
    std::vector<yini::Value> new_array = {
        yini::Value(10),
        yini::Value("test"),
        yini::Value(true)
    };
    parser["new_array"] = new_array;

    return 0;
}

#include "yini.hpp"
#include <iostream>

int main() {
    yini::Parser parser;

    // Parse errors include line numbers
    try {
        parser.parse_string("invalid syntax without equals");
    } catch (const yini::ParseError& e) {
        std::cout << "Parse error: " << e.what() << std::endl;
        // Output: "YINI Parse Error: Error at line 1: Invalid line format..."
    }

    // File errors
    try {
        parser.parse_file("nonexistent_file.yini");
    } catch (const yini::FileError& e) {
        std::cout << "File error: " << e.what() << std::endl;
        // Output: "YINI File Error: Cannot open file: nonexistent_file.yini"
    }

    // Safe value access
    try {
        auto value = parser.root().at("nonexistent_key");
    } catch (const std::out_of_range& e) {
        std::cout << "Key not found: " << e.what() << std::endl;
    }

    return 0;
}

#include "yini.hpp"
#include <iostream>

int main() {
    yini::Parser parser;
    parser.parse_string(R"(
        string_number = '42'
        string_bool = 'true'
        int_value = 100
        double_value = 3.14159
    )");

    // Automatic type conversion
    int num = parser["string_number"].as_int();        // "42" -> 42
    bool flag = parser["string_bool"].as_bool();       // "true" -> true
    std::string text = parser["int_value"].as_string(); // 100 -> "100"
    double pi = parser["double_value"].as_double();     // 3.14159

    // Boolean conversion supports multiple formats
    yini::Value bool_vals[] = {
        yini::Value("true"), yini::Value("yes"), yini::Value("on"),
        yini::Value("false"), yini::Value("no"), yini::Value("off")
    };
    
    for (const auto& val : bool_vals) {
        std::cout << val.as_string() << " -> " << val.as_bool() << std::endl;
    }

    return 0;
}

#include "yini.hpp"
#include <iostream>

int main() {
    yini::Parser parser;
    parser.parse_file("config.yini");

    // Iterate through all root-level values
    for (auto it = parser.root().values_begin(); it != parser.root().values_end(); ++it) {
        std::cout << "Key: " << it->first << ", Value: " << it->second.as_string() << std::endl;
    }

    // Iterate through all sections
    for (auto it = parser.root().sections_begin(); it != parser.root().sections_end(); ++it) {
        std::cout << "Section: " << it->first << std::endl;
        
        // Iterate through values in this section
        for (auto val_it = it->second->values_begin(); val_it != it->second->values_end(); ++val_it) {
            std::cout << "  " << val_it->first << " = " << val_it->second.as_string() << std::endl;
        }
    }

    return 0;
}

#include "yini.hpp"
#include <iostream>

bool validate_config(const yini::Parser& config) {
    // Check required root values
    if (!config.root().has_value("app_name")) {
        std::cerr << "Missing required field: app_name" << std::endl;
        return false;
    }

    // Check required sections
    if (!config.root().has_section("database")) {
        std::cerr << "Missing required section: database" << std::endl;
        return false;
    }

    // Validate value types and ranges
    try {
        int port = config.root().at("port").as_int();
        if (port < 1 || port > 65535) {
            std::cerr << "Port must be between 1 and 65535" << std::endl;
            return false;
        }
    } catch (const std::exception& e) {
        std::cerr << "Invalid port configuration: " << e.what() << std::endl;
        return false;
    }

    return true;
}