materialize

defmodule Materialize.Components.Navbar do
  @moduledoc """

  Use module for generate HTML block navbar.



  Add alias in **/web/views/layout_view.ex** with configuration navbar:

  

  ```Elixir

  alias #{__MODULE__}



  def navbar(conn) do

    Navbar.get_html([

      [:wrap, [class: "nav-wrapper"], [class: "col s12"]],

      [:logo, class: "brand-logo"]

      [:ul, [

        [:a, "list 1", [href: "#1"]],

        [:a, "list 2", [href: "#2"]]

      ], [id: "id-link"]] 

    ])

  end

  ```



  Use navbar in templates:

  

  ```Elixir

  <div class="row"><%= navbar(@conn) %></div>

  ```



  Result



  ```Html

  <nav>

    <div class="nav-wrapper">

      <a href="#" class="brand-logo">Logo</a>

      <ul id="nav-mobile" class="right hide-on-med-and-down">

        <li><a href="#1">list 1</a></li>

        <li><a href="#2">list 2</a></li>

      </ul>

    </div>

  </nav>

  ```



  ### Default attributes



  All default attributes are overwritten by the custom



  #### Wrapper



  ```Elixir

  [class: "nav-wrapper"] # set class if not set for first wrapper

  ```



  If you need some wrappers

  

  ```Elixir

  [:wrap, [class: "nav-wrapper"], [class: "col s12"]]

  ```



  Result



  ```Html

  <nav>

    <div class="nav-wrapper"> <!--- wrapper 1 -->

      <div class="col s12">   <!--- wrapper 2 -->

        <!--- other elements --->

      </div>

    </div>

  </nav>

```



  #### Logo



  **Attributes**



  ```Elixir

  [href: "#", class: "brand-logo"] # if href or class not set

  ```



  **Name**



  ```Elixir

  "Logo" # if not set

  ```



  #### List (**ul** elements for menu)

  ```Elixir

  [id: "nav-mobile", class: "right hide-on-med-and-down"] # in not set class or id

  ``` 

  """

  alias Materialize.Html
  use Phoenix.HTML

  @wrap_options [class: "nav-wrapper"]
  @logo_options [href: "#", class: "brand-logo"]
  @logo_name "Logo"
  @list_options [id: "nav-mobile", class: "right hide-on-med-and-down"]

  # defstruct [wrapper: @wrapper_options, logo: @logo_options]


  @doc """

  Create tag **span** or etc.

  

  ### Parameters



    - options: keyword list



  ### Example



  ```Elixie

  #{__MODULE__}.get_html([

      [:wrap, [class: "nav-wrapper"], [class: "col s12"]],

      [:logo, class: "brand-logo"]

      [:ul, [

        [:a, "list 1", [href: "#1"]],

        [:a, "list 2", [href: "#2"]]

      ], [id: "id-link"]] 

    ])

  ```

  """
  @spec get_html(Keyword.t) :: {:safe, [String.t]}
  def get_html(opts) do
    {opts, wrap} = get_element(opts, :wrap)
    {opts, logo} = get_element(opts, :logo)
    wrap = prepare_wrapper(wrap)
    logo = content_logo([:a] ++ logo)

    list = for item <- opts do
      if (Enum.member?(item, :ul)) do
        {tag, content, attr} = parse_item(item, "", @list_options)
        content = get_item(tag, content, attr)
        content_tag(tag, content, attr)
      end
    end

    # result navbar block

    content_tag(:nav) do
      content = [logo] ++ list
      do_wrap(wrap, content)
    end
  end

  # apply all wrappers

  defp do_wrap(wrap, content) do
    wrapper = List.last(wrap)
    wrap = wrap -- [wrapper]

    if (length(wrap) > 0) do
      content = content_tag(:div, content, wrapper)
      do_wrap(wrap, content)
    else
      content_tag(:div, content, wrapper)
    end
  end 

  # prepare wrappers

  defp prepare_wrapper(wrap) do
    for item <- wrap do
      attr = get_attr(item)

      if (List.first(wrap) === item) do
        attr = Keyword.merge(@wrap_options, attr)
      end

      attr
    end
  end

  # get element: wrap or logo

  defp get_element(opts, member) do
    element = Enum.find(opts, [], fn(x) -> Enum.member?(x, member) end)
    {opts -- [element], element -- [member]}
  end

  # get link

  defp content_logo(logo) do
    {tag, content, attr} = parse_item(logo, @logo_name, @logo_options)
    content_tag(tag, content, attr)
  end

  # parse element and get tag, text and attribute

  defp parse_item(opts, default_text \\ "", default_attr \\ []) do
    {opts, tag} = get_tag(opts)
    {opts, content} = get_content(opts, default_text)
    attr = get_attr(opts, default_attr)

    {tag, content, attr}
  end

  # get tag

  defp get_tag(item) do
    error = "Element #{inspect(item)} has not tag"

    tag = with {:ok, tag} <- Enum.fetch(item, 0), true <- is_atom(tag) do
        tag
    else
      :error -> raise(ArgumentError, error)
      false -> raise(ArgumentError, error)
    end

    {item -- [tag], tag}
  end

  # teg text or default text

  defp get_content(item, default_text \\ "") do
    error = "Element #{inspect(item)} has not content"

    content = with {:ok, content} <- Enum.fetch(item, 0) do
        content
    else
      :error -> default_text
      false -> raise(ArgumentError, error)
    end

    {item -- [content], content}
  end

  # get attribute from [class: "example"] or {:class, "example"}

  defp get_attr(item, default_attr \\ []) do
    error = "Error get attributes in element #{inspect(item)}"

    # if attributes set as keyword

    attr = with {:ok, attr} <- Enum.fetch(item, 0), true <- is_list(attr) do
        attr
    # if attributes set as tuples

    else
      :error -> []
      false -> for el <- item, is_tuple(el), do: el
    end

    Keyword.merge(default_attr, attr)
  end

  # get one element, example <a>

  defp get_item(tag, content, attr) when is_binary(content) do
    content_tag(tag, content, attr)
  end

  # get list, example <ul>

  defp get_item(_, content, _) when is_list(content) do
    for item <- content do
      {tag, content, attr} = parse_item(item)
      content_tag(:li, get_item(tag, content, attr))
    end
  end
end