open StdLabels
module E = ImportExpression.T
module Table = ImportDataTypes.Table
module Path = ImportDataTypes.Path
module CTE = Cte

let toml_of_table Table.{ file; tab; name } =
  let values = [ ("file", Otoml.string file); ("name", Otoml.string name) ] in
  let values =
    match tab with
    | 1 -> values
    | tab -> ("tab", Otoml.integer tab) :: values
  in

  Otoml.table values

module Extern = struct
  type t = {
    intern_key : Path.t E.t;
    target : Table.t;
    extern_key : Path.column E.t;
    allow_missing : bool;
    match_rule : string option;
  }
  [@@deriving show, eq]
  (** Describe a relation beteween two tables *)

  let toml_of_extern extern =
    let values =
      [
        ( "intern_key",
          Otoml.string
          @@ ImportExpression.Repr.repr ~top:true Path.show extern.intern_key );
        ( "extern_key",
          Otoml.string
          @@ ImportExpression.Repr.repr ~top:true
               (fun v -> ":" ^ ImportDataTypes.Path.column_to_string v)
               extern.extern_key );
        ("file", Otoml.string extern.target.file);
        ("allow_missing", Otoml.boolean extern.allow_missing);
      ]
    in

    let values =
      match extern.target.tab with
      | 1 -> values
      | tab -> ("tab", Otoml.integer tab) :: values
    in

    Otoml.table values

  let toml externs =
    List.map externs ~f:(fun e -> (e.target.name, toml_of_extern e))
    |> Otoml.table
end

type t = {
  version : int;
  locale : string option;
  source : Table.t;
  externals : Extern.t list;
  columns : Path.t E.t list;
  filters : Path.t E.t list;
  sort : Path.t E.t list;
  uniq : Path.t E.t list;
}

let repr t =
  let repr_expression_list l =
    Otoml.array
      (List.map l ~f:(fun v ->
           Otoml.string (ImportExpression.Repr.repr ~top:true Path.show v)))
  in

  let sheet =
    Otoml.table
      [
        ("columns", repr_expression_list t.columns);
        ("filters", repr_expression_list t.filters);
        ("sort", repr_expression_list t.sort);
        ("uniq", repr_expression_list t.uniq);
      ]
  in

  let values =
    [
      ("version", Otoml.integer t.version);
      ("source", toml_of_table t.source);
      ("externals", Extern.toml t.externals);
      ("sheet", sheet);
    ]
  in

  Otoml.table values

let get_table_for_name : 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 : Extern.t) ->
              String.equal name ext.target.name)
        in
        ext.target

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

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

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

let latest_version = 1

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