(** System catalog helpers. Pure definitions — no storage access, no
    manipulation dependency. Consumed by {!Manipulation.Make} and
    {!Catalog.Make} to bootstrap the catalog relations that make each multigroup
    self-describing. *)

(* TODO: on_rel_name and timing_rel_name are defined and seeded but never
   written to by any executor. They appear to be stubs for trigger/timing
   metadata that was never implemented. *)

(** Dedicated multigroup hosting the system catalog.  The catalog's relation
    names keep the [public:] prefix — that prefix is part of the relation name
    inside this mg, not a separate namespace. *)
let prelude_mg = "sakura"

let catalog_prefix = "public:"
let relation_rel_name = catalog_prefix ^ "relation"
let domain_rel_name = catalog_prefix ^ "domain"
let attribute_rel_name = catalog_prefix ^ "attribute"
let constraint_rel_name = catalog_prefix ^ "constraint"
let on_rel_name = catalog_prefix ^ "on"
let timing_rel_name = catalog_prefix ^ "timing"
let branch_rel_name = catalog_prefix ^ "branch"
let head_rel_name = catalog_prefix ^ "head"
let multigroup_rel_name = catalog_prefix ^ "multigroup"
let schema_rel_name = catalog_prefix ^ "schema"
let function_predicate_rel_name = catalog_prefix ^ "function_predicate"
let loaded_library_rel_name = catalog_prefix ^ "loaded_library"

(** Relations present in every multigroup's catalog. *)
let catalog_relation_names =
  [
    relation_rel_name;
    domain_rel_name;
    attribute_rel_name;
    constraint_rel_name;
    on_rel_name;
    timing_rel_name;
    schema_rel_name;
    function_predicate_rel_name;
    loaded_library_rel_name;
  ]

(** Relations exclusive to the sakura meta-multigroup. *)
let sakura_only_relation_names = [ multigroup_rel_name ]

let all_catalog_relation_names =
  catalog_relation_names @ sakura_only_relation_names

let is_catalog_relation name = List.mem name all_catalog_relation_names
let relation_schema : Schema.t = Schema.empty |> Schema.add "name" "string"
let domain_schema : Schema.t = Schema.empty |> Schema.add "name" "string"

let attribute_schema : Schema.t =
  Schema.empty
  |> Schema.add "relation_name" "string"
  |> Schema.add "attr_name" "string"
  |> Schema.add "domain_name" "string"

let constraint_schema : Schema.t =
  Schema.empty |> Schema.add "name" "string"
  |> Schema.add "relation_name" "string"

let on_schema : Schema.t = Schema.empty |> Schema.add "event" "string"
let timing_schema : Schema.t = Schema.empty |> Schema.add "timing" "string"
let multigroup_schema : Schema.t = Schema.empty |> Schema.add "name" "string"
let schema_schema : Schema.t = Schema.empty |> Schema.add "name" "string"

let function_predicate_schema : Schema.t =
  Schema.empty |> Schema.add "name" "string"
  |> Schema.add "symbol" "string"
  |> Schema.add "cardinality" "string"
  |> Schema.add "purity" "string"

let loaded_library_schema : Schema.t =
  Schema.empty |> Schema.add "path" "string"

(** Definitions seeded into every multigroup. *)
let catalog_definitions =
  [
    (relation_rel_name, relation_schema);
    (domain_rel_name, domain_schema);
    (attribute_rel_name, attribute_schema);
    (constraint_rel_name, constraint_schema);
    (on_rel_name, on_schema);
    (timing_rel_name, timing_schema);
    (schema_rel_name, schema_schema);
    (function_predicate_rel_name, function_predicate_schema);
    (loaded_library_rel_name, loaded_library_schema);
  ]

(** Extra definitions seeded only into the sakura meta-multigroup. *)
let sakura_only_definitions = [ (multigroup_rel_name, multigroup_schema) ]

(* TODO: all tuple builders use Obj.magic to coerce string values into
   Attribute.value (Obj.t). This is the same UB pattern fixed in standard.ml;
   should use Obj.repr instead. *)

let build_relation_tuple rel_name : Tuple.materialized =
  {
    Tuple.relation = relation_rel_name;
    attributes =
      Tuple.AttributeMap.singleton "name"
        { Attribute.value = Obj.magic rel_name };
  }

let build_domain_tuple dom_name : Tuple.materialized =
  {
    Tuple.relation = domain_rel_name;
    attributes =
      Tuple.AttributeMap.singleton "name"
        { Attribute.value = Obj.magic dom_name };
  }

let build_attribute_tuples ~relation_name (schema : Schema.t) :
    Tuple.materialized list =
  List.map
    (fun (attr_n, dom_n) ->
      {
        Tuple.relation = attribute_rel_name;
        attributes =
          Tuple.AttributeMap.of_list
            [
              ("relation_name", { Attribute.value = Obj.magic relation_name });
              ("attr_name", { Attribute.value = Obj.magic attr_n });
              ("domain_name", { Attribute.value = Obj.magic dom_n });
            ];
      })
    schema

let build_constraint_tuple cname rel_name : Tuple.materialized =
  {
    Tuple.relation = constraint_rel_name;
    attributes =
      Tuple.AttributeMap.of_list
        [
          ("name", { Attribute.value = Obj.magic cname });
          ("relation_name", { Attribute.value = Obj.magic rel_name });
        ];
  }

let build_on_tuple event : Tuple.materialized =
  {
    Tuple.relation = on_rel_name;
    attributes =
      Tuple.AttributeMap.singleton "event" { Attribute.value = Obj.magic event };
  }

let build_timing_tuple timing : Tuple.materialized =
  {
    Tuple.relation = timing_rel_name;
    attributes =
      Tuple.AttributeMap.singleton "timing"
        { Attribute.value = Obj.magic timing };
  }

let build_multigroup_tuple mg_name : Tuple.materialized =
  {
    Tuple.relation = multigroup_rel_name;
    attributes =
      Tuple.AttributeMap.singleton "name"
        { Attribute.value = Obj.magic mg_name };
  }

let build_schema_tuple schema_name : Tuple.materialized =
  {
    Tuple.relation = schema_rel_name;
    attributes =
      Tuple.AttributeMap.singleton "name"
        { Attribute.value = Obj.magic schema_name };
  }

let purity_to_string p = Sexplib.Sexp.to_string (Conventions.Purity.sexp_of_t p)

let purity_of_string s =
  match Conventions.Purity.t_of_sexp (Sexplib.Sexp.of_string s) with
  | p -> Some p
  | exception _ -> None

let cardinality_to_string c =
  Sexplib.Sexp.to_string (Conventions.Cardinality.sexp_of_t c)

let cardinality_of_string s =
  match Conventions.Cardinality.t_of_sexp (Sexplib.Sexp.of_string s) with
  | c -> Some c
  | exception _ -> None

let build_function_predicate_tuple ~name ~symbol ~cardinality ~purity :
    Tuple.materialized =
  {
    Tuple.relation = function_predicate_rel_name;
    attributes =
      Tuple.AttributeMap.of_list
        [
          ("name", { Attribute.value = Obj.magic name });
          ("symbol", { Attribute.value = Obj.magic symbol });
          ( "cardinality",
            { Attribute.value = Obj.magic (cardinality_to_string cardinality) }
          );
          ("purity", { Attribute.value = Obj.magic (purity_to_string purity) });
        ];
  }

let build_loaded_library_tuple path : Tuple.materialized =
  {
    Tuple.relation = loaded_library_rel_name;
    attributes =
      Tuple.AttributeMap.singleton "path" { Attribute.value = Obj.magic path };
  }