open StdLabels
module Syntax = Syntax
module Table = ImportDataTypes.Table
module Path = ImportDataTypes.Path
module T = Read_conf
module Expression = ImportExpression.T

external set_locale : string -> unit = "set_locale"

let latest_version = 1

module TomlReader = Read_conf.Make (Helpers.Toml.Decode)

let t_of_toml : Otoml.t -> (Syntax.t, string) result =
 fun toml ->
  let version =
    Otoml.find_or ~default:latest_version toml
      (Otoml.get_integer ~strict:false)
      [ "version" ]
  in
  match version with
  | n when n = latest_version ->
      let conf = TomlReader.read toml in
      let () =
        Result.iter
          (fun conf -> set_locale (Option.value ~default:"" conf.Syntax.locale))
          conf
      in
      conf
  | _ ->
      Printf.eprintf "Unsuported version : %d\n" version;
      exit 1

let dummy_conf =
  Syntax.
    {
      source = { file = ""; tab = 0; name = "" };
      version = latest_version;
      locale = Some "C";
      externals = [];
      columns = [];
      filters = [];
      sort = [];
      uniq = [];
    }

let get_table_for_name : Syntax.t -> string option -> Table.t =
 fun conf name ->
  match name with
  | None -> conf.source
  | Some name ->
      if String.equal name conf.source.name then conf.source
      else
        let ext =
          List.find conf.externals ~f:(fun (ext : Syntax.Extern.t) ->
              String.equal name ext.target.name)
        in
        ext.target

let root_table : Syntax.t -> Table.t = fun conf -> conf.source

let get_dependancies_for_table : Syntax.t -> Table.t -> Syntax.Extern.t list =
 fun conf source ->
  let is_root = source = conf.source in

  List.filter conf.externals ~f:(fun (ext : Syntax.Extern.t) ->
      (* Enumerate the intern_key and check the source pointed by each column *)
      Expression.fold_values ext.intern_key ~init:false ~f:(fun acc expr ->
          if acc then acc
          else
            match expr.Syntax.Path.alias with
            | Some v -> String.equal v source.name
            | None -> is_root))

let expression_from_string s =
  Read_conf.ExpressionParser.of_string Read_conf.ExpressionParser.path s