#include <span>
#include <algorithm>
#include <ranges>
#include <string>
#include <string_view>
#include <utility>
#include <vector>
#include <set>

#include "fmt/std.h"

#include "aoc/types.hpp"
#include "aoc/utils.hpp"

using namespace std::string_view_literals;
using namespace aoc::types;

// starts at 50
[[maybe_unused]]constexpr auto raw_str = R"(
3-5
10-14
16-20
12-18

1
5
8
11
17
32
)";

static auto entry([[maybe_unused]]std::span<char const*> const& args) -> void {
    // std::string str{raw_str};
    auto str = aoc::read_text("./input.txt").value_or("");
    str = aoc::trim(str);

    auto id_spec = str | std::views::split("\r\n\r\n"sv) | std::views::transform([](auto const& str) {
        return aoc::trim({std::begin(str), std::end(str)});
    }) | std::ranges::to<std::vector>();

    if (id_spec.size() < 2) throw std::runtime_error("ID specification is not valid");

    auto id_range = id_spec[0] | std::views::split("\n"sv) | std::views::transform([](auto const& str) {
        return std::ranges::fold_left(str | std::views::split("-"sv), std::vector<f64>{}, [](auto a, auto const& v) {
                a.push_back(std::stod(std::string({std::begin(v), std::end(v)})));
                return a;
            });
    }) | std::ranges::to<std::vector>();

    auto ids = id_spec[1] | std::views::split("\n"sv) | std::views::transform([](auto const& str) {
        return std::stod(std::string{std::begin(str), std::end(str)});
    }) | std::ranges::to<std::vector>();

    struct range {
        f64 start;
        f64 end;
    };

    // f64 sum = 0;

    // for (usize i = 0; i < ids.size(); ++i) {
    //     auto const id = ids[i];
    //     bool is_valid = false;
    //     for (usize j = 0; j < id_range.size(); ++j) {
    //         auto const a = id_range[j][0];
    //         auto const b = id_range[j][1];
    //
    //         if (id >= a && id <= b) {
    //             is_valid = true;
    //             break;
    //         }
    //     }
    //
    //     fmt::print("id: {} is {}\n", id, is_valid ? "valid" : "not valid");
    //
    //     if (is_valid) ++sum;
    // }

    std::vector<range> range_vec{};
    for (usize i = 0; i < id_range.size(); ++i) {
        auto const a = id_range[i][0];
        auto const b = id_range[i][1];
        range_vec.push_back({a, b});
    }

    std::ranges::sort(range_vec, [](auto a, auto b) {
        return a.start < b.start;
    });
    fmt::print("----------\n");

    // for (auto const& r : range_vec) {
    //     fmt::print("{}-{}\n", r.start, r.end);
    // }
    //
    // fmt::print("----------\n");

    std::vector<range> ranges{};
    for (usize i = 0; i < range_vec.size(); i += 1) {
        auto const& r = range_vec[i];
        if (ranges.empty()) {
            ranges.push_back(r);
            continue;
        }

        if (ranges.back().start <= r.start && ranges.back().end >= r.end) {
            continue;
        }

        if (ranges.back().end >= r.start) {
            ranges.back().end = r.end;
            continue;
        }

        ranges.push_back(r);
    }

    fmt::print("\n");

    f64 sum = 0.0;
    for (auto const& r : ranges) {
        // fmt::print("{}-{}  ", r.start, r.end);
        auto const d = (r.end - r.start) + 1;
        fmt::print("{}\n", d);
        sum += d;
    }

    fmt::print("res: {}\n", sum);

    //
    // std::vector<f64> ranges{};
    // for (auto const& value : set) ranges.push_back(value);
    // set = {};
    // std::ranges::sort(ranges);
    //
    //
    // // for (auto const& id : valid_ids) {
    // //     fmt::print("{} ", id);
    // // }
    // fmt::print("\n");
    //
    // fmt::print("res: {}\n", sum);
}

auto main([[maybe_unused]]int argc, [[maybe_unused]]char const* argv[]) -> int {
    try {
        entry({argv, std::next(argv, argc)});
    } catch (std::exception const& e) {
        fmt::print(stderr, "{}\n", e.what());
        return 1;
    }
    return 0;
}