#include <cstddef>
#include <deque>
#include <iostream>
#include <stdexcept>
#include <tuple>
#include <utility>
#include <variant>
#include <vector>
#include <fstream>

#include <intcode/intcode.hpp>
using namespace intcode;

namespace {

using Packet = std::pair<ValueType, ValueType>;
using Ethernet = std::deque<std::pair<std::size_t, Packet>>;

auto BuildNetwork(Machine m) -> std::vector<Machine> {
  std::vector<Machine> machines;
  for (int i = 0; i < 50; i++) {
    machines.push_back(m);
    std::get<Input>(Step(machines.back())).pos = i;
  }
  return machines;
}

auto Interact(Ethernet & ethernet, Machine & m, std::optional<Packet> p) -> void {
  for(;;) {
    auto effect = Step(m);
    switch (effect.index()) {

    default:
      throw std::runtime_error{"unexpected halt"};

    case 0: // Input
      if (p) {
        std::get<Input>(effect).pos = p->first;
        std::get<Input>(Step(m)).pos = p->second;
        p = {};
        break;
      }
      std::get<Input>(effect).pos = -1; // no packet
      return;

    case 1: // Output
      auto d = std::get<Output>(effect).val;
      auto x = std::get<Output>(Step(m)).val;
      auto y = std::get<Output>(Step(m)).val;
      ethernet.push_back({d, {x,y}});
      break;
    }
  }
}

} // namespace

auto main(int argc, char ** argv) -> int {
  if (2 != argc) { return 1; }
  std::ifstream fin {argv[1]};

  auto machines = BuildNetwork(Machine{ParseStream(fin)});
  auto ethernet = Ethernet{};

  std::optional<ValueType> part1;
  std::optional<ValueType> part2;
  std::optional<Packet> nat;

  for(;;) {
    if (ethernet.empty()) {
      if (nat) {
        if (nat->second == part2) { break; }
        part2 = nat->second;
        Interact(ethernet, machines[0], nat);
      } else {
        for (auto && m : machines) {
          Interact(ethernet, m, {});
        }
      }
    } else {
      auto [dest, p] = ethernet.front();
      ethernet.pop_front();
      if (dest == 255) {
        nat = p;
        if (!part1) { part1 = p.second; }
      } else if (dest < 50) {
        Interact(ethernet, machines[dest], p);
      } else {
        throw std::runtime_error{"bad destination"};
      }
    }
  }

  std::cout << "Part 1: " << *part1 << std::endl;
  std::cout << "Part 2: " << *part2 << std::endl;
}