require Logger

defmodule SecretsWatcherFileSystem.Backends.FSWindows do
  @moduledoc """
  File system backend for Windows.

  Need binary executable file packaged in to use this backend.

  This file is a fork from https://github.com/synrc/fs.

  ## Backend Options

    * `:recursive` (bool, default: true), monitor directories and their contents recursively

  ## Executable File Path

  Useful when running `:secrets_watcher_file_system` with escript.

  The default listener executable file is `priv/inotifywait.exe` within the
  folder of `:secrets_watcher_file_system` application.

  Two ways to customize the executable file path:

    * Module config with `config.exs`:

      ```elixir
      config :secrets_watcher_file_system, :fs_windows,
        executable_file: "YOUR_EXECUTABLE_FILE_PATH"`
      ```

    * System environment variable:

      ```
      export FILESYSTEM_FSWINDOWS_EXECUTABLE_FILE="YOUR_EXECUTABLE_FILE_PATH"`
      ```
  """

  use GenServer
  @behaviour SecretsWatcherFileSystem.Backend
  @sep_char <<1>>

  @default_exec_file "inotifywait.exe"

  def bootstrap do
    exec_file = executable_path()
    if not is_nil(exec_file) and File.exists?(exec_file) do
      :ok
    else
      Logger.error "Can't find executable `inotifywait.exe`"
      {:error, :fs_windows_bootstrap_error}
    end
  end

  def supported_systems do
    [{:win32, :nt}]
  end

  def known_events do
    [:created, :modified, :removed, :renamed, :undefined]
  end

  defp executable_path do
    executable_path(:system_env) || executable_path(:config) || executable_path(:system_path) || executable_path(:priv)
  end

  defp executable_path(:config) do
    Application.get_env(:secrets_watcher_file_system, :fs_windows)[:executable_file]
  end

  defp executable_path(:system_env) do
    System.get_env("FILESYSTEM_FSMWINDOWS_EXECUTABLE_FILE")
  end

  defp executable_path(:system_path) do
    System.find_executable(@default_exec_file)
  end

  defp executable_path(:priv) do
    case :code.priv_dir(:secrets_watcher_file_system) do
      {:error, _} ->
        Logger.error "`priv` dir for `:secrets_watcher_file_system` application is not avalible in current runtime, appoint executable file with `config.exs` or `FILESYSTEM_FSWINDOWS_EXECUTABLE_FILE` env."
        nil
      dir when is_list(dir) ->
        Path.join(dir, @default_exec_file)
    end
  end

  def parse_options(options) do
    case Keyword.pop(options, :dirs) do
      {nil, _} ->
        Logger.error "required argument `dirs` is missing"
        {:error, :missing_dirs_argument}
      {dirs, rest} ->
        format = ["%w", "%e", "%f"] |> Enum.join(@sep_char) |> to_charlist
        args = [
          '--format', format, '--quiet', '-m', '-r'
          | dirs |> Enum.map(&Path.absname/1) |> Enum.map(&to_charlist/1)
        ]
        parse_options(rest, args)
    end
  end

  defp parse_options([], result), do: {:ok, result}
  defp parse_options([{:recursive, true} | t], result) do
    parse_options(t, result)
  end
  defp parse_options([{:recursive, false} | t], result) do
    parse_options(t, result -- ['-r'])
  end
  defp parse_options([{:recursive, value} | t], result) do
    Logger.error "unknown value `#{inspect value}` for recursive, ignore"
    parse_options(t, result)
  end
  defp parse_options([h | t], result) do
    Logger.error "unknown option `#{inspect h}`, ignore"
    parse_options(t, result)
  end

  def start_link(args) do
    GenServer.start_link(__MODULE__, args, [])
  end

  def init(args) do
    {worker_pid, rest} = Keyword.pop(args, :worker_pid)
    case parse_options(rest) do
      {:ok, port_args} ->
        port = Port.open(
          {:spawn_executable, to_charlist(executable_path())},
          [:stream, :exit_status, {:line, 16384}, {:args, port_args}, {:cd, System.tmp_dir!()}]
        )
        Process.link(port)
        Process.flag(:trap_exit, true)
        {:ok, %{port: port, worker_pid: worker_pid}}
      {:error, _} ->
        :ignore
    end
  end

  def handle_info({port, {:data, {:eol, line}}}, %{port: port}=state) do
    {file_path, events} = line |> parse_line
    send(state.worker_pid, {:backend_file_event, self(), {file_path, events}})
    {:noreply, state}
  end

  def handle_info({port, {:exit_status, _}}, %{port: port}=state) do
    send(state.worker_pid, {:backend_file_event, self(), :stop})
    {:stop, :normal, state}
  end

  def handle_info({:EXIT, port, _reason}, %{port: port}=state) do
    send(state.worker_pid, {:backend_file_event, self(), :stop})
    {:stop, :normal, state}
  end

  def handle_info(_, state) do
    {:noreply, state}
  end

  def parse_line(line) do
    {path, flags} =
      case line |> to_string |> String.split(@sep_char, trim: true) do
        [dir, flags, file] -> {Enum.join([dir, file], "\\"), flags}
        [path, flags]      -> {path, flags}
      end
    {path |> Path.split() |> Path.join(), flags |> String.split(",") |> Enum.map(&convert_flag/1)}
  end

  defp convert_flag("CREATE"),   do: :created
  defp convert_flag("MODIFY"),   do: :modified
  defp convert_flag("DELETE"),   do: :removed
  defp convert_flag("MOVED_TO"), do: :renamed
  defp convert_flag(_),          do: :undefined
end