type domain_item =
 | Id of string               (* literal *)
 | Symbol of string * int     (* literal, instance num *)
 | Num of int                 (* instance num *)

module OrderedDomain =
  struct
    type t = domain_item
    let compare = Pervasives.compare
  end

module Domain = Set.Make (OrderedDomain)
module Environment = Map.Make (OrderedDomain)

type codomain_item =
  string *  (* description *)
  (environment -> string -> Cic.term list -> Cic.term)
    (* environment, literal number, arguments as needed *)

and environment = codomain_item Environment.t

module type Callbacks =
  sig
    val output_html : ?append_NL:bool -> Ui_logger.html_msg -> unit
    val interactive_user_uri_choice :
      selection_mode:[`SINGLE | `MULTIPLE] ->
      ?ok:string ->
      ?enable_button_for_non_vars:bool ->
      title:string -> msg:string -> id:string -> string list -> string list
    val interactive_interpretation_choice :
      (string * string) list list -> int
    val input_or_locate_uri : title:string -> UriManager.uri
  end

let string_of_domain_item = function
  | Id s -> Printf.sprintf "ID(%s)" s
  | Symbol (s, i) -> Printf.sprintf "SYMBOL(%s,%d)" s i
  | Num i -> Printf.sprintf "NUM(instance %d)" i

let string_of_domain dom =
  let buf = Buffer.create 1024 in
  Domain.iter
    (fun item -> Buffer.add_string buf (string_of_domain_item item ^ "; "))
    dom;
  Buffer.contents buf

module EnvironmentP3 =
  struct
    type t = environment
    let empty = ""

    let to_string env =
     Environment.fold
      (fun i v s ->
        match i with
        | Id id ->s ^ Printf.sprintf "alias %s %s\n" id (fst v)
        | _ -> "")
      env ""

    let of_string inputtext =
     let regexpr =
      let alfa = "[a-zA-Z_-]" in
      let digit = "[0-9]" in
      let ident = alfa ^ "\(" ^ alfa ^ "\|" ^ digit ^ "\)*" in
      let blanks = "\( \|\t\|\n\)+" in
      let nonblanks = "[^ \t\n]+" in
      let uri = "/\(" ^ ident ^ "/\)*" ^ nonblanks in (* not very strict check *)
       Str.regexp
        ("alias" ^ blanks ^ "\(" ^ ident ^ "\)" ^ blanks ^ "\(" ^ uri ^ "\)")
     in
      let rec aux n =
       try
        let n' = Str.search_forward regexpr inputtext n in
         let id = Id (Str.matched_group 2 inputtext) in
         let uri = "cic:" ^ (Str.matched_group 5 inputtext) in
          let resolve_id = aux (n' + 1) in
           if Environment.mem id resolve_id then
            resolve_id
           else
             let term =
               HelmLibraryObjects.term_of_uri (UriManager.uri_of_string uri)
             in
             (Environment.add id (uri, (fun _ _ _ -> term))
               resolve_id)
       with
        Not_found -> Environment.empty
      in
       aux 0
  end