# Doc
# https://hexdocs.pm/xml_builder/XmlBuilder.html#content

# Deps
{:xml_builder, "~> 2.0.0"}

# Raw in HTML
<%= emitter(@conn, @params["emitter"]) %>

# Helper Method
defp emitter(conn, params) do
  # Example
  # {:cfdiEmisor, %{id: 12345}, [{:first, nil, "Josh"}, {:last, nil, "Nussbaum"}]} |> XmlBuilder.generate

  emmiter = params
  |> Map.put(:Rfc, escape_value(conn.assigns.current_client.rfc))
  |> Map.put(:Nombre, escape_value(conn.assigns.current_client.business_name))

  IO.inspect emmiter
  IO.inspect node_fields(Bemus.CFDI.Emitter.changeset(%Bemus.CFDI.Emitter{}), params)
  # <cfdi:Emisor Rfc="<%= escape_value(@conn.assigns.current_client.rfc) %>" Nombre="<%= escape_value(@conn.assigns.current_client.business_name) %>" <%= node_fields(Bemus.CFDI.Emitter.changeset(%Bemus.CFDI.Emitter{}), @params) %> />
  {:cfdiEmisor, emmiter, []} |> XmlBuilder.generate
end

iex> Ecto.Adapters.SQL.query!(MyApp.Repo, "select 1")
%Postgrex.Result{
  columns: ["?column?"],
  command: :select,
  connection_id: 7250,
  num_rows: 1,
  rows: [[1]]
}

defmodule Logic do
  @spec boolean ~> boolean :: boolean
  def x ~> y do
    not x or y
  end
end

# Modo de usar:
# - Salvar como logic.ex
# - Na mesma pasta, chamar
# > iex logic.ex
# No iex:
# >
IO.puts(
'''
Para fazer teste no iex:
import Logic

p = true
q = false
r = true
p ~> (q and not r)

p = false
p ~> (q and not r)
'''
)

  @lpc {[:p, :q, :r], %{:nao => 1, :e => 2, :ou => 2, :implica => 2}}

  test "A fórmula :p é bem formada" do
    assert formula_bem_formada?(:p, @lpc)
  end

  test "A fórmula :s NÃO é bem formada" do
    refute formula_bem_formada?(:s, @lpc)
  end

  test "A fórmula 1 NÃO é bem formada" do
    refute formula_bem_formada?(1, @lpc)
  end

  test "A fórmula {:nao, :p}  é bem formada" do
    assert formula_bem_formada?({:nao, :p}, @lpc)
  end

  test "A fórmula {:oi, :p} NÃO é bem formada" do
    refute formula_bem_formada?({:oi, :p}, @lpc)
  end

  test "A fórmula {:p, :e, :q}  é bem formada" do
    assert formula_bem_formada?({:p, :e, :q}, @lpc)
  end

  test "A fórmula {:p, :ou, :q}  é bem formada" do
    assert formula_bem_formada?({:p, :ou, :q}, @lpc)
  end

  test "A fórmula {:p, :implica, :q}  é bem formada" do
    assert formula_bem_formada?({:p, :implica, :q}, @lpc)
  end

  test "A fórmula {:p1, :implica, :q} NÃO é bem formada" do
    refute formula_bem_formada?({:p1, :implica, :q}, @lpc)
  end

  test "A fórmula {:p, :implica, :q, :e, :r} NÃO é bem formada" do
    refute formula_bem_formada?({:p, :implica, :q, :e, :r}, @lpc)
  end

  test "A fórmula {:p, :implica, {:q, :e, :r}} é bem formada" do
    assert formula_bem_formada?({:p, :implica, {:q, :e, :r}}, @lpc)
  end

  test "A fórmula {:p, :implica, {:q, :e, {:nao, :r}}} é bem formada" do
    assert formula_bem_formada?({:p, :implica, {:q, :e, {:nao, :r}}}, @lpc)
  end

defmodule CaixaEletronico do
  def saque(valor,[nota]), do: [{nota,div(valor,nota)}]
  def saque(valor,[nota1, nota2]) do
     [{nota1,div(valor,nota1)},
      {nota2,div(rem(valor,nota1),nota2)},
   ]
  end
  def saque(valor,[nota_cabeca|resto_lista_notas]) do
    :erro
  end
end

defmodule CaixaeletronicoTest do
  use ExUnit.Case
  doctest CaixaEletronico

  test "calcula as notas para 200 reais" do
    assert CaixaEletronico.saque(200,[100])==[{100,2}]
  end

  test "calcula as notas para 100 reais" do
    assert CaixaEletronico.saque(100,[100])==[{100,1}]
  end

  test "calcula as notas para 100 reais em cédulas de 20" do
    assert CaixaEletronico.saque(100,[20])==[{20,5}]
  end

  test "calcula as notas para 150 reais em cédulas de 100 e 50" do
    assert CaixaEletronico.saque(150,[100,50])==[{100,1},{50,1}]
  end

  test "calcula as notas para 160 reais em cédulas de 100 e 20" do
    assert CaixaEletronico.saque(160,[100,20])==[{100,1},{20,3}]
  end

  test "calcula as notas para 170 reais em cédulas de 100, 50 e 10" do
    assert CaixaEletronico.saque(170,[100,50,10])==[{100,1},{50,1},{10,2}]
  end

  # test "calcula as notas para 288 reais" do
  #   assert CaixaEletronico.saque(288,[100,50,20,10,5,2,1])==[{100,2},{50,1},{20,1},{10,1},{5,1},{2,1},{1,1}]
  # end
end

# No arquivo de código
defmodule CaixaEletronico do
  def saque(_,_), do: nil
end

# No arquivo de testes
defmodule CaixaeletronicoTest do
  use ExUnit.Case
  doctest CaixaEletronico

  test "greets the world" do
    assert CaixaEletronico.saque(288,[100,50,20,10,5,2,1])==[{100,2},{50,1},{20,1},{10,1},{5,1},{2,1},{1,1}]
  end
end

defmodule Jokenpo do
  def joga(x,x), do: :empate
  def joga(:pedra,:tesoura), do: :pedra
  def joga(:pedra,:papel), do: :papel
  def joga(:tesoura,:papel), do: :tesoura
#  def joga(x,y), do: joga(y,x)
  def joga(:tesoura,:pedra), do: :pedra
  def joga(:papel,:pedra), do: :papel
  def joga(:papel,:tesoura), do: :tesoura
end

defmodule Funcoes do
  def fatorial(1), do: 1
  def fatorial(x), do: x*fatorial(x-1)

  def fibonacci(x) when x<=2, do: 1
  def fibonacci(x), do: fibonacci(x-2)+fibonacci(x-1)

  def fibo_fat(x), do: x |> fibonacci |> fatorial

  def identidade(x), do: x
  def inc(x), do: x+1
  def dec(x), do: x-1
end

defmodule PoesiaCompilada do
  def mexeu_com_uma(true), do: "Mexeu com todas!"
  def mexeu_com_uma(_), do: "Vamos nos empoderar mesmo assim!"

  def main() do
      entrada = IO.gets("Mexeu com uma? (S/N): ")
      IO.puts(mexeu_com_uma(String.upcase(entrada)=="S\n"))
  end
end

PoesiaCompilada.main()