defmodule Tailwind do
  # see https://github.com/tailwindlabs/tailwindcss/releases
  @latest_version "3.0.7"

  @moduledoc """
  Tailwind is an installer and runner for [Tailwind CLI](https://tailwindcss.com/blog/standalone-cli).

  Think [esbuild](https://github.com/phoenixframework/esbuild) but for Tailwind,
  allowing you to scratch NodeJS from your toolchain entirely.

  ## Profiles

  You can define multiple `tailwind` profiles,
  each profile configures arguments, current directory and environment variables:

      config :tailwind,
        # Version is optional, latest version will automatically be used if not specified.
        version: "#{@latest_version}",
        default: [
          args: ~w(-i input.css -o output.css),
          cd: Path.expand("../assets", __DIR__),
          env: %{"SOME_VAR" => "some value"}
        ]

  ## Tailwind configuration
  There are two global configurations for the tailwind application:
    * `:version` - the expected tailwind cli version
    * `:path` - the path to find the tailwind cli executable at. By
      default, it is automatically downloaded and placed inside
      the `_build` directory of your current app

  Overriding the `:path` is not recommended, as we will automatically
  download and manage `tailwind` for you. But in case you can't download
  it (for example, you're behind a proxy), you may want to
  set the `:path` to a configurable system location.
  """

  use Application
  require Logger

  @doc false
  def start(_, _) do
    Supervisor.start_link([], strategy: :one_for_one)
  end

  @doc """
  Gets the latest version available for Tailwind CLI at the moment of publishing.
  """
  def latest_version, do: @latest_version

  @doc """
  Installs, if not available, and then runs `tailwind`.
  Returns the same as `run/2`.
  """
  def install_and_run(profile, args) do
    install()

    run(profile, args)
  end

  @doc """
  Runs the given command with `args`.
  The given args will be appended to the configured args.
  The task output will be streamed directly to stdio. It
  returns the status of the underlying call.
  """
  def run(profile, extra_args) when is_atom(profile) and is_list(extra_args) do
    config = config_for!(profile)
    args = config[:args] || []

    opts = [
      cd: config[:cd] || File.cwd!(),
      env: config[:env] || %{},
      into: IO.stream(:stdio, :line),
      stderr_to_stdout: true
    ]

    bin_path()
    |> System.cmd(args ++ extra_args, opts)
    |> elem(1)
  end

  @doc """
  Installs `tailwind` in your system,
  if `:force` is passed the install is always done regardless if the binary already exists.
  """
  def install(:force) do
    bin_path = bin_path()

    if File.exists?(bin_path) do
      File.rm!(bin_path)
    end

    Logger.info("Reinstalling Tailwind CLI v#{configured_version()}")
    install()
  end

  def install() do
    version = configured_version()
    bin_path = bin_path()

    unless File.exists?(bin_path) do
      url =
        "https://github.com/tailwindlabs/tailwindcss/releases/download/v#{version}/tailwindcss-#{target()}"

      binary = fetch_body!(url)

      File.mkdir_p!(Path.dirname(bin_path))
      File.write!(bin_path, binary, [:binary])
      File.chmod(bin_path, 0o755)
    end
  end

  # Get the configured version, defaults to the latest available version.
  defp configured_version, do: Application.get_env(:tailwind, :version, latest_version())

  # Gets the platform target (linux-64, macos-arm64, windows-x64.exe)
  defp target do
    case :os.type() do
      {:win32, _} ->
        "windows-#{:erlang.system_info(:wordsize) * 8}.exe"

      {:unix, osname} ->
        arch_str = :erlang.system_info(:system_architecture)
        [arch | _] = arch_str |> List.to_string() |> String.split("-")
        osname = case osname do
          :darwin ->
            :macos
          osname ->
            osname
        end

        case arch do
          "amd64" -> "#{osname}-x64"
          "x86_64" -> "#{osname}-x64"
          "aarch64" when osname == :macos -> "#{osname}-arm64"
          "arm" when osname == :macos -> "#{osname}-arm64"
          _ -> raise "esbuild is not available for architecture: #{arch_str}"
        end
    end
  end

  # copied from https://github.com/phoenixframework/esbuild/blob/main/lib/esbuild.ex
  defp fetch_body!(url) do
    url = String.to_charlist(url)
    Logger.debug("Downloading Tailwind CLI from #{url}")

    {:ok, _} = Application.ensure_all_started(:inets)
    {:ok, _} = Application.ensure_all_started(:ssl)

    if proxy = System.get_env("HTTP_PROXY") || System.get_env("http_proxy") do
      Logger.debug("Using HTTP_PROXY: #{proxy}")
      %{host: host, port: port} = URI.parse(proxy)
      :httpc.set_options([{:proxy, {{String.to_charlist(host), port}, []}}])
    end

    if proxy = System.get_env("HTTPS_PROXY") || System.get_env("https_proxy") do
      Logger.debug("Using HTTPS_PROXY: #{proxy}")
      %{host: host, port: port} = URI.parse(proxy)
      :httpc.set_options([{:https_proxy, {{String.to_charlist(host), port}, []}}])
    end

    # https://erlef.github.io/security-wg/secure_coding_and_deployment_hardening/inets
    cacertfile = CAStore.file_path() |> String.to_charlist()

    http_options = [
      ssl: [
        verify: :verify_peer,
        cacertfile: cacertfile,
        depth: 2,
        customize_hostname_check: [
          match_fun: :public_key.pkix_verify_hostname_match_fun(:https)
        ]
      ]
    ]

    options = [body_format: :binary]

    case :httpc.request(:get, {url, []}, http_options, options) do
      {:ok, {{_, 200, _}, _headers, body}} ->
        body

      other ->
        raise "couldn't fetch #{url}: #{inspect(other)}"
    end
  end

  @doc """
  Returns the path to the executable.
  The executable may not be available if it was not yet installed.
  """
  def bin_path do
    name = "tailwind-#{target()}"

    Application.get_env(:tailwind, :path) ||
      if Code.ensure_loaded?(Mix.Project) do
        Path.join(Path.dirname(Mix.Project.build_path()), name)
      else
        Path.expand("_build/#{name}")
      end
  end

  @doc """
  Returns the configuration for the given profile.
  Returns nil if the profile does not exist.
  """
  def config_for!(profile) when is_atom(profile) do
    Application.get_env(:tailwind, profile) ||
      raise ArgumentError, """
      unknown Tailwind profile. Make sure the profile is defined in your config/config.exs file, such as:
          config :tailwind,
            #{profile}: [
              args: ~w(build -i ./css/app.css -o=../priv/static/assets/app.css),
              cd: Path.expand("../assets", __DIR__)
            ]
      """
  end
end