module Pure_map = struct
  module Ordered = struct
    type t = int

    let compare left right = if left < right then -1 else if left > right then 1 else 0
  end

  module Map = Map.Make (Ordered)

  type 'a t = 'a Map.t

  let empty = Map.empty

  let add key value map = Map.add key value map

  let remove key map = Map.remove key map

  let find key map = Map.find key map

  let find_opt key map = try Some (Map.find key map) with Not_found -> None

  let mem key map = Map.mem key map

  let cardinal map = Map.cardinal map

  let is_empty map = Map.is_empty map

  let bindings map = Map.bindings map

  let fold f map init = Map.fold f map init

  let iter f map = Map.iter f map

  let map f map = Map.map f map

  let keys map = Map.fold (fun key _ acc -> key :: acc) map [] |> List.rev

  let equal equal_value left right = Map.equal equal_value left right
end

type counters = {
  mutable predicate_evaluations : int;
  mutable mapping_evaluations : int;
  mutable changed_key_visits : int;
  mutable full_traversals : int;
  mutable scalar_deltas : int;
}

let new_counters () =
  {
    predicate_evaluations = 0;
    mapping_evaluations = 0;
    changed_key_visits = 0;
    full_traversals = 0;
    scalar_deltas = 0;
  }

let copy_counters counters =
  {
    predicate_evaluations = counters.predicate_evaluations;
    mapping_evaluations = counters.mapping_evaluations;
    changed_key_visits = counters.changed_key_visits;
    full_traversals = counters.full_traversals;
    scalar_deltas = counters.scalar_deltas;
  }

let reset_counters counters =
  counters.predicate_evaluations <- 0;
  counters.mapping_evaluations <- 0;
  counters.changed_key_visits <- 0;
  counters.full_traversals <- 0;
  counters.scalar_deltas <- 0

let count_predicate counters = counters.predicate_evaluations <- counters.predicate_evaluations + 1

let count_mapping counters = counters.mapping_evaluations <- counters.mapping_evaluations + 1

let count_changed_key counters = counters.changed_key_visits <- counters.changed_key_visits + 1

let count_full_traversal counters = counters.full_traversals <- counters.full_traversals + 1

let count_scalar_delta counters = counters.scalar_deltas <- counters.scalar_deltas + 1

let counters_to_string counters =
  Printf.sprintf
    "predicate_evaluations=%d mapping_evaluations=%d changed_key_visits=%d full_traversals=%d scalar_deltas=%d"
    counters.predicate_evaluations counters.mapping_evaluations counters.changed_key_visits
    counters.full_traversals counters.scalar_deltas

type 'a outcome = Success of 'a | Failure of string