//
// Created by ling on 24-2-4.
//
#include <gtest/gtest.h>
#include <Options.h>
#include <Order.h>
#include "OptionsException.h"

TEST(Option, 负数测试) {
    try {
        ling::Order order({"--number", "-10"});
        const auto number = order.addOption({"-n", "--number"}, ling::Order::INT);
        order.analysis();
        ASSERT_TRUE(number.isExistence());
        ASSERT_EQ(number.getInt64(), -10);
    } catch (const ling::OptionsException &e) {
        ASSERT_FALSE(e.what());
    }
}

TEST(Option, 16进制测试) {
    try {
        ling::Order order({"--hex", "0x1F", "--hex2", "0x1f"});
        const auto hex = order.addOption({"--hex"}, ling::Order::INT);
        const auto hex2 = order.addOption({"--hex2"}, ling::Order::INT);
        order.analysis();
        ASSERT_TRUE(hex.isExistence());
        ASSERT_TRUE(hex2.isExistence());
        ASSERT_EQ(hex.getInt64(), 0x1f);
        ASSERT_EQ(hex2.getInt64(), 0x1f);
    } catch (const ling::OptionsException &e) {
        ASSERT_FALSE(e.what());
    }
}

TEST(Option, 选项测试) {
    try {
        ling::Order order({"-pts", "--all", "--ok"});
        const auto pts = order.addOption({"-pts", "--pts"});
        const auto all = order.addOption({"-all", "--all"});
        const auto ok = order.addOption({"--ok", "-ok"});
        const auto cancel = order.addOption({"--cancel"});
        order.analysis();
        ASSERT_TRUE(pts.isOption());
        ASSERT_TRUE(all.isOption());
        ASSERT_TRUE(ok.isOption());
        ASSERT_FALSE(cancel.isOption());
    } catch (const ling::OptionsException &e) {
        std::cout << e.what() << std::endl;
        ASSERT_FALSE("解析出错！");
    }
}

TEST(Option, 参数测试) {
    try {
        ling::Order order({"-pts", "hello world!", "--all", "--ok"});
        const auto pts = order.addOption({"-pts", "--pts"}, ling::Order::Type::STRING);
        const auto all = order.addOption({"-all", "--all"});
        const auto ok = order.addOption({"--ok", "-ok"});
        const auto cancel = order.addOption({"--cancel"});
        order.analysis();
        ASSERT_TRUE(all.isOption());
        ASSERT_TRUE(ok.isOption());
        ASSERT_FALSE(cancel.isOption());
        ASSERT_TRUE(pts.getString() == "hello world!");
    } catch (const ling::OptionsException &e) {
        std::cout << e.what() << std::endl;
        ASSERT_FALSE("解析出错！");
    }
}


TEST(Option, 异常参数测试) {
    ling::Order order({"-pts", "--all", "--ok"});
    const auto pts = order.addOption({"-pts", "--pts"}, ling::Order::Type::STRING);
    const auto all = order.addOption({"-all", "--all"});
    const auto ok = order.addOption({"--ok", "-ok"});
    const auto cancel = order.addOption({"--cancel"});
    try {
        order.analysis();
        ASSERT_EQ(pts.getString(), "--all");
        ASSERT_FALSE(all.isExistence());
        ASSERT_TRUE(ok.isExistence());
        ASSERT_FALSE(cancel.isExistence());
    } catch (const ling::OptionsException &e) {
        ASSERT_FALSE("解析失败");
    }
}

TEST(Option, 匿名参数测试) {
    try {
        ling::Order order({"-pts", "hello world!", "hello!", "--all", "--ok"});
        order.addAnonymity(1);
        const auto pts = order.addOption({"-pts", "--pts"}, ling::Order::Type::STRING);
        const auto all = order.addOption({"-all", "--all"});
        const auto ok = order.addOption({"--ok", "-ok"});
        const auto cancel = order.addOption({"--cancel"});
        order.analysis();
        ASSERT_TRUE(all.isOption());
        ASSERT_TRUE(ok.isOption());
        ASSERT_FALSE(cancel.isOption());
        ASSERT_TRUE(pts.getString() == "hello world!");
        ASSERT_TRUE(order.getAnonymity().size() == 1);
        ASSERT_TRUE(order.getAnonymity()[0] == "hello!");
    } catch (const ling::OptionsException &e) {
        std::cout << e.what() << std::endl;
        ASSERT_FALSE("解析出错！");
    }
}

TEST(Option, 匿名参数测试2) {
    try {
        ling::Order order({"-pts", "hello world!", "hello!", "--all", "--ok", "world"});
        order.addAnonymity(2);
        const auto pts = order.addOption({"-pts", "--pts"}, ling::Order::Type::STRING);
        const auto all = order.addOption({"-all", "--all"});
        const auto ok = order.addOption({"--ok", "-ok"});
        const auto cancel = order.addOption({"--cancel"});
        order.analysis();

        ASSERT_TRUE(all.isOption());
        ASSERT_TRUE(ok.isOption());
        ASSERT_FALSE(cancel.isOption());
        ASSERT_TRUE(pts.getString() == "hello world!");
        ASSERT_TRUE(order.getAnonymity().size() == 2);
        ASSERT_TRUE(order.getAnonymity()[0] == "hello!");
        ASSERT_TRUE(order.getAnonymity()[1] == "world");
    } catch (const ling::OptionsException &e) {
        std::cout << e.what() << std::endl;
        ASSERT_FALSE("解析出错！");
    }
}

TEST(Option, 匿名参数测试3) {
    ling::Order order({"-pts", "hello world!", "hello!", "--all", "--ok", "world"});
    order.addAnonymity(1);
    const auto pts = order.addOption({"-pts", "--pts"}, ling::Order::Type::STRING);
    const auto all = order.addOption({"-all", "--all"});
    const auto ok = order.addOption({"--ok", "-ok"});
    const auto cancel = order.addOption({"--cancel"});
    try {
        order.analysis();
        ASSERT_FALSE("匿名参数数量超出限制，但是没有抛出异常！");
    } catch (const ling::OptionsException &e) {
    }
}


TEST(Option, Help生成) {
    ling::Order order({"-pts", "hello world!", "hello!", "--all", "--ok", "world"});
    order.addAnonymity(1);
    const auto pts = order.addOption({"-pts", "--pts"}, ling::Order::Type::STRING, "测试参数");
    const auto all = order.addOption({"-all", "--all"}, "测试参数");
    const auto ok = order.addOption({"-ok", "--ok"}, "测试参数");
    const auto cancel = order.addOption({"--cancel"}, "测试参数");
    auto help = order.generateHelp("test [选项] .. [参数]\n测试命令");
    std::cout << help << std::endl;
}