#include <networkit/distance/BFS.hpp>
#include <networkit/distance/DynBFS.hpp>
#include <networkit/dynamics/GraphEvent.hpp>
#include <networkit/graph/Graph.hpp>

#include <algorithm>
#include <chrono>
#include <cstdint>
#include <fstream>
#include <iostream>
#include <limits>
#include <sstream>
#include <stdexcept>
#include <string>
#include <utility>
#include <vector>

namespace {
using Edge = std::pair<NetworKit::node, NetworKit::node>;

std::vector<Edge> read_edges(const std::string& path, std::size_t& vertices) {
  std::ifstream in(path);
  if (!in) throw std::runtime_error("cannot open edge list: " + path);
  std::vector<Edge> edges;
  std::string line;
  std::uint64_t max_vertex = 0;
  bool saw = false;
  while (std::getline(in, line)) {
    if (line.empty() || line[0] == '#') continue;
    std::istringstream row(line);
    std::uint64_t u = 0, v = 0;
    if (!(row >> u >> v)) continue;
    edges.emplace_back(static_cast<NetworKit::node>(u), static_cast<NetworKit::node>(v));
    max_vertex = std::max(max_vertex, std::max(u, v));
    saw = true;
  }
  vertices = saw ? static_cast<std::size_t>(max_vertex + 1) : 0;
  return edges;
}

std::vector<std::int64_t> distances(const NetworKit::SSSP& bfs, std::size_t n) {
  std::vector<std::int64_t> out(n, -1);
  for (std::size_t u = 0; u < n; ++u) {
    const auto d = bfs.distance(static_cast<NetworKit::node>(u));
    if (d < std::numeric_limits<NetworKit::edgeweight>::max()) out[u] = static_cast<std::int64_t>(d);
  }
  return out;
}

std::vector<std::uint64_t> layer_counts(const std::vector<std::int64_t>& dist) {
  std::int64_t max_depth = 0;
  for (auto d : dist) if (d >= 0) max_depth = std::max(max_depth, d);
  std::vector<std::uint64_t> counts(static_cast<std::size_t>(max_depth) + 1, 0);
  for (auto d : dist) if (d >= 0) ++counts[static_cast<std::size_t>(d)];
  return counts;
}

void print_u64_array(const std::vector<std::uint64_t>& values) {
  std::cout << '[';
  for (std::size_t i = 0; i < values.size(); ++i) {
    if (i) std::cout << ',';
    std::cout << values[i];
  }
  std::cout << ']';
}
}

int main(int argc, char** argv) {
  if (argc != 5) {
    std::cerr << "usage: " << argv[0] << " edge_list root imported_rate batch_size\n";
    return 2;
  }
  const std::string path = argv[1];
  const auto root = static_cast<NetworKit::node>(std::stoull(argv[2]));
  const double imported_rate = std::stod(argv[3]);
  const std::size_t batch_size = std::stoull(argv[4]);
  if (!(imported_rate > 0.0 && imported_rate < 1.0) || batch_size == 0) return 2;

  std::size_t n = 0;
  const auto edges = read_edges(path, n);
  const auto imported = static_cast<std::size_t>(edges.size() * imported_rate);
  if (n == 0 || imported == 0 || imported >= edges.size() || root >= n) return 2;

  NetworKit::Graph graph(static_cast<NetworKit::count>(n), false, true);
  for (std::size_t i = 0; i < imported; ++i) graph.addEdge(edges[i].first, edges[i].second, 1.0, true);
  if (graph.numberOfEdges() != imported) {
    throw std::runtime_error("initial edge count mismatch; duplicate edge violates simple-graph contract");
  }

  NetworKit::DynBFS dyn(graph, root, false);
  dyn.run();

  std::size_t batches = 0;
  std::size_t operations = 0;
  double total_us = 0.0;
  double mutation_us = 0.0;
  double maintenance_us = 0.0;

  for (std::size_t begin = imported; begin < edges.size(); begin += batch_size) {
    const auto end = std::min(begin + batch_size, edges.size());
    std::vector<NetworKit::GraphEvent> events;
    events.reserve((end - begin) * 2);

    const auto t0 = std::chrono::steady_clock::now();
    for (std::size_t i = begin; i < end; ++i) {
      graph.addEdge(edges[i].first, edges[i].second, 1.0, true);
      events.emplace_back(NetworKit::GraphEvent::EDGE_ADDITION, edges[i].first, edges[i].second, 1.0);
    }
    for (std::size_t i = begin; i < end; ++i) {
      const auto j = i - imported;
      graph.removeEdge(edges[j].first, edges[j].second);
      events.emplace_back(NetworKit::GraphEvent::EDGE_REMOVAL, edges[j].first, edges[j].second, 1.0);
    }
    const auto t1 = std::chrono::steady_clock::now();
    dyn.updateBatch(events);
    const auto t2 = std::chrono::steady_clock::now();

    mutation_us += std::chrono::duration<double, std::micro>(t1 - t0).count();
    maintenance_us += std::chrono::duration<double, std::micro>(t2 - t1).count();
    total_us += std::chrono::duration<double, std::micro>(t2 - t0).count();
    operations += events.size();
    ++batches;

    NetworKit::BFS full(graph, root, false, false);
    full.run();
    if (distances(dyn, n) != distances(full, n)) {
      throw std::runtime_error("NetworKit DynBFS mismatch against fresh full BFS after batch " + std::to_string(batches));
    }
  }

  if (graph.numberOfEdges() != imported) throw std::runtime_error("final edge-count mismatch");
  const auto final_dist = distances(dyn, n);
  const auto layers = layer_counts(final_dist);
  std::uint64_t visited = 0;
  for (auto x : layers) visited += x;

  std::cout << "{\"schema_version\":1,"
            << "\"artifact_type\":\"velographx-external-networkit-native-dynbfs\","
            << "\"native_cpp\":true,\"directed\":true,\"weighted\":false,"
            << "\"vertices\":" << n << ",\"source_edges\":" << edges.size() << ','
            << "\"initial_edges\":" << imported << ",\"final_edges\":" << graph.numberOfEdges() << ','
            << "\"root\":" << root << ",\"imported_rate\":" << imported_rate << ','
            << "\"batch_size\":" << batch_size << ",\"batches\":" << batches << ','
            << "\"update_operations\":" << operations << ','
            << "\"wall_total_us\":" << total_us << ','
            << "\"wall_mean_us\":" << (batches ? total_us / batches : 0.0) << ','
            << "\"mutation_total_us\":" << mutation_us << ','
            << "\"maintenance_total_us\":" << maintenance_us << ','
            << "\"all_batches_correct_against_fresh_full_bfs\":true,"
            << "\"correctness_batches\":" << batches << ','
            << "\"visited_vertices\":" << visited << ",\"layer_counts\":";
  print_u64_array(layers);
  std::cout << ",\"research_claim\":false}\n";
  return 0;
}