arke

defmodule Arke do
  alias Arke.Validator
  alias Arke.Core.Unit
  alias Arke.Boundary.{ArkeManager, GroupManager, ParameterManager}
  alias Arke.Core.Parameter


  def init() do
    base_parameters()
    GroupManager.create(Unit.new(:parameter, %{label: "Parameter", description: "Parameter Group", arke_list: []},
      :group, nil, %{}, nil, nil, nil), :arke_system)
    arke_modules = get_arke_modules()
  end

  defp get_arke_modules() do
    Enum.reduce(:application.loaded_applications(), [], fn {app, _, _}, arke_list ->
      {:ok, modules} = :application.get_key(app, :modules)
      module_arke_list = Enum.reduce(modules, [], fn mod, mod_arke_list ->
        is_arke = Code.ensure_loaded?(mod) and :erlang.function_exported(mod, :arke_from_attr, 0) and mod.arke_from_attr != nil
        mod_arke_list = check_arke_module(mod, mod_arke_list, is_arke)
      end)
      arke_list ++ module_arke_list
    end)
  end
  defp check_arke_module(mod, arke_list, true) do
    %{id: id, data: data, metadata: metadata} = mod.arke_from_attr
    unit = Unit.new(id, data, :arke, nil, metadata, nil, nil, mod)

    ArkeManager.create(unit, :arke_system)

    Enum.map(mod.groups_from_attr, fn %{id: parent_id, metadata: link_metadata} ->
      GroupManager.add_link(parent_id, :arke_system, :arke_list, id, link_metadata)
    end)

    [mod | arke_list]
  end
  defp check_arke_module(_, arke_list, false), do: arke_list

  defp base_parameter(opts \\ []) do
    %{
      label: Keyword.get(opts, :label),
#      type: Keyword.get!(opts, :type),
      format: Keyword.get(opts, :format, :attribute),
      is_primary: Keyword.get(opts, :is_primary, false),
      nullable: Keyword.get(opts, :nullable, true),
      required: Keyword.get(opts, :required, false),
      persistence: Keyword.get(opts, :persistence, "arke_parameter"),
      helper_text: Keyword.get(opts, :label, nil),
    }
  end

  defp base_parameters() do
    id = Unit.new(:id,
      Map.merge(
        base_parameter(label: "Id", is_primary: true, nullable: false, required: true, persistence: "table_column"),
        %{min_length: 2, max_length: nil, values: nil, multiple: false, unique: true, default_string: nil}),
      :string, nil, %{}, nil, nil, nil)

    arke_id = Unit.new(:arke_id,
      Map.merge(
        base_parameter(label: "Arke id", nullable: false, required: true, persistence: "table_column"),
        %{min_length: 2, max_length: nil, values: nil, multiple: false, unique: false, default_string: nil}),
      :string, nil, %{}, nil, nil, nil)

    metadata = Unit.new(:metadata,
      Map.merge(
        base_parameter(label: "Metadata", persistence: "table_column"),
        %{default_dict: %{}}),
      :dict, nil, %{}, nil, nil, nil)

    configuration = Unit.new(:configuration,
      Map.merge(
        base_parameter(label: "Configuration", persistence: "table_column"),
        %{default_dict: %{}}),
      :dict, nil, %{}, nil, nil, nil)

    inserted_at = Unit.new(:inserted_at,
      Map.merge(
        base_parameter(label: "Inserted at", persistence: "table_column"),
        %{default_datetime: nil}),
      :datetime, nil, %{}, nil, nil, nil)

    updated_at = Unit.new(:updated_at,
      Map.merge(
        base_parameter(label: "Updated at", persistence: "table_column"),
        %{default_datetime: nil}),
      :datetime, nil, %{}, nil, nil, nil)

    active = Unit.new(:active,
      Map.merge(
        base_parameter(label: "Active", nullable: false),
        %{default_boolean: true}),
      :boolean, nil, %{}, nil, nil, nil)

    label = Unit.new(:label,
      Map.merge(
        base_parameter(label: "Label", nullable: false, required: true),
        %{min_length: 2, max_length: 200, values: nil, multiple: false, unique: false, default_string: nil}),
      :string, nil, %{}, nil, nil, nil)

    format = Unit.new(:format,
      Map.merge(
        base_parameter(label: "Format", nullable: false),
        %{min_length: 2, max_length: nil, values: nil, multiple: false, unique: false, default_string: "attribute"}),
      :string, nil, %{}, nil, nil, nil)

    is_primary = Unit.new(:is_primary,
      Map.merge(
        base_parameter(label: "Is Primary", nullable: false),
        %{default_boolean: false}),
      :boolean, nil, %{}, nil, nil, nil)

    nullable = Unit.new(:nullable,
      Map.merge(
        base_parameter(label: "Nullable", nullable: false),
        %{default_boolean: true}),
      :boolean, nil, %{}, nil, nil, nil)

    required = Unit.new(:required,
      Map.merge(
        base_parameter(label: "Required", nullable: false),
        %{default_boolean: false}),
      :boolean, nil, %{}, nil, nil, nil)

    persistence = Unit.new(:persistence,
      Map.merge(
        base_parameter(label: "Persistence", nullable: false),
        %{min_length: 2, max_length: nil, values: [%{label: "Arke Parameter", value: "arke_parameter"}, %{label: "Table Column", value: "table_column"}], multiple: false, unique: false, default_string: "arke_parameter"}),
      :string, nil, %{}, nil, nil, nil)

    helper_text = Unit.new(:helper_text,
      Map.merge(
        base_parameter(label: "Helper text", nullable: true),
        %{min_length: 2, max_length: nil, values: nil, multiple: false, unique: false, default_string: nil}),
      :string, nil, %{}, nil, nil, nil)


    min_length = Unit.new(:min_length,
      Map.merge(
        base_parameter(label: "Min Length"),
        %{min: nil, max: nil, values: nil, multiple: false, unique: false, default_integer: nil}),
      :integer, nil, %{}, nil, nil, nil)

    max_length = Unit.new(:max_length,
      Map.merge(
        base_parameter(label: "Max Length"),
        %{min: nil, max: nil, values: nil, multiple: false, unique: false, default_integer: nil}),
      :integer, nil, %{}, nil, nil, nil)

    values = Unit.new(:values,
      Map.merge(
        base_parameter(label: "Values"),
        %{default_list: nil}),
      :list, nil, %{}, nil, nil, nil)

    multiple = Unit.new(:multiple,
      Map.merge(
        base_parameter(label: "Multiple", nullable: false),
        %{default_boolean: false}),
      :boolean, nil, %{}, nil, nil, nil)

    unique = Unit.new(:unique,
      Map.merge(
        base_parameter(label: "Unique", nullable: false),
        %{default_boolean: false}),
      :boolean, nil, %{}, nil, nil, nil)

    min = Unit.new(:min,
      Map.merge(
        base_parameter(label: "Min"),
        %{min: nil, max: nil, values: nil, multiple: false, unique: false, default_integer: nil}),
      :integer, nil, %{}, nil, nil, nil)

    max = Unit.new(:max,
      Map.merge(
        base_parameter(label: "Max"),
        %{min: nil, max: nil, values: nil, multiple: false, unique: false, default_integer: nil}),
      :integer, nil, %{}, nil, nil, nil)

    default_integer = Unit.new(:default_integer,
      Map.merge(
        base_parameter(label: "Default"),
        %{min: nil, max: nil, values: nil, multiple: false, unique: false, default_integer: nil}),
      :integer, nil, %{}, nil, nil, nil)

    default_float = Unit.new(:default_float,
      Map.merge(
        base_parameter(label: "Default"),
        %{min: nil, max: nil, values: nil, multiple: false, unique: false, default_float: nil}),
      :float, nil, %{}, nil, nil, nil)

    default_string = Unit.new(:default_string,
      Map.merge(
        base_parameter(label: "Default"),
        %{min_length: nil, max_length: nil, values: nil, multiple: false, unique: false, default_string: nil}),
      :string, nil, %{}, nil, nil, nil)

    default_boolean = Unit.new(:default_boolean,
      Map.merge(
        base_parameter(label: "Default"),
        %{default_boolean: nil}),
      :boolean, nil, %{}, nil, nil, nil)

    default_dict = Unit.new(:default_dict,
      Map.merge(
        base_parameter(label: "Default"),
        %{default_dict: nil}),
      :dict, nil, %{}, nil, nil, nil)

    default_list = Unit.new(:default_list,
      Map.merge(
        base_parameter(label: "Default"),
        %{default_list: nil}),
      :list, nil, %{}, nil, nil, nil)

    default_date = Unit.new(:default_date,
      Map.merge(
        base_parameter(label: "Default"),
        %{default_date: nil}),
      :date, nil, %{}, nil, nil, nil)

    default_time = Unit.new(:default_time,
      Map.merge(
        base_parameter(label: "Default"),
        %{default_time: nil}),
      :time, nil, %{}, nil, nil, nil)

    default_datetime = Unit.new(:default_datetime,
      Map.merge(
        base_parameter(label: "Default"),
        %{default_datetime: nil}),
      :datetime, nil, %{}, nil, nil, nil)

    default_link = Unit.new(:default_link,
      Map.merge(
        base_parameter(label: "Default"),
        %{default_link: []}),
      :link, nil, %{}, nil, nil, nil)

    description = Unit.new(:description,
      Map.merge(
        base_parameter(label: "Description"),
        %{min_length: 0, max_length: 500, values: nil, multiple: false, unique: false, default_string: nil}),
      :string, nil, %{}, nil, nil, nil)

    arke_list = Unit.new(:arke_list,
      Map.merge(
        base_parameter(label: "Arke List"),
        %{default_link: []}),
      :link, nil, %{}, nil, nil, nil)

    parameters = Unit.new(:parameters,
      Map.merge(
        base_parameter(label: "Parameters"),
        %{default_link: []}),
      :link, nil, %{}, nil, nil, nil)

    child_id = Unit.new(:child_id,
      Map.merge(
        base_parameter(label: "Child Id"),
        %{min_length: 2, max_length: nil, values: nil, multiple: false, unique: false, default_string: nil}),
      :string, nil, %{}, nil, nil, nil)

    parent_id = Unit.new(:parent_id,
      Map.merge(
        base_parameter(label: "Parent Id"),
        %{min_length: 2, max_length: nil, values: nil, multiple: false, unique: false, default_string: nil}),
      :string, nil, %{}, nil, nil, nil)


    type = Unit.new(:type,
      Map.merge(
        base_parameter(label: "Type"),
        %{min_length: 2, max_length: nil, values: nil, multiple: false, unique: false, default_string: nil}),
      :string, nil, %{}, nil, nil, nil)

    name = Unit.new(:name,
      Map.merge(
        base_parameter(label: "Name"),
        %{min_length: 2, max_length: 100, values: nil, multiple: false, unique: false, default_string: nil}),
      :string, nil, %{}, nil, nil, nil)


    public_key = Unit.new(:public_key,
      Map.merge(
        base_parameter(label: "Public Key"),
        %{min_length: 2, max_length: nil, values: nil, multiple: false, unique: false, default_string: nil}),
      :string, nil, %{}, nil, nil, nil)

    email = Unit.new(:email,
      Map.merge(
        base_parameter(label: "Email"),
        %{min_length: 2, max_length: nil, values: nil, multiple: false, unique: false, default_string: nil}),
      :string, nil, %{}, nil, nil, nil)

    vat = Unit.new(:vat,
      Map.merge(
        base_parameter(label: "Vat"),
        %{min_length: 2, max_length: nil, values: nil, multiple: false, unique: false, default_string: nil}),
      :string, nil, %{}, nil, nil, nil)

    environment = Unit.new(:environment,
      Map.merge(
        base_parameter(label: "Environment"),
        %{min_length: 2, max_length: nil, values: nil, multiple: false, unique: false, default_string: nil}),
      :string, nil, %{}, nil, nil, nil)


    username = Unit.new(:username,
      Map.merge(
        base_parameter(label: "Username"),
        %{min_length: 3, max_length: nil, values: nil, multiple: false, unique: false, default_string: nil}),
      :string, nil, %{}, nil, nil, nil)

    password_hash = Unit.new(:password_hash,
      Map.merge(
        base_parameter(label: "Password hash"),
        %{min_length: 3, max_length: nil, values: nil, multiple: false, unique: false, default_string: nil}),
      :string, nil, %{}, nil, nil, nil)

    first_name = Unit.new(:first_name,
      Map.merge(
        base_parameter(label: "First name"),
        %{min_length: 3, max_length: nil, values: nil, multiple: false, unique: false, default_string: nil}),
      :string, nil, %{}, nil, nil, nil)

    last_name = Unit.new(:last_name,
      Map.merge(
        base_parameter(label: "Last name"),
        %{min_length: 3, max_length: nil, values: nil, multiple: false, unique: false, default_string: nil}),
      :string, nil, %{}, nil, nil, nil)

    fiscal_code = Unit.new(:fiscal_code,
      Map.merge(
        base_parameter(label: "Fiscal code"),
        %{min_length: 3, max_length: nil, values: nil, multiple: false, unique: false, default_string: nil}),
      :string, nil, %{}, nil, nil, nil)

    address = Unit.new(:address,
      Map.merge(
        base_parameter(label: "Address"),
        %{default_dict: nil}),
      :dict, nil, %{}, nil, nil, nil)

    phone_number = Unit.new(:phone_number,
      Map.merge(
        base_parameter(label: "Phone number"),
        %{min_length: 1, max_length: nil, values: nil, multiple: false, unique: false, default_string: nil}),
      :string, nil, %{}, nil, nil, nil)

    birth_date = Unit.new(:birth_date,
      Map.merge(
        base_parameter(label: "Birth date"),
        %{min_length: 1, max_length: nil, values: nil, multiple: false, unique: false, default_string: nil}),
      :string, nil, %{}, nil, nil, nil)

    first_access = Unit.new(:first_access,
      Map.merge(
        base_parameter(label: "First access"),
        %{default_boolean: true}),
      :boolean, nil, %{}, nil, nil, nil)

    last_login = Unit.new(:last_login,
      Map.merge(
        base_parameter(label: "Last login", persistence: "table_column"),
        %{default_datetime: nil}),
      :datetime, nil, %{}, nil, nil, nil)

    parameters = [id, arke_id, metadata, configuration, inserted_at, updated_at, active, label, format, is_primary,
      nullable, required, persistence, helper_text, min_length, max_length, values, multiple, unique, min, max,
      default_integer, default_float, default_string, default_boolean, default_dict, default_list, default_date, default_time,
      default_datetime, description, arke_list, parameters, child_id, parent_id, type, name, public_key, email, vat,
      environment, username, password_hash, first_name, last_name, fiscal_code, address, phone_number, first_access,
      last_login, birth_date, default_link
    ]

    Enum.map(parameters, fn parameter ->
      ParameterManager.create(parameter, :arke_system)
    end)

  end

end