defmodule MishkaInstaller.Installer.DepHandler do
  @event "on_change_dependency"
  alias MishkaInstaller.{
    Dependency,
    Installer.MixCreator,
    Installer.DepChangesProtector,
    Installer.RunTimeSourcing
  }

  alias MishkaInstaller.Helper.Extra
  require Logger

  defstruct [
    :app,
    :version,
    :type,
    :url,
    :git_tag,
    :custom_command,
    :dependency_type,
    dependencies: []
  ]

  @moduledoc """

  A module that holds new dependencies' information, and add them into database or validating to implement in runtime

  ### Responsibilities of this module

  * Create `Json` - it helps developer to implement theire plugin/commponent into the project.
  * Add dependencies into database - for validating, stroing and keeping backup of runtime dependencies
  * Get dependencies information in several different ways


  ### For example, these are output from `Json` file
  ```elixir
  [
    %{
      app: :mishka_installer,
      version: "0.0.2",
      type: :git, # :hex, if user upload elixir libraries (path), we should keep them in a temporary folder, and Docker should make it valume
      url: "https://github.com/mishka-group/mishka_installer", # if it is hex: https://hex.pm/packages/mishka_installer
      git_tag: "0.0.2", # we consider it when it is a git, and if does not exist we get master,
      custom_command: "ecto.migrate", # you can write nil or you task file like ecto.migrate
      dependency_type: :none, # :force_update, When you use this, the RunTime sourcing check what dependencies you use in your program have a higher version
      #compared to the old source. it just notice admin there is a update, it does not force the source to be updated
      dependencies: [ # this part let mishka_installer to know can update or not dependencies of a app, we should consider a backup file
        %{app: :mishka_developer_tools, max: "0.0.2", min: "0.0.1"},
        %{app: :mishka_social, max: "0.0.2", min: "0.0.1"}
      ]
    }
  ]
  ```
  OR

  ```elixir
  %MishkaInstaller.Installer.DepHandler{
    app: "mishka_social",
    version: "0.0.2 ",
    type: "hex",
    url: "https://hex.pm/packages/mishka_social",
    git_tag: nil,
    custom_command: nil,
    dependency_type: "force_update",
    dependencies: [
      %{app: :phoenix, min: "1.6"},
      %{app: :phoenix_live_view, max: "0.17.7", min: "0.17.7"},
      %{app: :ueberauth, max: "0.17.7", min: "0.17.7"},
      %{app: :ueberauth_github, min: "0.8.1"},
      %{app: :ueberauth_google, min: "0.10.1"},
    ]
  }
  ```
  """

  @type app_info() :: String.t() | atom() | map() | list()
  @type run() :: :hex | :git | :upload
  @type installed_apps() :: {atom, description :: charlist(), vsn :: charlist()}
  @type t() :: %__MODULE__{
          app: String.t() | nil,
          version: String.t() | nil,
          type: String.t() | nil,
          url: String.t() | nil,
          git_tag: String.t() | nil,
          custom_command: String.t() | nil,
          dependency_type: String.t() | nil,
          dependencies: [map()]
        }

  @doc """
    ## Run and Get a dependency
    ```elixir
      Application.spec(:timex, :vsn)

      MishkaInstaller.Installer.DepHandler.run(:hex, "faker")

      app = %{url: "https://github.com/bitwalker/timex", tag: "3.7.5"}
      MishkaInstaller.Installer.DepHandler.run(:git, app)

      app = %{url: "https://github.com/bitwalker/timex", tag: "3.7.6"}
      MishkaInstaller.Installer.DepHandler.run(:git, app)

      app = %{url: "https://github.com/bitwalker/timex", tag: "3.7.8"}
      MishkaInstaller.Installer.DepHandler.run(:git, app)


      app = %{url: "https://github.com/elixirs/faker", tag: "v0.17.0"}
      MishkaInstaller.Installer.DepHandler.run(:git, app)

      app = %{url: "https://github.com/martinsvalin/html_entities", tag: "v0.5.1"}
      MishkaInstaller.Installer.DepHandler.run(:git, app)


      app = %{url: "https://github.com/beatrichartz/csv", tag: "v2.3.0"}
      MishkaInstaller.Installer.DepHandler.run(:git, app)

      MishkaInstaller.Installer.DepHandler.run(:upload, ["../mishka_installer/deployment/extensions/timex-3.7.8.zip"])

    ```
  """
  # ref: fix phoenix reload issue when a dep is compiled (https://github.com/phoenixframework/phoenix/issues/4278)
  # this ref should be in the document https://hexdocs.pm/phoenix/Phoenix.CodeReloader.html#reload/1
  @spec run(:git | :hex | :upload, app_info(), atom()) :: map()
  def run(type, app, output_type \\ :cmd)

  def run(:hex = type, app, output_type) do
    MishkaInstaller.Helper.Sender.package("hex", %{"app" => app})
    |> check_app_status(type, nil)
    |> run_request_handler(type, output_type)
  end

  def run(:git = type, app, output_type) do
    MishkaInstaller.Helper.Sender.package("github", %{"url" => app.url, "tag" => app.tag})
    |> check_app_status(type, nil)
    |> run_request_handler(type, output_type)
  end

  def run(:upload = type, [file_path], output_type) do
    unzip_dep_folder(file_path)
    |> check_mix_file_and_get_ast(file_path)
    |> check_app_status(:upload, file_path)
    |> run_request_handler(type, output_type)
  end

  @spec create_mix_file_and_start_compile(String.t() | atom(), atom()) :: :ok
  def create_mix_file_and_start_compile(app_name, output_type) do
    mix_path = MishkaInstaller.get_config(:mix_path)
    MixCreator.backup_mix(mix_path)
    create_deps_json_file(MishkaInstaller.get_config(:project_path))

    list_json_dpes =
      Enum.map(mix_read_from_json(), fn {key, _v} ->
        String.contains?(File.read!(mix_path), "#{key}")
      end)
      |> Enum.any?(&(!&1))

    MixCreator.create_mix(MishkaInstaller.get_config(:mix).project[:deps], mix_path)

    if list_json_dpes do
      Logger.warn("Try to re-create Mix file")
      create_mix_file_and_start_compile(app_name, output_type)
    else
      DepChangesProtector.deps(app_name, output_type)
    end
  end

  @spec create_mix_file :: :ok
  def create_mix_file() do
    mix_path = MishkaInstaller.get_config(:mix_path)
    create_deps_json_file(MishkaInstaller.get_config(:project_path))

    list_json_dpes =
      Enum.map(mix_read_from_json(), fn {key, _v} ->
        String.contains?(File.read!(mix_path), "#{key}")
      end)
      |> Enum.any?(&(!&1))

    MixCreator.create_mix(MishkaInstaller.get_config(:mix).project[:deps], mix_path)

    if list_json_dpes do
      Logger.warn("Try to re-create Mix file")
      create_mix_file()
    else
      :ok
    end
  end

  # This function helps developer to decide what they should do when an app is going to be updated.
  # For example, each of the extensions maybe have states or necessary jobs, hence they can register their app for `on_change_dependency` event.
  @spec add_new_app(MishkaInstaller.Installer.DepHandler.t()) ::
          {:ok, :add_new_app, any} | {:error, :add_new_app, :changeset | :file, any}
  def add_new_app(%__MODULE__{} = app_info) do
    case check_or_create_deps_json() do
      {:ok, :check_or_create_deps_json, exist_json} ->
        insert_new_ap(
          {:open_file, File.open(extensions_json_path(), [:read, :write])},
          app_info,
          exist_json
        )

      {:error, :check_or_create_deps_json, msg} ->
        {:error, :add_new_app, :file, msg}
    end
  end

  @spec read_dep_json(any) :: {:error, :read_dep_json, String.t()} | {:ok, :read_dep_json, list()}
  def read_dep_json(json \\ File.read!(extensions_json_path())) do
    {:ok, :read_dep_json, json |> Jason.decode!()}
  rescue
    _e ->
      {:error, :read_dep_json,
       Gettext.dgettext(
         MishkaInstaller.gettext(),
         "mishka_installer",
         "You do not have access to read this file or maybe the file does not exist or even has syntax error"
       )}
  end

  @spec mix_read_from_json :: list
  def mix_read_from_json() do
    case read_dep_json() do
      {:ok, :read_dep_json, data} ->
        Enum.map(data, fn item -> mix_creator(item["type"], item) end)

      {:error, :read_dep_json, msg} ->
        raise msg <> ". To make sure, re-create the JSON file from scratch."
    end
  end

  @spec append_mix([tuple()]) :: list
  def append_mix(list) do
    new_list = Enum.map(list, &(&1 |> Tuple.to_list() |> List.first()))

    json_mix =
      Enum.map(mix_read_from_json(), &mix_item(&1, new_list, list))
      |> Enum.reject(&is_nil(&1))

    Enum.reject(list, fn item ->
      List.first(Tuple.to_list(item)) in Enum.map(json_mix, fn item ->
        List.first(Tuple.to_list(item))
      end)
    end) ++ json_mix
  rescue
    _e -> list
  end

  @spec compare_dependencies_with_json(installed_apps() | any()) ::
          list | {:error, :compare_dependencies_with_json, String.t()}
  def compare_dependencies_with_json(installed_apps \\ Application.loaded_applications()) do
    with {:ok, :check_or_create_deps_json, exist_json} <- check_or_create_deps_json(),
         {:ok, :read_dep_json, json_data} <- read_dep_json(exist_json) do
      installed_apps =
        Map.new(installed_apps, fn {app, _des, _ver} = item -> {Atom.to_string(app), item} end)

      Enum.map(json_data, fn app ->
        case Map.fetch(installed_apps, app["app"]) do
          :error ->
            nil

          {:ok, {installed_app, _des, installed_version}} ->
            %{
              app: installed_app,
              json_version: app["version"],
              installed_version: installed_version,
              status: Version.compare(String.trim(app["version"]), "#{installed_version}")
            }
        end
      end)
      |> Enum.reject(&is_nil(&1))
    else
      {:error, :check_or_create_deps_json, msg} -> {:error, :compare_dependencies_with_json, msg}
      _ -> {:error, :compare_dependencies_with_json, "invalid Json file"}
    end
  end

  @spec compare_sub_dependencies_with_json(any) ::
          list | {:error, :compare_sub_dependencies_with_json, String.t()}
  def compare_sub_dependencies_with_json(installed_apps \\ Application.loaded_applications()) do
    with {:ok, :check_or_create_deps_json, exist_json} <- check_or_create_deps_json(),
         {:ok, :read_dep_json, json_data} <- read_dep_json(exist_json) do
      installed_apps =
        Map.new(installed_apps, fn {app, _des, _ver} = item -> {Atom.to_string(app), item} end)

      Enum.map(merge_json_by_min_version(json_data), fn app ->
        case Map.fetch(installed_apps, app["app"]) do
          :error ->
            nil

          {:ok, {installed_app, _des, installed_version}} ->
            %{
              app: installed_app,
              json_min_version: app["min"],
              json_max_version: app["max"],
              installed_version: installed_version,
              min_status:
                if(!is_nil(app["min"]),
                  do: Version.compare(String.trim(app["min"]), "#{installed_version}"),
                  else: nil
                ),
              max_status:
                if(!is_nil(app["max"]),
                  do: Version.compare(String.trim(app["max"]), "#{installed_version}"),
                  else: nil
                )
            }
        end
      end)
      |> Enum.reject(&is_nil(&1))
    else
      {:error, :check_or_create_deps_json, msg} ->
        {:error, :compare_sub_dependencies_with_json, msg}

      _ ->
        {:error, :compare_sub_dependencies_with_json, "invalid Json file"}
    end
  end

  @spec check_or_create_deps_json(binary) ::
          {:ok, :check_or_create_deps_json, String.t()}
          | {:error, :check_or_create_deps_json, String.t()}
  def check_or_create_deps_json(project_path \\ MishkaInstaller.get_config(:project_path)) do
    with {:deployment_path, true} <-
           {:deployment_path, File.exists?(Path.join(project_path, ["deployment"]))},
         {:extensions_path, true} <-
           {:extensions_path,
            File.exists?(Path.join(project_path, ["deployment/", "extensions"]))},
         {:json_file, true} <- {:json_file, File.exists?(extensions_json_path())},
         {:empty_json, true, json_data} <-
           {:empty_json, File.read!(extensions_json_path()) != "",
            File.read!(extensions_json_path())},
         {:ok, :read_dep_json, _converted_json} <- read_dep_json(json_data) do
      {:ok, :check_or_create_deps_json, json_data}
    else
      {:deployment_path, false} ->
        create_deps_json_directory(project_path, "deployment")

      {:extensions_path, false} ->
        create_deps_json_directory(project_path, "deployment/extensions")

      {:json_file, false} ->
        create_deps_json_file(project_path)

      {:empty_json, false, _data} ->
        File.rm_rf(extensions_json_path())
        create_deps_json_file(project_path)

      {:error, :read_dep_json, _msg} ->
        File.rm_rf(extensions_json_path())
        create_deps_json_file(project_path)
    end
  end

  @spec get_deps_from_mix(module()) :: list
  def get_deps_from_mix(mix_module) do
    [{:deps, app_info} | _t] =
      Keyword.filter(mix_module.project, fn {key, _value} -> key == :deps end)

    Enum.map(app_info, fn app_info ->
      [app, version] = Tuple.to_list(app_info) |> Enum.take(2)
      %{app: app, version: version}
    end)
  end

  @spec get_deps_from_mix_lock :: list
  def get_deps_from_mix_lock() do
    Mix.Dep.Lock.read()
    |> Map.to_list()
    |> Enum.map(fn {key, list} ->
      [_h | [_app, version]] = Tuple.to_list(list) |> Enum.take(3)
      %{app: key, version: version}
    end)
  end

  @spec extensions_json_path :: binary()
  def extensions_json_path() do
    path = MishkaInstaller.get_config(:project_path)
    Path.join(path, ["deployment/", "extensions/", "extensions.json"])
  end

  @spec create_deps_json_file(binary()) ::
          {:error, :check_or_create_deps_json, binary} | {:ok, :check_or_create_deps_json, binary}
  def create_deps_json_file(project_path) do
    case File.open(extensions_json_path(), [:write]) do
      {:ok, file} ->
        IO.binwrite(file, Jason.encode!(MishkaInstaller.Dependency.dependencies()))
        File.close(file)
        check_or_create_deps_json(project_path)

      _error ->
        {:error, :check_or_create_deps_json,
         Gettext.dgettext(
           MishkaInstaller.gettext(),
           "mishka_installer",
           "You do not have sufficient access to create this file. Please add it manually."
         )}
    end
  end

  @spec compare_installed_deps_with_app_file(String.t()) ::
          {:error, :compare_installed_deps_with_app_file, String.t()}
          | {:ok, :compare_installed_deps_with_app_file, list()}
  def compare_installed_deps_with_app_file(app) do
    new_app_path = Path.join(MishkaInstaller.get_config(:project_path), ["deps/", "#{app}"])

    if File.dir?(new_app_path) and File.dir?(new_app_path <> "/_build/#{Mix.env()}/lib") do
      apps_list =
        File.ls!(new_app_path <> "/_build/#{Mix.env()}/lib")
        |> Enum.map(fn sub_app ->
          with {:ok, bin} <- RunTimeSourcing.read_app(new_app_path, sub_app),
               {:ok, {:application, _, properties}} <- RunTimeSourcing.consult_app_file(bin),
               true <- compare_version_with_installed_app(sub_app, properties[:vsn]) do
            {sub_app, new_app_path <> "/_build/#{Mix.env()}/lib/#{sub_app}"}
          else
            _ -> nil
          end
        end)
        |> Enum.reject(&is_nil(&1))

      {:ok, :compare_installed_deps_with_app_file, apps_list}
    else
      {:error, :compare_installed_deps_with_app_file,
       Gettext.dgettext(
         MishkaInstaller.gettext(),
         "mishka_installer",
         "App folder or its _build does not exist"
       )}
    end
  end

  def move_and_replace_compiled_app_build(app_list) do
    Enum.map(app_list, fn {app, build_path} ->
      MishkaInstaller.Installer.RunTimeSourcing.do_runtime(String.to_atom(app), :uninstall)
      File.cp_r(build_path, Path.join(RunTimeSourcing.get_build_path(), "#{app}"))
    end)
  end

  def compare_version_with_installed_app(app, version) do
    ver = Application.spec(String.to_atom(app), :vsn)
    if !is_nil(ver), do: Version.compare("#{version}", "#{ver}") == :gt, else: true
  end

  defp create_deps_json_directory(project_path, folder_path) do
    case File.mkdir(Path.join(project_path, folder_path)) do
      :ok ->
        check_or_create_deps_json(project_path)

      {:error, :eacces} ->
        {:error, :check_or_create_deps_json,
         Gettext.dgettext(
           MishkaInstaller.gettext(),
           "mishka_installer",
           "You do not have sufficient access to create this directory. Please add it manually."
         )}

      {:error, :enospc} ->
        {:error, :check_or_create_deps_json,
         Gettext.dgettext(
           MishkaInstaller.gettext(),
           "mishka_installer",
           "there is no space left on the device."
         )}

      {:error, e} when e in [:eexist, :enoent, :enotdir] ->
        {:error, :check_or_create_deps_json,
         Gettext.dgettext(
           MishkaInstaller.gettext(),
           "mishka_installer",
           "Please contact plugin support when you encounter this error."
         )}
    end
  end

  # Ref: https://elixirforum.com/t/how-to-improve-sort-of-maps-in-a-list-which-have-duplicate-key/47486
  defp merge_json_by_min_version(json_data) do
    Enum.flat_map(json_data, & &1["dependencies"])
    |> Enum.group_by(& &1["app"])
    |> Enum.map(fn {_key, list} ->
      Enum.max_by(list, & &1["min"], Version)
    end)
  end

  defp insert_new_ap({:open_file, {:ok, _file}}, app_info, exist_json) do
    with {:decode, {:ok, exist_json_data}} <- {:decode, Jason.decode(exist_json)},
         {:duplicate_app, false} <-
           {:duplicate_app,
            Enum.any?(
              exist_json_data,
              &(&1["app"] == Map.get(app_info, :app) || Map.get(app_info, "app"))
            )},
         map_app_info <- [Map.from_struct(app_info)],
         {:encode, {:ok, _new_apps}} <- {:encode, Jason.encode(exist_json_data ++ map_app_info)},
         {:ok, :add, :dependency, repo_data} <-
           MishkaInstaller.Dependency.create(Map.from_struct(app_info)) do
      # after the new app added into the database, the DepChangesProtector module remove the json file and re-create it
      {:ok, :add_new_app, repo_data}
    else
      {:decode, {:error, _error}} ->
        {:error, :add_new_app, :file,
         Gettext.dgettext(
           MishkaInstaller.gettext(),
           "mishka_installer",
           "We can not decode the JSON file, because this file has syntax problems. Please delete this file or fix it"
         )}

      {:duplicate_app, true} ->
        {:error, :add_new_app, :file,
         Gettext.dgettext(
           MishkaInstaller.gettext(),
           "mishka_installer",
           "You can not insert new app which is duplicate, if you want to update it please use another function."
         )}

      {:encode, {:error, _error}} ->
        {:error, :add_new_app, :file,
         Gettext.dgettext(
           MishkaInstaller.gettext(),
           "mishka_installer",
           "We can not encode your new app data, please check your data."
         )}

      {:error, :add, :dependency, repo_error} ->
        {:error, :add_new_app, :changeset, repo_error}
    end
  end

  defp insert_new_ap({:open_file, {:error, _posix}}, _app_info, _exist_json),
    do:
      {:error, :add_new_app, :file,
       Gettext.dgettext(
         MishkaInstaller.gettext(),
         "mishka_installer",
         "Unfortunately, the JSON concerned file either does not exist or we do not have access to it. You can delete or create it in your panel, but before that please check you have enough access to edit it."
       )}

  defp mix_creator("hex", data) do
    {String.to_atom(data["app"]), "~> #{String.trim(data["version"])}"}
  end

  defp mix_creator("path", data) do
    uploaded_extension =
      Path.join(MishkaInstaller.get_config(:project_path), [
        "deployment/",
        "extensions/",
        "#{data["app"]}"
      ])

    {String.to_atom(data["app"]), path: uploaded_extension}
  end

  defp mix_creator("git", data) do
    case data["git_tag"] do
      nil ->
        {String.to_atom(data["app"]), git: data["url"]}

      _ ->
        {String.to_atom(data["app"]), git: data["url"], tag: data["git_tag"]}
    end
  end

  # The priority of path and git master/main are always higher the `mix` dependencies list.
  defp mix_item({_app, path: _uploaded_extension} = value, _app_list, _deps_list), do: value
  defp mix_item({_app, git: _url} = value, _app_list, _deps_list), do: value

  defp mix_item({app, git: _url, tag: imporetd_version} = value, app_list, deps_list) do
    if app in app_list,
      do: check_same_app_version(app, deps_list, imporetd_version, value),
      else: value
  end

  defp mix_item({app, imporetd_version} = value, app_list, deps_list) do
    if app in app_list,
      do: check_same_app_version(app, deps_list, imporetd_version, value),
      else: value
  end

  defp check_same_app_version(app, deps_list, imporetd_version, value) do
    founded_app =
      Enum.find(deps_list, fn item -> Enum.take(Tuple.to_list(item), 1) |> List.first() == app end)

    case Enum.take(Tuple.to_list(founded_app), 3) |> List.to_tuple() do
      {_founded_app_name, git: _url} ->
        nil

      {_founded_app_name, git: _url, tag: tag} ->
        if Version.compare(clean_mix_version(imporetd_version), clean_mix_version(tag)) in [
             :eq,
             :lt
           ],
           do: nil,
           else: value

      {_founded_app_name, version} ->
        if Version.compare(clean_mix_version(imporetd_version), clean_mix_version(version)) in [
             :eq,
             :lt
           ],
           do: nil,
           else: value
    end
  rescue
    _e -> nil
  end

  defp clean_mix_version(version) do
    version
    |> String.replace("~>", "")
    |> String.replace(">=", "")
    |> String.replace("v", "")
    |> String.trim()
  end

  defp check_app_status({:ok, :package, pkg}, :hex, _) do
    create_app_info(pkg, :hex)
    |> Map.from_struct()
    |> sync_app_with_database()
  end

  defp check_app_status(result, type, file_path) when type in [:git, :upload] do
    case result do
      {:error, :package, result} when result in [:mix_file, :not_found, :not_tag, :unhandled] ->
        {:error,
         Gettext.dgettext(
           MishkaInstaller.gettext(),
           "mishka_installer",
           "Unfortunately, an error occurred while we were comparing your mix.exs file. The flag of erorr is %{result}",
           result: result
         )}

      data ->
        if Enum.any?(data, &(&1 == {:error, :package, :convert_ast_output})) do
          {:error,
           Gettext.dgettext(
             MishkaInstaller.gettext(),
             "mishka_installer",
             "Your mix.exs file must contain the app, version and source_url parameters"
           )}
        else
          create_app_info(data, if(type == :git, do: type, else: :path))
          |> Map.from_struct()
          |> rename_folder_copy_to_deps(file_path)
          |> sync_app_with_database()
        end
    end
  end

  defp check_app_status({:error, :package, status}, type, _) do
    msg =
      if status == :not_found do
        Gettext.dgettext(
          MishkaInstaller.gettext(),
          "mishka_installer",
          "Are you sure you have entered the package name or url correctly?"
        )
      else
        Gettext.dgettext(
          MishkaInstaller.gettext(),
          "mishka_installer",
          "Unfortunately, we cannot connect to %{type} server now, please try other time! or make it correct",
          type: type
        )
      end

    {:error, msg}
  end

  defp rename_folder_copy_to_deps(data, file_path)
       when not is_nil(file_path) and is_binary(file_path) do
    file =
      Path.join(MishkaInstaller.get_config(:project_path), [
        "deployment/",
        "extensions/",
        "#{Path.basename(file_path, ".zip")}"
      ])

    new_name =
      Path.join(MishkaInstaller.get_config(:project_path), [
        "deployment/",
        "extensions/",
        "#{data.app}"
      ])

    File.rename!(file, new_name)

    File.cp_r!(
      new_name,
      Path.join(MishkaInstaller.get_config(:project_path), ["deps/", "#{data.app}"])
    )

    data
  end

  defp rename_folder_copy_to_deps(data, _file_path), do: data

  defp sync_app_with_database(data) do
    if compare_version_with_installed_app(data.app, data.version) do
      case Dependency.create_or_update(data) do
        {:ok, :add, :dependency, repo_data} ->
          {:ok, :no_state,
           Gettext.dgettext(
             MishkaInstaller.gettext(),
             "mishka_installer",
             "We could not find any registered-app that has important state, hence you can update safely. It should be noted if you send multi apps before finishing previous app, other new apps are saved in a queue."
           ), repo_data.app}

        {:ok, :edit, :dependency, repo_data} ->
          if MishkaInstaller.PluginETS.get_all(event: @event) == [] do
            {:ok, :no_state,
             Gettext.dgettext(
               MishkaInstaller.gettext(),
               "mishka_installer",
               "We could not find any registered-app that has important state, hence you can update safely. It should be noted if you send multi apps before finishing previous app, other new apps are saved in a queue."
             ), repo_data.app}
          else
            {:ok, :registered_app,
             Gettext.dgettext(
               MishkaInstaller.gettext(),
               "mishka_installer",
               "There is an important state for an app at least, so we sent a notification to them and put your request in the update queue. After their response, we will change the %{app} dependency and let you know about its latest news.",
               app: repo_data.app
             ), repo_data.app}
          end

        {:error, action, :dependency, _repo_error} when action in [:add, :edit] ->
          # TODO: save it in activities
          {:error,
           Gettext.dgettext(
             MishkaInstaller.gettext(),
             "mishka_installer",
             "Unfortunately, an error occurred while storing the data in the database. To check for errors, see the Activities section, and if this error persists, report it to support."
           )}

        {:error, action, :uuid, _error_tag} when action in [:uuid, :get_record_by_id] ->
          # TODO: save it in activities
          {:error,
           Gettext.dgettext(
             MishkaInstaller.gettext(),
             "mishka_installer",
             "Unfortunately, an error occurred while storing the data in the database. To check for errors, see the Activities section, and if this error persists, report it to support."
           )}

        {:error, :update_app_version, :older_version} ->
          {:error,
           Gettext.dgettext(
             MishkaInstaller.gettext(),
             "mishka_installer",
             "You have already installed this library and the installed version is the same as the latest version of the Hex site. Please take action when a new version of this app is released"
           )}
      end
    else
      {:error,
       Gettext.dgettext(
         MishkaInstaller.gettext(),
         "mishka_installer",
         "You have already installed this library and the installed version is the same as the latest version of the Hex site. Please take action when a new version of this app is released"
       )}
    end
  end

  defp run_request_handler(status, type, output_type) do
    case status do
      {:ok, :no_state, msg, app_name} ->
        MishkaInstaller.DepCompileJob.add_job(app_name, output_type)

        %{
          "app_name" => app_name,
          "status_message_type" => :success,
          "message" => msg,
          "selected_form" => type
        }

      {:ok, :registered_app, msg, app_name} ->
        %{
          "app_name" => app_name,
          "status_message_type" => :info,
          "message" => msg,
          "selected_form" => :registered_app
        }

      {:error, msg} ->
        %{
          "app_name" => nil,
          "status_message_type" => :danger,
          "message" => msg,
          "selected_form" => type
        }
    end
  end

  defp unzip_dep_folder(file_path) do
    {:unzip,
     :zip.unzip(~c'#{file_path}', [
       {:cwd,
        ~c'#{Path.join(MishkaInstaller.get_config(:project_path), ["deployment/", "extensions"])}'}
     ])}
  end

  defp check_mix_file_and_get_ast({:unzip, {:ok, _content}}, file_path) do
    mix_file =
      Path.join(MishkaInstaller.get_config(:project_path), [
        "deployment/",
        "extensions/",
        "#{Path.basename(file_path, ".zip")}",
        "/mix.exs"
      ])

    with {:mix_file, {:ok, body}} <- {:mix_file, File.read(mix_file)},
         {:code, {:ok, ast}} <- {:code, Code.string_to_quoted(body)} do
      Extra.ast_mix_file_basic_information(ast, [:app, :version, :source_url])
    else
      {:mix_file, {:error, _error}} -> {:error, :package, :mix_file}
      {:code, {:error, _error}} -> {:error, :package, :string_mix_file}
    end
  end

  defp check_mix_file_and_get_ast({:unzip, {:error, _error}}, _file_path),
    do: {:error, :package, :unzip}

  defp create_app_info(pkg, :hex) do
    %__MODULE__{
      app: pkg["name"],
      version: pkg["latest_stable_version"],
      type: "hex",
      url: pkg["html_url"],
      dependency_type: "force_update",
      dependencies: []
    }
  end

  defp create_app_info([app: app, version: version, source_url: source_url, tag: tag], :git) do
    %__MODULE__{
      app: "#{app}",
      version: "#{version}",
      type: "git",
      git_tag: tag,
      url: "#{source_url}",
      dependency_type: "force_update",
      dependencies: []
    }
  end

  defp create_app_info([app: app, version: version, source_url: source_url], :path) do
    %__MODULE__{
      app: "#{app}",
      version: "#{version}",
      type: "path",
      url: "#{source_url}",
      dependency_type: "force_update",
      dependencies: []
    }
  end
end