defmodule TailColors do
  @moduledoc """
  Helper functions for working with tailwind classes
  """
  @colors [
            "slate",
            "gray",
            "zinc",
            "neutral",
            "stone",
            "red",
            "orange",
            "amber",
            "yellow",
            "lime",
            "green",
            "emerald",
            "teal",
            "cyan",
            "sky",
            "blue",
            "indigo",
            "violet",
            "purple",
            "fuchsia",
            "pink",
            "rose"
          ] ++ (Application.compile_env(:tail_colors, :colors) || [])

  @tints [50, 100, 200, 300, 400, 500, 600, 700, 800, 900, 950]
  @themed_colors Application.compile_env(:tail_colors, :themed_colors) || %{}

  @doc ~S"""
  substitutes a themed color from config for the actual color name.
  """
  def theme(class_str) do
    Map.keys(@themed_colors)
    |> Enum.map(&Atom.to_string/1)
    |> Enum.reduce(class_str, fn item, new_str ->
      String.replace(new_str, item, Map.get(@themed_colors, String.to_atom(item)))
    end)
  end

  @doc ~S"""
  takes list of classNames and starting text, and finds first instance
  that matches with a known color and tint, a default value can also be set
  ## Examples
      iex> TailColors.get_color("thing text-red-400 something", "text")
      "text-red-400"

      iex> TailColors.get_color("thing bg-blue", "bg")
      "bg-blue"

      iex> TailColors.get_color("thing else", "bg")
      nil

      iex> TailColors.get_color("thing bg-monster else", "bg")
      nil

      iex> TailColors.get_color("thing bg-blue-404 else", "bg")
      nil

      iex> TailColors.get_color("thing else", "bg", "bg-blue-600")
      "bg-blue-600"
  """
  def get_color(classes, lookup, default \\ nil)

  def get_color(classes, p, d) when is_bitstring(classes), do: get_color(break(classes), p, d)

  def get_color(classes, prefix, default) when is_bitstring(prefix) do
    classes
    |> Enum.find(fn class -> String.starts_with?(class, prefix <> "-") end)
    |> color_tint(prefix)
    |> case do
      nil -> default
      match -> match
    end
  end

  @doc ~S"""
  takes list of classNames and prefix text or list of options, and finds first instance that matches,
  a default value can also be set

  ## Examples
      iex> TailColors.get("thing rounded something", "rounded")
      "rounded"

      iex> TailColors.get("thing rounded-xl something", "rounded")
      "rounded-xl"

      iex> TailColors.get("thing else", "rounded")
      nil

      iex> TailColors.get("thing else", "rounded", "rounded-md")
      "rounded-md"

      iex> TailColors.get("thing box else", ["circle", "rounded", "box"])
      "box"

      iex> TailColors.get("thing else", ["circle", "rounded", "box"])
      nil

      iex> TailColors.get("thing else", ["circle", "rounded", "box"], "rounded")
      "rounded"
  """

  def get(classes, lookup, default \\ nil)
  def get(classes, prefix, d) when is_bitstring(classes), do: get(break(classes), prefix, d)

  def get(classes, prefix, default) when is_bitstring(prefix) do
    if prefix in classes do
      prefix
    else
      case first_prefix(classes, prefix) do
        nil -> default
        match -> match
      end
    end
  end

  def get(classes, list, default) when is_list(list) do
    case common_items(classes, list) do
      nil -> default
      [h | _] -> h
    end
  end

  defp first_prefix(cl, prefix), do: Enum.find(cl, &String.starts_with?(&1, prefix <> "-"))

  @doc ~S"""
  takes a list of classNames and matches the first class with the prefix and returns the match or default values

  ## Examples
      iex> TailColors.get("thing text-red-400 something", "text", "blue", 600)
      "text-red-400"

      iex> TailColors.get("thing text-red something", "text", "blue", 600)
      "text-red-600"

      iex> TailColors.get("thing something", "text", "blue", 600)
      "text-blue-600"
  """

  def get(class_str, p, c, t)

  def get(class_str, p, c, t) when is_bitstring(class_str),
    do: get(break(class_str), p, c, t)

  def get(class_list, prefix, default_color, default_tint) do
    case get(class_list, prefix) do
      nil ->
        "#{prefix}-#{default_color}-#{default_tint}"

      match ->
        if int_ending?(match) do
          match
        else
          "#{match}-#{default_tint}"
        end
    end
  end

  defp color_tint(nil, _), do: nil

  defp color_tint(class, prefix) do
    cond do
      !is_color?(class, prefix) -> nil
      int_ending?(class) and !is_tint?(class) -> nil
      true -> class
    end
  end

  defp is_color?(class, prefix) do
    case String.split(class, "-") do
      [^prefix, color] -> color in @colors
      [^prefix, color, _] -> color in @colors
      _ -> false
    end
  end

  defp int_ending?(c), do: String.match?(c, ~r/.*-\d+/)

  defp is_tint?(class) do
    with [str | _] <- String.split(class, "-") |> Enum.reverse(),
         {int, _} <- Integer.parse(str) do
      int in @tints
    else
      _ -> false
    end
  end

  defp break(class_list), do: String.split(class_list, ~r/\s+/)

  @doc ~S"""
  takes a list of classNames and a string, and returns true if the string is in the list

  ## Examples
      iex> TailColors.has?("thing text-red-400 something", "something")
      true

      iex> TailColors.has?("thing bg-blue", "something")
      false
  """
  def has?(classes, str) when is_bitstring(classes),
    do: has?(break(classes), str)

  def has?(classes, str) when is_bitstring(str) do
    classes
    |> Enum.any?(&String.starts_with?(&1, str))
  end

  @doc ~S"""
  takes a list of classNames and finds any colors that appear that are not prefixed by a string followed by a -
  returns a tuple of {color, tint}

  ## Examples
      iex> TailColors.main_color("thing red something", "blue", 700)
      {"red", 700}

      iex> TailColors.main_color("thing red-400 something", "blue", 700)
      {"red", 400}

      iex> TailColors.main_color("thing something", "blue", 700)
      {"blue", 700}
  """
  def main_color(classes, c, t) when is_bitstring(classes), do: main_color(break(classes), c, t)

  def main_color(classes, default_color, default_tint) when is_list(classes) do
    case(common_items(classes, @colors)) do
      nil ->
        case with_tints(classes, default_tint) do
          nil -> {default_color, default_tint}
          tuple -> tuple
        end

      match ->
        color = match |> hd
        {color, default_tint}
    end
  end

  defp with_tints(classes, default_tint) do
    classes
    |> Enum.map(&parse_color_tint(&1, default_tint))
    |> Enum.find(fn
      {_color, nil} -> false
      {color, tint} -> color in @colors and tint in @tints
    end)
  end

  defp parse_color_tint(nil, _), do: nil

  defp parse_color_tint(class, default_tint) do
    class
    |> String.split("-")
    |> Enum.reverse()
    |> case do
      [h | []] ->
        {h, nil}

      [h | t] ->
        if str_to_int(h) in @tints do
          {t |> Enum.reverse() |> Enum.join("-"), String.to_integer(h)}
        else
          {[h | t] |> Enum.reverse() |> Enum.join("-"), default_tint}
        end
    end
  end

  defp str_to_int(str) do
    case Integer.parse(str) do
      {int, _} -> int
      _ -> nil
    end
  end

  defp common_items(l1, l2) do
    l3 = l1 -- l2

    (l1 -- l3)
    |> case do
      [] -> nil
      match -> match
    end
  end

  defp modify(class_str, mod_fun, args \\ []) do
    if is_tint?(class_str) do
      tint = get_tint(class_str)
      tint = apply(__MODULE__, mod_fun, [tint] ++ args)
      replace_tint(class_str, tint)
    else
      class_str
    end
  end

  defp replace_tint(c, tint) when is_integer(tint), do: replace_tint(c, Integer.to_string(tint))

  defp replace_tint(class_str, tint), do: Regex.replace(~r/-\d+$/, class_str, "-" <> tint)

  defp get_tint(str),
    do: str |> String.split("-") |> Enum.reverse() |> hd() |> String.to_integer()

  @doc ~S"""
  moves the tint down the list of tints.

  ## Examples
      iex> TailColors.darker(600, 1)
      700

      iex> TailColors.darker(600, 3)
      900

      iex> TailColors.darker(600, 9)
      950

      iex> TailColors.darker("text-green-400", 1)
      "text-green-500"

      iex> TailColors.darker("text-green-400", 9)
      "text-green-950"

      iex> TailColors.darker("not-a-tint", 1)
      "not-a-tint"
  """
  def darker(class_str, steps) when is_bitstring(class_str),
    do: modify(class_str, :darker, [steps])

  def darker(tint, steps), do: step(tint, steps)

  @doc ~S"""
  moves the tint up the list of tints.
  ## Examples
      iex> TailColors.lighter(600, 1)
      500

      iex> TailColors.lighter(600, 3)
      300

      iex> TailColors.lighter(600, 9)
      50

      iex> TailColors.lighter("text-green-400", 1)
      "text-green-300"

      iex> TailColors.lighter("text-green-400", 9)
      "text-green-50"

      iex> TailColors.lighter("not-a-tint", 1)
      "not-a-tint"
  """
  def lighter(class_str, steps) when is_bitstring(class_str),
    do: modify(class_str, :lighter, [steps])

  def lighter(tint, steps), do: step(tint, -1 * steps)

  defp step(tint, steps) when is_integer(tint) and is_integer(tint) do
    {_t, index} =
      Enum.with_index(@tints)
      |> Enum.find(fn {t, _i} -> t == tint end)

    cond do
      index + steps < 0 ->
        hd(@tints)

      true ->
        case Enum.fetch(@tints, index + steps) do
          {:ok, tint} -> tint
          :error -> List.last(@tints)
        end
    end
  end

  @doc ~S"""
  takes a list of classNames and a list of classes to remove, and then removes those classes if they appear in the classNames

  ## Examples
      iex> TailColors.clean("thing needle something", "needle")
      "thing something"
      iex> TailColors.clean("thing something", "needle")
      "thing something"
      iex> TailColors.clean("thing needle haystack something", "needle haystack")
      "thing something"
  """
  def clean(class_list, remove_list)
  def clean(cl, rl) when is_bitstring(cl), do: clean(break(cl), rl)
  def clean(cl, rl) when is_bitstring(rl), do: clean(cl, break(rl))

  def clean(class_list, remove_list) do
    (class_list -- remove_list) |> Enum.filter(& &1) |> Enum.join(" ")
  end

  @doc ~S"""
  takes a list of classNames and a list of classes to remove, and then removes those classes if they appear in the classNames

  ## Examples
      iex> TailColors.clean_prefix("thing bg-blue-500 something", "bg")
      "thing something"
      iex> TailColors.clean_prefix("thing something", "bg")
      "thing something"
      iex> TailColors.clean_prefix("thing bg-green-200 text-red-600 something", "bg text")
      "thing something"
  """
  def clean_prefix(class_list, remove_list)
  def clean_prefix(cl, rl) when is_bitstring(cl), do: clean_prefix(break(cl), rl)
  def clean_prefix(cl, rl) when is_bitstring(rl), do: clean_prefix(cl, break(rl))

  def clean_prefix(class_list, remove_list) do
    class_list
    |> Enum.filter(fn class ->
      !Enum.any?(remove_list, fn remove_class ->
        String.starts_with?(class, remove_class <> "-")
      end)
    end)
    |> Enum.join(" ")
  end

  @doc ~S"""
  takes a list of classNames and removes any colors that appear that do not follow the tailwind color struction prefix-color-tint
  #
  ## Examples
      iex> TailColors.clean_colors("thing blue something")
      "thing something"
      iex> TailColors.clean_colors("thing something")
      "thing something"
      iex> TailColors.clean_colors("thing blue red something")
      "thing something"
  """
  def clean_colors(class_list)
  def clean_colors(c) when is_bitstring(c), do: clean_colors(break(c))

  def clean_colors(class_list) do
    class_list
    |> Enum.filter(fn class ->
      !Enum.any?(@colors, fn color -> String.starts_with?(class, color <> "") end)
    end)
    |> Enum.join(" ")
  end

  @doc ~S"""
  takes a either a tint, or a color class, and returns a tint that is easier to read on that background
  #
  ## Examples
      iex> TailColors.invert(200)
      600
      iex> TailColors.invert("bg-blue-600")
      "bg-blue-50"
      iex> TailColors.invert(nil)
      nil
      iex> TailColors.invert("weirdo")
      "weirdo"
  """
  def invert(class_str)
  def invert(str) when is_bitstring(str), do: modify(str, :invert)
  def invert(nil), do: nil
  def invert(50), do: 400
  def invert(100), do: 500
  def invert(200), do: 600
  def invert(300), do: 700
  def invert(400), do: 50
  def invert(500), do: 50
  def invert(600), do: 50
  def invert(700), do: 100
  def invert(800), do: 100
  def invert(900), do: 200
  def invert(950), do: 300
end