defmodule Drop do
  def fall_velocity(distance) do
    :math.sqrt(2 * 9.8 * distance)
  end
  
  def mps_to_mph(mps) do
   2.23693629 * mps
  end

  def mps_to_kph(mps) do
   3.6 * mps
  end
  
end

test "Sum of lists" do
   assert Hello.sum([]) == 0
   assert Hello.sum([2]) == 2
   assert Hello.sum([1, 2, 3, -1, -2, -3]) == 0
end

defmodule FizzBuzz do
  use Elmchemy

  import XList, only: [{:'range', 0},{:'map', 0}]
  @doc """
  Fizzes the buzzes and buzzfizzes the fizz out of buzz


      iex> import FizzBuzz
      iex> fizzbuzz.(1).(7)
      "1 2 Fizz 4 Buzz Fizz 7"


  """
  @spec fizzbuzz() :: (integer -> (integer -> String.t))
  @spec fizzbuzz(integer, integer) :: String.t
  curry fizzbuzz/2
  def fizzbuzz(from, to) do
    fizz_buzz = fn(n) -> case {rem(n, 3), rem(n, 5)} do
      {0, 0} -> "FizzBuzz"
      {0, _} -> "Fizz"
      {_, 0} -> "Buzz"
      _ -> to_string.(n)
    end end
    XList.range.(from).(to)
    |> (map.(fizz_buzz >>> to_string)).()
    |> (join_words).()
  end

  @spec join_words() :: (list(String.t) -> String.t)
  @spec join_words(list(String.t)) :: String.t
  defp join_words(list) do
    XString.join.(" ").(list)
  end

end

def example do
  item = {10, 2, {20, 30, []}}
  case item do
    {10, 2, {20, 30}, []} -> :ok
  end
end

example()
## -> ** (CaseClauseError) no case clause matching: {10, 2, {20, 30, []}}

defmodule Assignment6 do
  def main(_args) do
    IO.gets("Enter a name: ")
    |> cleanize
    |> input
    |> Enum.sort         # I cheated and use a merge sort after all input collected
    |> IO.inspect
  end

  @doc """
  An input name of "end" completes user input and returns an initialized blank input
  """
  def input("end") do
    []
  end

  @doc """
  Recursively inputs a name and adds to a list
  """
  def input(name) do
    n = IO.gets "Enter a name: "
    [name | n |> cleanize |> input]
  end

  @doc """
  Removes any trailing new line characters or spaces, then lower cases the name
  """
  def cleanize(s) do
    s
    |> String.trim_trailing
    |> String.downcase
  end

end

# in your app supervisor
:phx_dyn_dispatch = :ets.new(:phx_dyn_dispatch, [:named_table, :bag, :public])

defmodule DynamicDispatch do

  def register(group, plug, opts) do
    true = :ets.insert(:phx_dyn_dispatch, {group, plug, opts})
  end

  def unregister(group, plug) do
    true = :ets.match_delete(:phx_dyn_dispatch, {group, plug, :_})
  end

  def init(opts), do: opts

  def call(conn, group: group) do
    Enum.reduce_while(:ets.lookup(:phx_dyn_dispatch, group), conn, fn
      {_, _plug, _opts}, %Plug.Conn{halted: true} = acc -> {:halt, acc}
      {_, plug, opts}, %Plug.Conn{} = acc -> {:cont, plug.call(acc, opts)}
    end)
  end
end

# in your existing router
forward "/", DynamicDispatch, []


# register your router/plug at any time
DynamicDispatch.register(:app, MyOtherRouter, [])

defmodule Sort do
  import List
  import Enum

  def bubble_sort([]), do: []
  def bubble_sort(list), do: bubble_sort_(bubble(list))

  def bubble_sort_([]), do: []
  def bubble_sort_(list), do: bubble_sort(take(list, length(list)-1)) ++ [last list]

  def bubble([]), do: []
  def bubble([x]), do: [x]
  def bubble([x, y]), do: if x < y, do: [x, y], else: [y, x]
  def bubble([x | [y | tail]]) do
    if x < y, do: [x] ++ bubble([y] ++ tail), else: [y] ++ bubble([x] ++ tail)
  end
end

list = Enum.take_random(Enum.to_list(1..50), 50)
IO.inspect Sort.bubble_sort list

defmodule LoveLetter.Deck do

  def shuffle(deck) do
    new_deck = Enum.shuffle(deck)
    case deck == new_deck do
      true -> shuffle(deck)
      _    -> new_deck
    end
  end
end

defmodule LoveLetter.Game do
  alias LoveLetter.Player

  def deal(%{deck: deck, players: []}), do:
    %{deck: deck, players: []}

  def deal(%{deck: deck, players: player}) when is_tuple(player) do
    card = List.first(deck)
    deck = List.delete(deck, card)
    %{deck: deck, players: Player.add_card_to_hand(player, card)}
  end

  def deal(%{deck: deck, players: players = [player | tail]}) when is_list(players) do
    head_state = deal(%{deck: deck, players: player})
    tail_state = deal(%{deck: head_state[:deck], players: tail})

    %{
      deck: tail_state[:deck],
      players: [head_state[:players] | tail_state[:players]]
    }
  end

  def draw(%{player: player = {:player, hand}, deck: deck}) do
    %{deck: deck, players: [{:player, new_hand}]} =
      deal(%{deck: deck, players: [player]})
    {:player, List.delete(new_hand, Enum.min(new_hand))}
  end

end

defmodule LoveLetter.GameTest do
  use ExUnit.Case
  doctest LoveLetter.Game

  @deck [1, 1, 1, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6,  7, 8]

  test "dealing nothing results in nothing" do
    assert LoveLetter.Game.deal(%{deck: [], players: []})
      == %{deck: [], players: []}
  end

  test "dealing deck with one player, one player gets one card" do
    assert LoveLetter.Game.deal(%{deck: @deck, players: [{:player, []}]}) ==
      %{deck: List.delete_at(@deck, 0), players: [{:player, [1]}]}
  end

  test "multiple players deal multiple cards" do
    assert LoveLetter.Game.deal(%{deck: [1,2,3,4,5], players: [{:player, []}, {:player, []}]}) ==
        %{deck: [3,4,5], players: [{:player, [1]}, {:player, [2]}]}
  end

  test "shuffling decks" do
    assert LoveLetter.Deck.shuffle([1,2,3,4]) != [1,2,3,4]
  end


  test "dealing out cards realistically" do
    deck = LoveLetter.Deck.shuffle(@deck)
    state = %{deck: deck, players: [{:player, []}, {:player, []}]}
    %{deck: new_deck, players: players} = LoveLetter.Game.deal(state)
    assert length(deck) > length(new_deck)
    assert [1, 1] == Enum.map(players, fn({:player, hand}) -> length(hand) end)
  end

  test "Dealing & discarding second card" do
    deck = LoveLetter.Deck.shuffle(@deck)
    state = %{deck: deck, players: [{:player, []}, {:player, []}]}
    %{deck: deck, players: players} = LoveLetter.Game.deal(state)
    player = players |> Enum.shuffle |> List.first
    new_player = LoveLetter.Game.draw(%{deck: deck, player: player})
  end

end

defmodule LoveLetter.Player do
  def add_card_to_hand({:player, hand}, card) when is_list(hand), do:
    {:player, hand ++ [card]}

end

defmodule Blink do
  def blink() do
    for i <- 1..45 do
      IO.puts "Run time #{i}"
      # {_,{_, m, _}} = :os.timestamp |> :calendar.now_to_datetime # Using it to run every minute
      
      System.cmd("notify-send",["TODO","Blink"])
      Process.sleep(60000) # or we can use ":timer.sleep(60000)"
    end
    blink() # Calling itself
  end
end

# Run using the command given below
#  nohup elixir -r blinking.exs -e "Blink.blink" &

defmodule ZipList do
  defstruct previous: [], current: nil, remaining: []

  def from_list(list, index \\ 0)
  def from_list([], _), do: {:error, :empty_list}
  def from_list(list, index) when length(list) < index, do: {:error, :index_out_of_bounds}
  def from_list(list, index) when is_list(list) do
    previous = list |> Enum.take(index) |> Enum.reverse
    [current | remaining] = Enum.drop list, index
    ziplist = %__MODULE__{previous: previous, current: current, remaining: remaining}
    {:ok, ziplist}
  end

  def to_list(ziplist) do
    tail = [ziplist.current | ziplist.remaining]
    Enum.reverse ziplist.previous, tail
  end

  def previous?(%__MODULE__{previous: previous}), do: previous != []

  def remaining?(%__MODULE__{remaining: remaining}), do: remaining != []

  def advance(z = %__MODULE__{remaining: []}), do: z
  def advance(z = %__MODULE__{remaining: [remaining | rest]}) do
    %__MODULE__{previous: [z.current | z.previous], current: remaining, remaining: rest}
  end

  def retreat(z = %__MODULE__{previous: []}), do: z
  def retreat(z = %__MODULE__{previous: [previous | rest]}) do
    %__MODULE__{previous: rest, current: previous, remaining: [z.current | z.remaining]}
  end

  def current_index(ziplist) do
    Enum.count(ziplist.previous) + 1
  end
end

defimpl Enumerable, for: ZipList do
  def count(%ZipList{remaining: remaining, previous: previous}) do
    count = Enum.count(remaining) + Enum.count(previous) + 1
    {:ok, count}
  end
  def member?(%ZipList{previous: previous, current: current, remaining: remaining}, value) do
    result = current == value or Enum.member?(previous, value) or Enum.member?(remaining, value)
    {:ok, result}
  end
  def reduce(ziplist, acc, fun) do
    ziplist |> ZipList.to_list |> Enumerable.List.reduce(acc, fun)
  end
end

defimpl Collectable, for: ZipList do
  def into(ziplist) do
    {{ziplist, []}, fn
      {ziplist, values}, {:cont, item} -> {ziplist, [item | values]}
      {ziplist, values}, :done -> %ZipList{ziplist | remaining: ziplist.remaining ++ Enum.reverse(values)}
      _, :halt -> :ok
    end}
  end
end