#include <numeric>
#include <algorithm>

#include "aoc.hpp"
#include "aoc/utils.hpp"
#include "fmt/format.h"

auto aoc24::day01([[maybe_unused]]std::span<char const*> const& args) -> std::expected<void, aoc::error> {
    constexpr auto filename = "./dat/24/re/01.txt";
    std::ifstream strm{filename, std::ios::in};
    if (!strm.is_open()) {
        return aoc::make_error(
                fmt::format("Error opening file: {}\n", filename),
                std::errc::file_exists
            );
    }

    std::vector<std::uint32_t> a{};
    std::vector<std::uint32_t> b{};

    std::string str{};
    while (strm) {
        auto const c = char(strm.peek());
        if (std::isdigit(c)) {
            str += char(strm.get());
            continue;
        }
        if (c == ' ') {
            if (!str.empty()) {
                a.emplace_back(std::stoi(str));
                str.clear();
            }
        }
        if (c == '\n') {
            if (!str.empty()) {
                b.emplace_back(std::stoi(str));
                str.clear();
            }
        }
        [[discard]]strm.get();
    }

    fmt::print("a: {}, b: {}\n", a.size(), b.size());

    std::sort(std::begin(a), std::end(a));
    std::sort(std::begin(b), std::end(b));

    auto diff_view = std::views::zip(a, b) | std::views::transform([](auto const& p) {
        auto const [x, y] = p;
        return x > y ? x - y : y - x;
    });
    auto const sum = std::accumulate(std::begin(diff_view), std::end(diff_view), 0);

    fmt::print("Part A: {}\n", std::abs(sum));

    auto values = a | std::views::transform([&b](auto v) {
        return std::pair{v, b | std::views::filter([v](auto c) {
            return v == c; // Filter elements in `b` equal to `v`
        }) | std::ranges::to<std::vector>()};
    }) | std::ranges::to<std::vector>();

    auto const meow = std::accumulate(std::begin(values), std::end(values), 0, [](auto const acc, auto const& pair) {
        return acc + std::int32_t(pair.first * pair.second.size());
    });

    fmt::print("Part B: {}\n", meow);
    return {};
}