defmodule ElixirScript do
  require Logger

  @moduledoc """
  Translates Elixir into JavaScript.

  All compile functions return a list of
  transpiled javascript code or a tuple consisting of
  the file name for the code and the transpiled javascript code.

  All compile functions also take an optional opts parameter
  that controls transpiler output.

  Available options are:
  * `:include_path` - a boolean controlling whether to return just the JavaScript code
  or a tuple of the file name and the JavaScript code
  * `:core_path` - The es6 import path used to import the elixirscript core.
  When using this option, the Elixir.js file is not exported
  * `:full_build` - For compile_path, tells the compiler to perform a full build instead of incremental one
  * `:output` - option to tell compiler how to output data
      * `nil`: Return as list
      * `:stdout`: Write to standard out
      * `path (string)`: Write to specified path
  """

  defmacro __using__(_) do
    quote do
      import Kernel, except: [
        if: 2, unless: 2, abs: 1, apply: 2, apply: 3, binary_part: 3, hd: 1,
        tl: 1, is_atom: 1, is_binary: 1, is_bitstring: 1, is_boolean: 1, is_float: 1,
        is_function: 1, is_function: 2, is_integer: 1, is_list: 1, is_number: 1,
        is_pid: 1, is_tuple: 1, is_map: 1, is_port: 1, is_reference: 1, length: 1,
        map_size: 1, max: 2, min: 2, round: 1, trunc: 1, tuple_size: 1, elem: 2, is_nil: 1,
        make_ref: 1, spawn: 1, spawn: 3, spawn_link: 1, spawn_link: 3, spawn_monitor: 1,
        spawn_monitor: 3, send: 2, self: 0, match?: 2, to_string: 1, "|>": 2, in: 2, "..": 2,
        sigil_r: 2
      ]
      import ElixirScript.Kernel
      require JS
    end
  end

  # This is the serialized state of the ElixirScript.State module containing references to the standard library
  @lib_path Application.get_env(:elixir_script, :lib_path)
  @version  Mix.Project.config[:version]

  @doc """
  Compiles the given Elixir code string
  """
  @spec compile(binary, Map.t) :: [binary | {binary, binary} | :ok]
  def compile(elixir_code, opts \\ %{}) do
    elixir_code
    |> List.wrap
    |> Enum.map(fn(x) ->
      x
      |> Code.string_to_quoted!
      |> compile_quoted(opts)
    end)
    |> List.flatten
  end

  @doc """
  Compiles the given Elixir code in quoted form
  """
  @spec compile_quoted(Macro.t, Map.t) :: [binary | {binary, binary} | :ok]
  def compile_quoted(quoted, opts \\ %{}) do

    opts = build_compiler_options(opts)

    data = quoted
    |> get_modules_from_quoted
    |> Enum.map(fn(x) -> %{ast: x, app: :app} end)

    std_lib_quoted = get_quoted_std_lib()

    %{data: std_lib_quoted ++ data}
    |> ElixirScript.Passes.Init.execute(opts)
    |> shared_passes(opts)
  end

  defp shared_passes(compiler_data, opts) do
    compiler_data
    |> ElixirScript.Passes.FindModules.execute(opts)
    |> ElixirScript.Passes.FindLoadOnly.execute(opts)
    |> ElixirScript.Passes.HandleOverridables.execute(opts)
    |> ElixirScript.Passes.FindFunctions.execute(opts)
    |> ElixirScript.Passes.JavaScriptAST.execute(opts)
    |> ElixirScript.Passes.ConsolidateProtocols.execute(opts)
    |> ElixirScript.Passes.RemoveUnused.execute(opts)
    |> ElixirScript.Passes.CreateJSModules.execute(opts)
    |> ElixirScript.Passes.JavaScriptCode.execute(opts)
    |> ElixirScript.Passes.HandleOutput.execute(opts)
  end

  defp get_quoted_std_lib() do
    files = [get_std_lib_path(), "**", "*.ex"]
    |> Path.join
    |> Path.wildcard

    files
    |> Enum.map(fn path -> File.read!(path) end)
    |> Enum.map(&Code.string_to_quoted!(&1))
    |> Enum.flat_map(&get_modules_from_quoted(&1))
    |> Enum.map(fn(x) -> %{ast: x, app: :elixir} end)
  end

  defp get_modules_from_quoted(quoted) do
    results = case quoted do
                {:__block__, _, list} ->
                  {modules, not_modules} = Enum.partition(list,
                                                fn
                                                  {type, _, _ } when type in [:defprotocol, :defimpl, :defmodule] ->
                                                    true
                                                  _ ->
                                                    false
                                                end)

                  temp_module = case not_modules do
                                  [] ->
                                    []
                                  _ ->
                                    [{:defmodule, [], [{:__aliases__, [], [:ElixirScript, :Temp]}, [do: { :__block__, [], not_modules }]]}]
                                end

                  modules ++ temp_module

                {type, _, _ } = x when type in [:defprotocol, :defimpl, :defmodule] ->
                  x
                x ->
                  {:defmodule, [], [{:__aliases__, [], [:ElixirScript, :Temp]}, [do: { :__block__, [], [x] }]]}
              end

    List.wrap(results)
  end

  @doc """
  Compiles the elixir files found at the given path
  """
  @spec compile_path(binary | [binary] | map, Map.t) :: [binary | {binary, binary} | :ok]
  def compile_path(path, opts \\ %{})

  def compile_path(path, opts) when is_binary(path) do
    compile_path([path], opts)
  end

  def compile_path(path, opts) when is_list(path) do
    built_opts = build_compiler_options(opts)

    app_name = cond do
      !is_nil(built_opts[:app]) ->
        built_opts[:app]
      Code.ensure_loaded?(Mix) ->
        Mix.Project.config()[:app]
      true ->
        :app
    end

    compile_path(Map.put(%{}, app_name, path), opts)
  end

  def compile_path(path, opts) do
    opts = build_compiler_options(opts)

    deps = path
    |> Map.to_list
    |> Enum.map(fn {app, path} -> {app, List.wrap(path)} end)

    deps_wrapped = [{:elixir, List.wrap(get_std_lib_path())}] ++ deps

    result = %{data: deps_wrapped}
    |> ElixirScript.Passes.Init.execute(opts)
    |> ElixirScript.Passes.ASTFromFile.execute(opts)
    |> ElixirScript.Passes.LoadModules.execute(opts)
    |> shared_passes(opts)

    result
  end

  defp build_compiler_options(opts) do
    default_options = Map.new
    |> Map.put(:include_path, false)
    |> Map.put(:root, nil)
    |> Map.put(:env, __ENV__)
    |> Map.put(:import_standard_libs, true)
    |> Map.put(:core_path, "Elixir.Bootstrap")
    |> Map.put(:full_build, false)
    |> Map.put(:output, nil)
    |> Map.put(:app, :app)
    |> Map.put(:format, :es)
    |> Map.put(:js_modules, [])
    |> Map.put(:remove_unused, false)

    options = Map.merge(default_options, opts)
    Map.put(options, :module_formatter, get_module_formatter(options[:format]))
  end

  defp get_module_formatter(:umd) do
    ElixirScript.ModuleSystems.UMD
  end

  defp get_module_formatter(:common) do
    ElixirScript.ModuleSystems.Common
  end

  defp get_module_formatter(_) do
    ElixirScript.ModuleSystems.ES
  end

  @doc """
  Returns the contents of the bootrstrap js file
  """
  @spec get_bootstrap_js(string) :: string
  def get_bootstrap_js(module_format) do
    path = Path.join([operating_path, "build", to_string(module_format), "Elixir.Bootstrap.js"])
    File.read!(path)
  end

  #Gets path to js files whether the mix project is available
  #or when used as an escript
  defp operating_path() do
    case @lib_path do
      nil ->
        if Code.ensure_loaded?(Mix.Project) do
          Path.join([Mix.Project.build_path, "lib", "elixir_script", "priv"])
        else
          split_path = Path.split(Application.app_dir(:elixirscript))
          replaced_path = List.delete_at(split_path, length(split_path) - 1)
          replaced_path = List.delete_at(replaced_path, length(replaced_path) - 1)
          Path.join(replaced_path)
        end
      lib_path ->
        lib_path
    end
  end

  defp get_std_lib_path() do
    Path.join([operating_path(), "std_lib"])
  end

end