{
  "name": "lib-demo",
  "version": "1.0.0",
  "dependencies": ["fmt", "spdlog", "nlohmann-json"],
  "builtin-baseline": "1d611efb49276c65d69fb6d010c2aaaf039322b0"
}

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

find_package(fmt CONFIG REQUIRED)
find_package(spdlog CONFIG REQUIRED)
find_package(nlohmann_json CONFIG REQUIRED)

add_executable(fmt_demo fmt_demo.cpp)
target_link_libraries(fmt_demo PRIVATE fmt::fmt)

add_executable(spdlog_demo spdlog_demo.cpp)
target_link_libraries(spdlog_demo PRIVATE spdlog::spdlog)

add_executable(json_demo json_demo.cpp)
target_link_libraries(json_demo PRIVATE nlohmann_json::nlohmann_json)

cmake -B build -DCMAKE_TOOLCHAIN_FILE=$VCPKG_ROOT/scripts/buildsystems/vcpkg.cmake
cmake --build build

#include <fmt/core.h>
#include <fmt/format.h>
#include <fmt/color.h>
#include <fmt/ranges.h>
#include <string>
#include <vector>

int main() {
    // Базове форматування
    std::string name = "Іван";
    int age = 25;
    fmt::print("Привіт, {}! Тобі {} років.\n", name, age);

    // Форматування з позиціями
    fmt::print("{1} має {0} років\n", age, name);

    // Форматування чисел
    double pi = 3.14159265359;
    fmt::print("π = {:.2f}\n", pi);
    fmt::print("π = {:.5f}\n", pi);

    // Вирівнювання
    fmt::print("{:>10} | {:^10} | {:<10}\n", "Right", "Center", "Left");

    // Кольоровий вивід
    fmt::print(fg(fmt::color::green), "Успіх!\n");
    fmt::print(fg(fmt::color::red) | fmt::emphasis::bold, "Помилка!\n");

    // Форматування контейнерів
    std::vector<int> numbers = {1, 2, 3, 4, 5};
    fmt::print("Числа: {}\n", numbers);

    // Створення рядка
    std::string message = fmt::format("Рахунок: {}/100", 85);
    fmt::print("{}\n", message);

    // Системи числення та заповнення
    fmt::print("{:#x} {:#b} {:08.3f} {:+d}\n", 255, 5, 3.14159, 7);
}

#include <fmt/format.h>
#include <string>

struct Point {
    int x, y;
};

// Додаємо підтримку власного типу: у {} можна виводити Point
template <>
struct fmt::formatter<Point> : fmt::formatter<std::string> {
    auto format(const Point& p, fmt::format_context& ctx) const {
        return fmt::formatter<std::string>::format(fmt::format("({}, {})", p.x, p.y), ctx);
    }
};

int main() {
    fmt::print("{}\n", Point{1, 2});
    fmt::print("[{:>10}]\n", Point{3, 4});
}

#include <spdlog/spdlog.h>
#include <spdlog/sinks/basic_file_sink.h>
#include <spdlog/sinks/rotating_file_sink.h>
#include <spdlog/sinks/stdout_color_sinks.h>

int main() {
    // Базове логування
    spdlog::info("Програма запущена");
    spdlog::warn("Це попередження");
    spdlog::error("Це помилка");
    spdlog::debug("Debug повідомлення");  // за замовчуванням не показується

    // Рівень логування
    spdlog::set_level(spdlog::level::debug);
    spdlog::debug("Тепер debug показується");

    // Форматування (fmt всередині)
    std::string user = "Іван";
    int attempts = 3;
    spdlog::info("Користувач {} зробив {} спроб", user, attempts);

    // Логування у файл
    auto file_logger = spdlog::basic_logger_mt("file_logger", "logs/app.log");
    file_logger->info("Записано у файл");

    // Ротація файлів
    auto rotating = spdlog::rotating_logger_mt("rotating", "logs/rotating.log", 1024 * 1024 * 5, 3);
    rotating->info("З ротацією файлів");

    // Консоль з кольорами
    auto console = spdlog::stdout_color_mt("console");
    console->info("Кольоровий вивід!");

    // Власний формат
    spdlog::set_pattern("[%Y-%m-%d %H:%M:%S.%e] [%^%l%$] %v");
    spdlog::info("З власним форматом");

    spdlog::flush_on(spdlog::level::info);
    file_logger->flush();
}

#include <spdlog/spdlog.h>
#include <spdlog/sinks/stdout_color_sinks.h>
#include <spdlog/sinks/basic_file_sink.h>

int main() {
    auto console = std::make_shared<spdlog::sinks::stdout_color_sink_mt>();
    console->set_level(spdlog::level::warn);   // у консолі лише попередження й вище

    auto file = std::make_shared<spdlog::sinks::basic_file_sink_mt>("logs/all.log", true);
    file->set_level(spdlog::level::trace);      // у файлі все

    spdlog::logger logger("app", {console, file});
    logger.set_level(spdlog::level::trace);

    logger.info("Це потрапить лише у файл");
    logger.error("Це побачимо і в консолі, і у файлі");
}

#include <nlohmann/json.hpp>
#include <fstream>
#include <iostream>

using json = nlohmann::json;

int main() {
    json person = {
        {"name", "Іван"},
        {"age", 25},
        {"city", "Київ"},
        {"skills", {"C++", "Python", "JavaScript"}},
        {"employed", true}
    };

    // Виведення з відступами
    std::cout << person.dump(2) << std::endl;

    // Читання значень
    std::string name = person["name"];
    int age = person["age"];
    std::cout << "Ім'я: " << name << ", вік: " << age << std::endl;

    // Перевірка існування поля
    if (person.contains("email")) {
        std::cout << "Email: " << person["email"] << std::endl;
    } else {
        std::cout << "Email не вказано" << std::endl;
    }

    // Додавання полів і елементів масиву
    person["email"] = "ivan@example.com";
    person["skills"].push_back("CMake");

    for (const auto& skill : person["skills"]) {
        std::cout << "Skill: " << skill << std::endl;
    }
    // ... продовження нижче
}

    // Запис у файл і читання назад
    {
        std::ofstream file("person.json");
        file << person.dump(4);
    }
    std::ifstream input("person.json");
    json loaded = json::parse(input);
    std::cout << "З файлу: " << loaded["email"] << std::endl;

    // Розбір рядка
    json point_json = json::parse(R"({"x": 10, "y": 20})");
    std::cout << "x: " << point_json["x"] << ", y: " << point_json["y"] << std::endl;

struct Point {
    int x, y;
};

void to_json(json& j, const Point& p) {
    j = json{{"x", p.x}, {"y", p.y}};
}

void from_json(const json& j, Point& p) {
    j.at("x").get_to(p.x);
    j.at("y").get_to(p.y);
}

// Використання
Point p = point_json.get<Point>();      // JSON -> Point
json back = Point{3, 4};                // Point -> JSON

    try {
        json bad = json::parse("{\"x\": ");
    } catch (const json::parse_error& e) {
        std::cout << "Помилка: " << e.what() << std::endl;
    }