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

#include "fmt/std.h"

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

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

// simple pipe for std::string by value
template <typename F>
auto operator|(std::string s, F&& f) -> decltype(auto) {
    return std::forward<F>(f)(std::move(s));
}

auto ltrim(std::string s) -> std::string {
    s.erase(
        std::begin(s),
        std::find_if(s.begin(), s.end(), [](char ch) {
            return !std::isspace(static_cast<char>(ch));
        }));
    return s;
}

auto rtrim(std::string s) -> std::string {
    s.erase(
        std::find_if(s.rbegin(), s.rend(), [](char ch) {
            return !std::isspace(static_cast<char>(ch));
        }).base(),
        s.end());
    return s;
}

auto trim(std::string s) -> std::string {
    return ltrim(rtrim(std::move(s)));
}

// starts at 50
[[maybe_unused]]constexpr auto raw_str = R"(
L68
L30
R48
L5
R60
L55
L1
L99
R14
L82
)";

enum class rotdir {
    none,
    L,
    R
};

struct rot {
    rotdir dir;
    u32 turns;
};

auto map_char_to_rotdir(char c) -> rotdir {
    switch (c) {
        using enum rotdir;
        case 'L': return L;
        case 'R': return R;
        default: return none;
    }
}

auto map_dir_to_i32(i32 value, rotdir dir) -> i32 {
    switch (dir) {
        using enum rotdir;
        case L:  return -value;
        case R:
        default: return value;
    } 
}

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

    auto rot_vec = str | std::views::split("\n"sv) | std::views::transform([](auto const& str) {
            return rot{
                .dir = map_char_to_rotdir(*std::begin(str)),
                .turns = u32(std::stoul(std::string{++std::begin(str), std::end(str)}))
            };
        }) | std::ranges::to<std::vector>();

    i32 start = 50;
    auto sum = std::ranges::fold_left(rot_vec, 0, [&start](auto a, auto b) {
            auto c = map_dir_to_i32(b.turns % 100, b.dir);

            start = (100 + start + c) % 100;

            if (start == 0) ++a;

            return a;
        });

    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;
}