#include "Argonaut.h"
#include <iostream>
#include <string>
#include <vector>

int main(int argc, char* argv[])
{
    // 1. Create a parser instance
    Argonaut::Parser parser;
    
    // 2. Configure the parser using the fluent API
    parser
        .SetVersion("v1.2.3")
        .AutoHelp(true)
        .AutoVersion(true)
        .Add(
            // A required positional argument
            Argonaut::Argument("FILE")
                .SetDescription("The input file to process.")
                .Required()
        )
        .Add(
            // An integer option with default value
            Argonaut::Argument("COUNT")
                .SetDescription("Number of iterations.")
                .AddAlias("-n")
                .AddAlias("--count")
                .SetDefaultValue("10")
        )
        .Add(
            // A simple flag
            Argonaut::Argument("VERBOSE")
                .SetDescription("Enable verbose output.")
                .AddAlias("--verbose")
                .Flag()
        )
        .Add(
            // A floating point multi-value option
            Argonaut::Argument("SCALE")
                .SetDescription("Scale factors.")
                .AddAlias("-s")
                .AddAlias("--scale")
                .MultiValue()
        );

    // 3. Run the parser inside a try...catch block
    try
    {
        parser.Parse(argc, argv);
    }
    catch (const Argonaut::HelpRequestedException& e)
    {
        std::cout << e.what(); // Print help and exit
        return 0; 
    }
    catch (const Argonaut::VersionRequestedException& e)
    {
        std::cout << "My-App " << e.what() << std::endl; // Print version and exit
        return 0; 
    }
    catch (const Argonaut::Exception& e)
    {
        std::cerr << "Error: " << e.what() << "\n\n";
        std::cerr << parser.Help(); // Print help on error
        return 1;
    }

    // 4. Retrieve your parsed values (Type-Safe!)
    try
    {
        // Retrieve string (default)
        std::string inputFile = parser.GetValuesOf("FILE")[0];
        
        // Retrieve integer automatically
        int count = parser.GetValuesOf<int>("COUNT")[0];
        
        // Retrieve boolean automatically (checks for "true", "1", "yes", "on")
        // For flags, we usually check emptiness, but GetValuesOf<bool> works if provided explicitly.
        bool verbose = !parser.GetValuesOf("VERBOSE").empty();

        // Retrieve vector of floats
        std::vector<float> scales = parser.GetValuesOf<float>("SCALE");

        // --- Application Logic ---
        std::cout << "File: " << inputFile << "\n";
        std::cout << "Count: " << count << "\n";
        std::cout << "Verbose: " << std::boolalpha << verbose << "\n";
        
        for(float s : scales) std::cout << "Scale: " << s << "\n";

    }
    catch(const std::exception& e)
    {
        std::cerr << "Conversion Error: " << e.what() << std::endl;
        return 1;
    }

    return 0;
}

struct Vector3 { float x, y, z; };

// Specialize the converter in the Argonaut namespace
namespace Argonaut {
    template<> struct ArgumentConverter<Vector3> {
        static Vector3 Convert(const std::string& v) {
            // Example parsing logic for "1.0,2.0,3.0"
            Vector3 result{0,0,0};
            sscanf(v.c_str(), "%f,%f,%f", &result.x, &result.y, &result.z);
            return result;
        }
    };
}

// Usage in main:
// parser.Add(Argonaut::Argument("POS").AddAlias("--pos"));
// ...
// Vector3 pos = parser.GetValuesOf<Vector3>("POS")[0];