{
  "name": "lib-demo2",
  "version": "1.0.0",
  "dependencies": ["cpp-httplib", "nlohmann-json", "cxxopts", "cli11", "catch2", "gtest"],
  "builtin-baseline": "1d611efb49276c65d69fb6d010c2aaaf039322b0"
}

cmake_minimum_required(VERSION 3.15)
project(LibDemo2 CXX)
set(CMAKE_CXX_STANDARD 17)

find_package(httplib CONFIG REQUIRED)
find_package(nlohmann_json CONFIG REQUIRED)
find_package(cxxopts CONFIG REQUIRED)
find_package(CLI11 CONFIG REQUIRED)
find_package(Catch2 CONFIG REQUIRED)

add_executable(server server.cpp)
target_link_libraries(server PRIVATE httplib::httplib nlohmann_json::nlohmann_json)

add_executable(client client.cpp)
target_link_libraries(client PRIVATE httplib::httplib)

# macOS: cpp-httplib використовує системний резолвер Apple
if(APPLE)
    target_link_libraries(server PRIVATE "-framework CoreFoundation" "-framework CFNetwork")
    target_link_libraries(client PRIVATE "-framework CoreFoundation" "-framework CFNetwork")
endif()

add_executable(cli11_demo cli11_demo.cpp)
target_link_libraries(cli11_demo PRIVATE CLI11::CLI11)

add_executable(cxxopts_demo cxxopts_demo.cpp)
target_link_libraries(cxxopts_demo PRIVATE cxxopts::cxxopts)

add_executable(catch_tests catch_tests.cpp)
target_link_libraries(catch_tests PRIVATE Catch2::Catch2WithMain)

enable_testing()
include(CTest)
include(Catch)
catch_discover_tests(catch_tests)

#include <httplib.h>
#include <nlohmann/json.hpp>
#include <iostream>

int main() {
    httplib::Server svr;

    // GET запит
    svr.Get("/", [](const httplib::Request&, httplib::Response& res) {
        res.set_content("Привіт від HTTP сервера!", "text/plain; charset=utf-8");
    });

    // GET з параметром шляху
    svr.Get("/hello/:name", [](const httplib::Request& req, httplib::Response& res) {
        std::string name = req.path_params.at("name");
        res.set_content("Привіт, " + name + "!", "text/plain; charset=utf-8");
    });

    // POST запит
    svr.Post("/api/data", [](const httplib::Request& req, httplib::Response& res) {
        std::cout << "Отримано: " << req.body << std::endl;
        res.set_content("OK", "text/plain");
    });

    // JSON API
    svr.Get("/api/user", [](const httplib::Request&, httplib::Response& res) {
        nlohmann::json user = {{"name", "Іван"}, {"age", 25}};
        res.set_content(user.dump(), "application/json");
    });

    // Зупинка сервера для демонстрації
    svr.Get("/stop", [&](const httplib::Request&, httplib::Response& res) {
        res.set_content("bye", "text/plain");
        svr.stop();
    });

    std::cout << "Сервер запущено на http://localhost:8765" << std::endl;
    svr.listen("localhost", 8765);
    std::cout << "Сервер зупинено" << std::endl;
}

#include <httplib.h>
#include <iostream>

int main() {
    httplib::Client cli("http://localhost:8765");

    auto res = cli.Get("/");
    if (res && res->status == 200) {
        std::cout << "GET /            -> " << res->status << " " << res->body << std::endl;
    }

    res = cli.Get("/hello/Оксана");
    if (res) {
        std::cout << "GET /hello/...   -> " << res->status << " " << res->body << std::endl;
    }

    res = cli.Get("/api/user");
    if (res) {
        std::cout << "GET /api/user    -> " << res->status << " " << res->body
                  << " (" << res->get_header_value("Content-Type") << ")" << std::endl;
    }

    auto post = cli.Post("/api/data", R"({"key": "value"})", "application/json");
    if (post) {
        std::cout << "POST /api/data   -> " << post->status << " " << post->body << std::endl;
    }

    res = cli.Get("/missing");
    if (res) {
        std::cout << "GET /missing     -> " << res->status << std::endl;
    }

    cli.Get("/stop");
}

#include <cxxopts.hpp>
#include <iostream>

int main(int argc, char* argv[]) {
    cxxopts::Options options("MyApp", "Опис програми");

    options.add_options()
        ("f,file", "Input file", cxxopts::value<std::string>())
        ("o,output", "Output file", cxxopts::value<std::string>()->default_value("output.txt"))
        ("v,verbose", "Verbose output", cxxopts::value<bool>()->default_value("false"))
        ("c,count", "Repeat count", cxxopts::value<int>()->default_value("1"))
        ("h,help", "Print help");

    try {
        auto result = options.parse(argc, argv);

        if (result.count("help")) {
            std::cout << options.help() << std::endl;
            return 0;
        }

        if (result.count("file")) {
            std::cout << "Input file: " << result["file"].as<std::string>() << std::endl;
        }

        std::cout << "Output: " << result["output"].as<std::string>() << std::endl;
        std::cout << "Verbose: " << (result["verbose"].as<bool>() ? "yes" : "no") << std::endl;
        std::cout << "Count: " << result["count"].as<int>() << std::endl;
    } catch (const cxxopts::exceptions::exception& e) {
        std::cerr << "Error: " << e.what() << std::endl;
        return 1;
    }
    return 0;
}

#include <CLI/CLI.hpp>
#include <iostream>
#include <string>

int main(int argc, char** argv) {
    CLI::App app{"Демонстрація CLI11"};

    std::string file;
    int count = 1;
    bool verbose = false;

    app.add_option("-f,--file", file, "Вхідний файл")->required();
    app.add_option("-c,--count", count, "Кількість повторів")->check(CLI::PositiveNumber);
    app.add_flag("-v,--verbose", verbose, "Докладний вивід");

    CLI11_PARSE(app, argc, argv);

    std::cout << "file=" << file << " count=" << count << " verbose=" << verbose << std::endl;
    return 0;
}

{ "dependencies": ["gtest"] }

find_package(GTest CONFIG REQUIRED)

add_executable(math_tests tests/test_math.cpp)
target_link_libraries(math_tests PRIVATE GTest::gtest_main MathUtils)

include(GoogleTest)
gtest_discover_tests(math_tests)

#include <catch2/catch_test_macros.hpp>
#include <vector>

int add(int a, int b) {
    return a + b;
}

TEST_CASE("Addition works correctly", "[math]") {
    REQUIRE(add(2, 2) == 4);
    REQUIRE(add(-1, 1) == 0);
    REQUIRE(add(0, 0) == 0);
}

TEST_CASE("Vectors work", "[containers]") {
    std::vector<int> v;

    SECTION("starts empty") {
        REQUIRE(v.empty());
        REQUIRE(v.size() == 0);
    }

    SECTION("can add elements") {
        v.push_back(5);
        REQUIRE(v.size() == 1);
        REQUIRE(v[0] == 5);
    }
}