defmodule Excon do
  @moduledoc """
  Pure Elixir identicon creator
  """

  @palettes {
    [{0, 153, 153}, {64, 179, 179}, {127, 204, 204}, {191, 229, 229}],
    [{0, 152, 102}, {64, 178, 140}, {127, 203, 178}, {191, 229, 217}],
    [{101, 44, 143}, {140, 97, 171}, {178, 149, 199}, {216, 202, 227}],
    [{255, 204, 51}, {255, 217, 102}, {255, 229, 153}, {255, 242, 204}],
    [{153, 153, 0}, {179, 179, 64}, {204, 204, 127}, {229, 229, 191}],
    [{102, 152, 0}, {140, 178, 64}, {178, 203, 127}, {217, 229, 191}],
    [{143, 44, 101}, {171, 97, 140}, {199, 149, 178}, {227, 202, 216}],
    [{51, 204, 255}, {102, 217, 255}, {153, 229, 255}, {204, 242, 255}],
    [{102, 0, 152}, {140, 64, 178}, {178, 127, 203}, {217, 191, 229}],
    [{255, 51, 204}, {255, 102, 217}, {255, 153, 229}, {255, 204, 242}],
    [{44, 101, 143}, {97, 140, 171}, {149, 178, 199}, {202, 216, 227}],
    [{153, 0, 153}, {179, 64, 179}, {204, 127, 204}, {229, 191, 229}],
    [{255, 128, 33}, {255, 169, 20}, {245, 197, 161}, {244, 210, 184}],
    [{250, 200, 250}, {220, 80, 220}, {230, 150, 230}, {240, 100, 240}],
    [{240, 192, 216}, {230, 168, 212}, {250, 217, 217}, {255, 210, 210}],
    [{112, 220, 113}, {183, 240, 183}, {152, 218, 150}, {218, 255, 222}]
  }

  defp mirror(thing, dir), do: do_mirror(thing, dir, [])
  defp do_mirror([], _, acc), do: acc |> Enum.reverse()

  defp do_mirror([r | rows], :ltr, acc),
    do: do_mirror(rows, :ltr, [r |> Enum.concat(r |> Enum.reverse()) | acc])

  defp do_mirror([r | rows], :rtl, acc),
    do: do_mirror(rows, :rtl, [r |> Enum.reverse() |> Enum.concat(r) | acc])

  defp do_mirror(rows, :ttb, _), do: rows |> Enum.concat(Enum.reverse(rows))
  defp do_mirror(rows, :btt, _), do: rows |> Enum.reverse() |> Enum.concat(rows)

  defp hashtopat(str), do: do_hashtopat(str, [])
  defp do_hashtopat(<<>>, acc), do: acc |> Enum.reverse() |> Enum.chunk_every(4)

  defp do_hashtopat(<<t::integer-size(2), rest::bitstring>>, acc),
    do: do_hashtopat(rest, [t | acc])

  defp magnify(thing, how_much) do
    thing
    |> expand_cols(how_much, [])
    |> expand_rows(how_much, [])
  end

  defp expand_cols([], _n, acc), do: acc |> Enum.reverse()
  defp expand_cols([r | rest], n, acc), do: expand_cols(rest, n, [expand_col(r, n, []) | acc])
  defp expand_col([], _n, acc), do: acc |> List.flatten() |> Enum.reverse()
  defp expand_col([c | rest], n, acc), do: expand_col(rest, n, [List.duplicate(c, n) | acc])

  defp expand_rows([], _n, acc), do: acc

  defp expand_rows([r | rest], n, acc),
    do: expand_rows(rest, n, Enum.concat(acc, expand_row(r, n, [])))

  defp expand_row(_i, 0, acc), do: acc
  defp expand_row(i, n, acc), do: expand_row(i, n - 1, [i | acc])

  defp to_png(pattern, mag, pdx) do
    {:ok, pid} = Agent.start(fn -> [] end)

    %{
      size: {8 * mag, 8 * mag},
      mode: {:indexed, 8},
      call: fn i -> Agent.update(pid, fn state -> [i | state] end) end,
      palette: computed_pal(pdx)
    }
    |> :png.create()
    |> png_append_pattern(pattern |> magnify(mag))
    |> :png.close()

    img_data = Agent.get(pid, fn state -> state end)
    Agent.stop(pid)

    img_data
    |> List.flatten()
    |> Enum.reverse()
    |> Enum.join()
  end

  defp computed_pal(<<pi::integer-size(4), _unused::integer-size(4)>>) do
    {:rgb, 8, @palettes |> elem(pi)}
  end

  defp png_append_pattern(png, []), do: png

  defp png_append_pattern(png, [r | rest]) do
    png
    |> :png.append({:row, :binary.list_to_bin(r)})
    |> png_append_pattern(rest)
  end

  defp parse_options(options) do
    {Keyword.get(options, :filename, nil), Keyword.get(options, :magnification, 4),
     Keyword.get(options, :type, :png), Keyword.get(options, :base64, false)}
  end

  @doc """
  Create an indenticon from an identifying string.

  Options
    - `type`: :png or :svg  (default: :png)
    - `filename`: a string for the file name (default: nil, image data is returned)
    - `magnification`: how many times to magnify the 8x8 pattern (default: 4)
    - `base64`: should output be base64 encoded (default: false, filename overrides)

  ## Examples

      iex> Excon.ident("ExCon", base64: true)
      "iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAMAAABEpIrGAAAADFBMVEXwwNjmqNT62dn/0tL9+OiNAAAAAklEQVR4nGKkkSsAAABBSURBVGNghAJmIGCCAhAbJs5ABwUwDkiCAQpAbJgmeiiAM4AA7jAggGmklwKYJCygkMVGkoKBjovBkiZhnAHKmwBcxQWBMC75hwAAAABJRU5ErkJggg=="

      iex> Excon.ident("ExCon", filename: "excon")
      :ok
  """
  def ident(id, opts \\ []) do
    {fname, mag, type, b64} = parse_options(opts)

    id
    |> Blake2.hash2b(5)
    |> ident(type, mag)
    |> output(fname, type, b64)
  end

  defp output(img, nil, _t, true), do: img |> Base.encode64()
  defp output(img, nil, _t, false), do: img

  defp output(img, filename, type, _b64),
    do: :ok = File.write(filename <> "." <> Atom.to_string(type), img)

  defp ident(<<forpat::binary-size(4), forpal::bitstring-size(8)>>, :png, mag) do
    forpat
    |> hashtopat
    |> mirror(:ltr)
    |> mirror(:ttb)
    |> to_png(mag, forpal)
  end

  defp ident(hash, :svg, mag) do
    <<cpo::integer-size(4), cpe::integer-size(4), fp::integer-size(2), c1::bitstring-size(6),
      c2::bitstring-size(6), c3::bitstring-size(6), c4::bitstring-size(6),
      fc::bitstring-size(6)>> = hash

    odds = elem(@palettes, cpo)
    evens = elem(@palettes, cpe)
    fg = elem(@palettes, fp)

    """
    <svg width="#{8 * mag}" height="#{8 * mag}" version="1.1" xmlns="http://www.w3.org/2000/svg">
    #{do_circle(2, 2, 2, c1, mag, odds)}
    #{do_circle(2, 6, 2, c2, mag, evens)}
    #{do_circle(6, 6, 2, c3, mag, odds)}
    #{do_circle(6, 2, 2, c4, mag, evens)}
    #{do_path(fc, mag, fg)}
    </svg>
    """
  end

  defp do_circle(x, y, r, c, mag, pal),
    do: "<circle cx=\"#{x * mag}\" cy=\"#{y * mag}\" r=\"#{r * mag}\" #{svg_fill(c, pal)}/>"

  defp do_path(
         <<ys::integer-size(1), yf::integer-size(1), x1::integer-size(1), y1::integer-size(1),
           x2::integer-size(1), y2::integer-size(1)>> = c,
         mag,
         pal
       ),
       do:
         "<path d=\"M0,#{(ys * 4 + 4) * mag}  C#{x1 * 8 * mag},#{y1 * -2 * mag} #{x2 * -2 * mag},#{
           y2 * 8 * mag
         } #{8 * mag},#{(yf * 4 + 4) * mag}\" #{svg_fill(c, pal, 0.375)}/>"

  defp svg_fill(<<w::integer-size(2), o::integer-size(4)>>, pal, opbase \\ 0.5) do
    "fill=\"rgba(#{pal |> Enum.fetch!(w) |> Tuple.to_list() |> Enum.join(",")},#{opbase + o / 32}\""
  end
end