defmodule Mix.Tasks.Coh.Clean do
  @moduledoc """
  This task will clean most of the files installed by the `mix coh.install` task.

  Projects created with both `coh.install` and `coherence.install` can be
  cleaned with this task. It will auto detect the project structure and remove
  the appropriate files.

  ## Examples

      # Clean all the installed files
      mix coh.clean --all

      # Clean only the installed view and template files
      mix coh.clean --views --templates

      # Clean all but the models
      mix coh.clean --all --no-models

      # Prompt once to confirm the removal
      mix coh.clean --all --confirm-once

      # Clean installed options
      mix coh.clean --options rememberable
      mix coh.clean --options "registerable invitable trackable"

  The following options are supported:

  * `--all` -- clean all files
  * `--views` -- clean view files
  * `--templates` -- clean template files
  * `--models` -- clean models files
  * `--controllers` -- clean controller files
  * `--email` -- clean email files
  * `--web` -- clean the web/coherence_web.ex file
  * `--messages` -- clean the web/coherence_messages.ex file
  * `--migrations` -- clean the migration files
  * `--options` -- Clean one or more specific options
  * `--dry-run` -- Show what will be removed, but don't actually remove any files
  * `--confirm-once` -- confirm once before removing all selected files

  Disable options:

  * `--no-confirm` - don't confirm before removing files
  """
  use Mix.Task

  import Coherence.Mix.Utils
  import Mix.Ecto

  alias Mix.Tasks.Coh.Install

  @shortdoc "Clean files created by the coherence installer."

  @dialyzer [
    {:nowarn_function, raise_options_error!: 2},
  ]

  @config_file "config/config.exs"
  @remove_opts ~w(views templates models controllers emails web messages migrations config)a
  @default_opts ~w(confirm)a
  @clean_opts [{:options, :string}]
  @switches Enum.map([:all, :confirm_once | @remove_opts] ++ @default_opts, &({&1, :boolean})) ++ @clean_opts ++ [dry_run: :boolean]

  @spec run([String.t] | []) :: any
  def run(args) do
    args
    |> OptionParser.parse(switches: @switches)
    |> do_config
    |> do_clean
    |> do_clean_options
  end

  defp do_clean(config) do
    confirm_once(config, fn config ->
      Enum.reduce @remove_opts, config, &(remove! &2, &1)
    end)
  end

  defp do_clean_options(config) do
    confirm_once(config, fn config ->
      remove! config, :options
    end)
  end

  defp confirm_once(%{confirm_once: true} = config, fun) do
    config = Map.put config, :confirm, false
    if Mix.shell.yes? "Are you sure you want to delete coherence files?" do
      fun.(config)
    end
    config
  end

  defp confirm_once(config, fun) do
    fun.(config)
  end

  defp valid_option?(all_options, option) do
    Enum.any? all_options, &(&1 == option)
  end

  defp validate_options!(options, all_options) do
    case Enum.filter(options, &(not valid_option?(all_options, &1))) do
      [] -> :ok
      list -> raise_options_error!(list, all_options)
    end
  end

  defp option_string(options) do
    options
    |> Enum.map(&Atom.to_string/1)
    |> Enum.join(", ")
  end

  defp raise_options_error!(list, all_options) do
    Mix.raise """
    Invalid Option(s): '#{option_string(list)}' are not valid option(s)

    Please choose from list:
    '#{option_string(all_options)}'
    """
  end

  defp get_current_options(options) do
    :coherence
    |> Application.get_env(:opts)
    |> log_invalid_options(options)
  end

  defp log_invalid_options(current_options, options) do
    case Enum.filter(options, &(not valid_option?(current_options, &1))) do
      [] ->
        options
      invalid_list ->
        Mix.shell.info "Option(s) #{option_string(invalid_list)} where not found in your configuration. They will not be removed."
        options -- invalid_list
    end
  end

  defp remove_view_file!(option, config) do
    view_files = Install.view_files
    case view_files[option] do
      nil ->
        :ok
      file_name ->
        path = web_path ["views", "coherence", file_name]
        confirm config, path, fn -> rm!(path) end
    end
    option
  end

  defp remove_template_files!(option, config) do
    files = Install.template_files
    files
    |> Enum.find(fn {_, {opt, _}} -> opt == option end)
    |> case do
      nil ->
        :ok
      {path, _} ->
        path = web_path ["templates", "coherence", "#{path}"]
        confirm config, path, fn -> rm_dir!(path) end
    end
    option
  end

  defp remove_controller_files!(option, config) do
    case controller_files()[option] do
      nil ->
        :ok
      file_name ->
        path = web_path ["controllers", "coherence", file_name]
        confirm config, path, fn -> rm!(path) end
    end
    option
  end

  defp remove_config_options!(options, config) do
    with contents when is_binary(contents) <- File.read!(@config_file),
        [_, opts_string] when is_binary(opts_string) <- Regex.run(~r/opts:\s*(\[.*?\])/, contents) do
      remove_config_options!(config, contents, options, opts_string)
    else
      error ->
        Mix.raise """
        Problem updating config, error: #{inspect error}
        """
    end
  end

  defp remove_config_options!(config, contents, options, opts_string) do
    new_opts_string =
      Enum.reduce options, opts_string, fn option, acc ->
        String.replace acc, ~r/(,\s*:#{option})|(:#{option}\s*,?\s*)/, ""
      end
    message = ~s'"opts: #{stringify opts_string}" with "opts: #{stringify new_opts_string}"'
    confirm_config config, message, fn ->
      File.write!(@config_file, String.replace(contents, opts_string, new_opts_string))
    end
    config
  end

  defp stringify(item) do
    item
    |> inspect
    |> String.replace("\"", "")
  end

  defp remove_option!(config, option) do
    option
    |> remove_view_file!(config)
    |> remove_template_files!(config)
    |> remove_controller_files!(config)
  end

  defp remove!(%{options: options} = config, :options) do
    all_options = Install.all_options
    options =
      options
      |> String.split(" ", trim: true)
      |> Enum.map(&(String.replace &1, "-", "_"))
      |> Enum.map(&String.to_atom/1)

    validate_options!(options, all_options)

    options
    |> get_current_options
    |> Enum.map(&(remove_option!(config, &1)))
    |> remove_config_options!(config)

    config
  end

  defp remove!(%{templates: true} = config, :templates) do
    path = web_path "templates/coherence"
    confirm config, path, fn -> rm_dir!(path) end
  end

  defp remove!(%{views: true} = config, :views) do
    path = web_path "views/coherence"
    confirm config, path, fn -> rm_dir!(path) end
  end

  defp remove!(%{controllers: true} = config, :controllers) do
    path = web_path "controllers/coherence"
    confirm config, path, fn -> rm_dir!(path) end
  end

  defp remove!(%{models: true} = config, :models) do
    path = lib_path "coherence"
    confirm config, path, fn -> rm_dir!(path) end
  end

  defp remove!(%{web: true} = config, :web) do
    path = web_path "coherence_web.ex"
    confirm config, path, fn -> rm!(path) end
  end

  defp remove!(%{messages: true} = config, :messages) do
    path = web_path "coherence_messages.ex"
    confirm config, path, fn -> rm!(path) end
  end

  defp remove!(%{emails: true} = config, :emails) do
    path = web_path ~w(emails coherence)
    confirm config, path, fn -> rm_dir!(path) end
  end

  defp remove!(%{migrations: true} = config, :migrations) do
    case Application.get_env :coherence, :repo do
      nil ->
        Mix.shell.error "Config.repo not configured. Skipping migration removal!"
      repo ->
        do_remove!(config, repo)
    end
  end

  defp remove!(%{config: true} = config, :config) do
    confirm config, "coherence config", fn ->
      regex = ~r/# %% Coherence Configuration %%.+?# %% End Coherence Configuration %%/s
      conf = File.read! @config_file
      File.write! @config_file, String.replace(conf, regex, "")
    end
  end

  defp remove!(config, _), do: config

  defp do_remove!(config, repo) do
    ensure_repo(repo, [])
    path = Path.relative_to(migrations_path(repo), Mix.Project.app_path)
    case Path.wildcard(path <> "/*coherence*") do
      [] ->
        config
      files ->
        confirmed? =
          if config[:confirm] do
            Mix.shell.info "Found migrations: " <> Enum.join(files, ", ")
            Mix.shell.yes? "Delete them?"
          else
            true
          end
        if confirmed? do
          Enum.each files, &(rm! &1)
        end
        config
    end
  end

  defp confirm_config(%{dry_run: true} = config, message, _fun) do
    Mix.shell.info "Update config " <> message
    config
  end

  defp confirm_config(%{confirm: true} = config, message, fun) do
    if Mix.shell.yes? "Update config " <> message <> "?" do
      Mix.shell.info "Updating config " <> message
      fun.()
    end
    config
  end

  defp confirm_config(config, message, fun) do
    Mix.shell.info "Updating config " <> message
    fun.()
    config
  end

  defp confirm(%{dry_run: true} = config, path, _fun) do
    Mix.shell.info "Delete #{path}"
    config
  end

  defp confirm(%{confirm: true} = config, path, fun) do
    if File.exists? path do
      if Mix.shell.yes? "Delete #{path}?" do
        fun.()
      end
    else
      Mix.shell.error "Problem removing #{path}"
    end
    config
  end
  defp confirm(config, _path, fun) do
    fun.()
    config
  end

  ###############
  # configuration

  defp do_config({opts, parsed, unknown}) do
    opts
    |> verify_opts(parsed, unknown)
    |> Enum.into(%{})
    |> do_all_config
    |> do_default_config
  end

  defp do_all_config(%{all: true} = config) do
    Enum.reduce @remove_opts, config, &(Map.put_new(&2, &1, true))
  end
  defp do_all_config(config), do: config

  defp do_default_config(config) do
    Enum.reduce @default_opts, config, fn opt, config ->
      Map.put config, opt, Map.get(config, opt, true)
    end
  end

  defp verify_opts(opts, parsed, unknown) do

    verify_args!(parsed, unknown)

    switch_keys = Keyword.keys @switches

    case opts |> Keyword.keys |> Enum.filter(&(not &1 in switch_keys)) do
      [] -> opts
      list -> raise_option_errors(list)
    end
  end

  defp coh? do
    not File.exists?("web")
  end

  defp web_path(path) when is_binary(path), do: Path.join(web_path(), path)
  defp web_path(paths), do: Path.join([web_path() | paths])
  defp web_path do
    if coh?(), do: Path.join("lib", otp_app() <> "_web"), else: "web"
  end

  defp lib_path, do: Path.join("lib", otp_app())
  defp lib_path(path) when is_binary(path), do: Path.join(lib_path(), path)
  defp lib_path(paths), do: Path.join([lib_path() | paths])

  defp otp_app do
    Mix.Project.config[:app] |> to_string
  end
end