defmodule SF.Repo.Migrations.CreateUsers do
  use Ecto.Migration

  def change do
    create table(:users, primary_key: false) do
      add :id, :binary_id, primary_key: true
      add :email, :string, null: false
      add :magic_token, :uuid
      add :confirmation_token, :uuid
      add :confirmed_at, :naive_datetime

      timestamps()
    end

    create index(:users, [:email], unique: true)
    create index(:users, [:magic_token], unique: true)
    create index(:users, [:confirmation_token], unique: true)
  end
end

defmodule SF.User do
  use Ecto.Schema
  import Ecto.Changeset

  @primary_key {:id, :binary_id, autogenerate: true}
  @foreign_key_type :binary_id
  schema "users" do
    field :email, :string
    field :magic_token, Ecto.Base64UUID
    field :confirmation_token, Ecto.Base64UUID
    field :confirmed_at, :naive_datetime

    timestamps()
  end

  @doc false
  def changeset(user, attrs) do
    user
    |> cast(attrs, [:email, :confirmation_token])
    |> validate_required([:email])
    |> unique_constraint(:email)
  end
end

create index(:users, ["(lower(email))"], unique: true)

defmodule SF.UserService do
  def find_by_email(email) do
    email = String.downcase(email)

    user =
      Repo.one(
        from u in User,
          where: fragment("lower(?)", u.email) == ^email
      )

    if user != nil, do: {:ok, user}, else: {:error, :not_found}
  end
end

# In this example we have a User and a Post entity.
defmodule User do
  defstruct id: nil, name: nil, admin: false
end

defmodule Post do
  defstruct user_id: nil, content: nil
end

# Followed by a protocol definition which allows you to define the rules on what
# is allowed and what is forbidden.

defimpl Canada.Can, for: User do
  def can?(%User{id: user_id}, action, %Post{user_id: user_id})
    when action in [:update, :read, :destroy, :touch], do: true

  def can?(%User{admin: admin}, action, _)
    when action in [:update, :read, :destroy, :touch], do: admin

  def can?(%User{}, :create, Post), do: true
end

# Finally, when we want to use this we just use the following syntax which reads
# very nicely.

import Canada, only: [can?: 2]

if some_user |> can? read(some_post) do
  # render the post
else
  # sorry (raise a 403)
end

# lib/canada.ex
defmodule Canada do
  defmacro can?(subject, {action, _, [argument]}) do
    quote do
      Canada.Can.can? unquote(subject), unquote(action), unquote(argument)
    end
  end
end

# lib/canada/can.ex
defprotocol Canada.Can do
  @doc "Evaluates permissions"
  def can?(subject, action, resource)
end

defmodule Postgrex.BinaryUtils do
  @moduledoc false

  defmacro int64 do
    quote do: signed-64
  end

  # ...

  defmacro uint16 do
    quote do: unsigned-16
  end

end

defmodule Postgrex.Messages do
  import Postgrex.BinaryUtils
  # ....
  def parse(<<type :: int32, rest :: binary>>, ?R, size) do
  # ....

  def parse(<<pid :: int32, key :: int32>>, ?K, _size) do
  # ....
end

defmodule Postgrex.ErrorCode do
  @external_resource errcodes_path = Path.join(__DIR__, "errcodes.txt")

  errcodes = for line <- File.stream!(errcodes_path),
             # ...

  # errcode duplication removal

  # defining a `code_to_name` function for every single error code which maps
  # the code to a name.
  for {code, errcodes} <- Enum.group_by(errcodes, &elem(&1, 0)) do
    [{^code, name}] = errcodes
    def code_to_name(unquote(code)), do: unquote(name)
  end
  def code_to_name(_), do: nil

end

defmodule Ecto.UUID do

  @doc """
  Casts to UUID.
  """
  @spec cast(t | raw | any) :: {:ok, t} | :error
  def cast(<< a1, a2, a3, a4, a5, a6, a7, a8, ?-,
              b1, b2, b3, b4, ?-,
              c1, c2, c3, c4, ?-,
              d1, d2, d3, d4, ?-,
              e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12 >>) do
    << c(a1), c(a2), c(a3), c(a4),
       c(a5), c(a6), c(a7), c(a8), ?-,
       c(b1), c(b2), c(b3), c(b4), ?-,
       c(c1), c(c2), c(c3), c(c4), ?-,
       c(d1), c(d2), c(d3), c(d4), ?-,
       c(e1), c(e2), c(e3), c(e4),
       c(e5), c(e6), c(e7), c(e8),
       c(e9), c(e10), c(e11), c(e12) >>
  catch
    :error -> :error
  else
    casted -> {:ok, casted}
  end
  def cast(<< _::128 >> = binary), do: encode(binary)
  def cast(_), do: :error

  @compile {:inline, c: 1}

  defp c(?0), do: ?0
  defp c(?1), do: ?1
  defp c(?2), do: ?2
  defp c(?3), do: ?3
  defp c(?4), do: ?4
  defp c(?5), do: ?5
  defp c(?6), do: ?6
  defp c(?7), do: ?7
  defp c(?8), do: ?8
  defp c(?9), do: ?9
  defp c(?A), do: ?a
  defp c(?B), do: ?b
  defp c(?C), do: ?c
  defp c(?D), do: ?d
  defp c(?E), do: ?e
  defp c(?F), do: ?f
  defp c(?a), do: ?a
  defp c(?b), do: ?b
  defp c(?c), do: ?c
  defp c(?d), do: ?d
  defp c(?e), do: ?e
  defp c(?f), do: ?f
  defp c(_),  do: throw(:error)

end

defmodule User do
  def authorized?(%User{} = user) do
    # ....
  end
end

with {:parse, {:ok, user_attrs}} <- {:parse, Jason.parse(body)},
     {:persist, {:ok, user}} <- {:persist, Users.create(user_attrs)},
     {:welcome_email, :ok} <- {:welcome_email, Emailer.welcome(user)} do
     :ok
else
  {:parse, err} ->
    # raise an error
    {:error, :parse_error}
  {:persist, {:error, changeset}} ->
    # return validation errors
    {:error, changeset}
  {:welcome_email, err} ->
    # it is ok if email sending failed, we just log this
    Logger.error("SENDING_WELCOME_EMAIL_FAILED")
    :ok
end

defmodule API do
  defdelegate create_customer(customer_json), to: API.CustomerCreator
end

defmodule API.CustomerCreator do
  def create_customer(customer_json) do
    # ...
  end
end

defmodule User do
  @enforce_keys [:email, :name]
  defstruct [:email, :name]
end

defmodule HTTPClient do
  @timeout 60_000
  @doc """
  Times out after #{@timeout} seconds
  """
  def get(url) do
  end
end

ExUnit.start

defmodule HTTPTest do
  use ExUnit.Case
  require Logger

  @moduletag :capture_log

  test "suppress logs" do
    Logger.info "AAAAAAAAAAAAAAAAAAAHHHHHHHHH"
  end
end

defmodule Day5 do
  def scan(polymer) do
    chars =
      polymer
      |> String.to_charlist()

    res =
      chars
      |> Enum.reduce({:none, []}, fn
        c, {:none, acc} ->
          {:prev, c, acc}

        c, {:prev, prev, acc} ->
          if react?(c, prev) do
            {:none, acc}
          else
            {:prev, c, [prev | acc]}
          end
      end)

    reduced_polymer =
      case res do
        {_, acc} -> acc
        {:prev, c, acc} -> [c | acc]
      end
      |> Enum.reverse()
      |> to_string

    if reduced_polymer == polymer do
      polymer
    else
      scan(reduced_polymer)
    end
  end

  def react?(c1, c2), do: abs(c1 - c2) == 32

  @all_units Enum.zip(?a..?z, ?A..?Z) |> Enum.map(fn {c1, c2} -> ~r[#{[c1]}|#{[c2]}] end)
  def smallest(polymer) do
    @all_units
    |> Enum.map(fn unit_to_be_removed ->
      polymer
      |> String.replace(unit_to_be_removed, "")
      |> scan
      |> String.length()
    end)
    |> Enum.min()
  end
end

defmodule Day5Test do
  use ExUnit.Case

  import Day5

  test "reduces 2 reacting units" do
    assert scan("aA") == ""
  end

  test "reduces 2 non reacting units" do
    assert scan("aB") == "aB"
    assert scan("Ba") == "Ba"
  end

  test "reduces 3 non reacting units" do
    assert scan("aBc") == "aBc"
    assert scan("aBA") == "aBA"
    assert scan("BaD") == "BaD"
  end

  test "reduces 3 reacting units" do
    assert scan("aAB") == "B"
    assert scan("abB") == "a"
    assert scan("aBb") == "a"
    assert scan("BaA") == "B"
  end

  test "reduces recursively" do
    assert scan("baAB") == ""
  end

  test "large polymer" do
    assert scan("dabAcCaCBAcCcaDA") == "dabCBAcaDA"
    assert scan("abcdDCBA") == ""
  end

  test "input" do
    assert File.read!("./input.txt") |> String.trim() |> scan |> String.length() == 0
  end

  test "smallest" do
    assert smallest("dabAcCaCBAcCcaDA") == 4
  end

  test "smallest for input" do
    assert File.read!("./input.txt") |> String.trim() |> smallest == 0
  end
end

defmodule Day4 do
  defmodule State do
    defstruct [:guard_id, :start, :sleep]
  end

  defp desc_minutes({_k, ranges}) do
    ranges
    |> Enum.reduce(0, fn x, sum ->
      sum + Enum.count(x)
    end)
    |> Kernel.*(-1)
  end

  def find_sleep_constant(spec) do
    {guard, sleep_durations} =
      spec
      |> parse
      |> Enum.sort_by(&desc_minutes/1)
      |> hd

    guard * most_sleepy_minute(sleep_durations)
  end

  def sleepiest_guard_minute(spec) do
    {guard_id, {min, _count}} =
      spec
      |> parse # => %{ guard_id => [min_start1..min_end1] }
      |> Enum.map(fn {guard_id, durations} ->
        {min, occurences} =
          durations
          |> Enum.flat_map(&Enum.to_list/1)
          |> Enum.group_by(& &1)
          |> Enum.max_by(fn {_min, occurences} -> Enum.count(occurences) end)

        {guard_id, {min, length(occurences)}}
      end)
      |> Enum.max_by(fn {_guard_id, {_min, count}} -> count end)
    {guard_id, min}
  end

  def most_sleepy_minute(sleep_durations) do
    {minute, _} =
      sleep_durations
      |> Enum.flat_map(&Enum.to_list/1)
      |> Enum.group_by(& &1)
      |> Enum.sort_by(fn {_k, v} -> -1 * Enum.count(v) end)
      |> hd

    minute
  end

  def parse(spec) do
    {_state, logs} =
      spec
      |> String.split("\n", trim: true)
      |> Enum.sort()
      |> Enum.map(&parse_line/1)
      |> Enum.reduce({_state = %State{}, _out = %{}}, fn x, {state, out} ->
        case x do
          {:start, guard_id, _minutes} ->
            {%{state | guard_id: guard_id}, out}

          {:sleep, minutes} ->
            {%{state | start: minutes}, out}

          {:wake, minutes} ->
            prev_sleep = out[state.guard_id] || []
            {state, Map.put(out, state.guard_id, [state.start..(minutes - 1) | prev_sleep])}
        end
      end)

    logs
  end

  def parse_line(line) do
    <<"[", _year::32, "-", _month::16, "-", _day::16, " ", _hour::16, ":",
      minutes_bin::binary-size(2), "] ", note::binary>> = line

    parse_note(note, String.to_integer(minutes_bin))
  end

  def parse_note("wakes up", minutes) do
    {:wake, minutes}
  end

  def parse_note("falls asleep", minutes) do
    {:sleep, minutes}
  end

  def parse_note(begin_note, minutes) do
    guard_id =
      Regex.named_captures(~r[Guard #(?<guard_id>\d+) begins shift], begin_note)
      |> Map.get("guard_id")
      |> String.to_integer()

    {:start, guard_id, minutes}
  end
end

defmodule Day4Test do
  use ExUnit.Case

  import Day4

  test "parses the times when each guard sleeps" do
    assert parse("""
           [1518-11-01 00:00] Guard #10 begins shift
           [1518-11-01 00:05] falls asleep
           [1518-11-01 00:25] wakes up
           [1518-11-01 00:30] falls asleep
           [1518-11-01 00:55] wakes up
           [1518-11-01 23:58] Guard #99 begins shift
           [1518-11-02 00:40] falls asleep
           [1518-11-02 00:50] wakes up
           [1518-11-03 00:05] Guard #10 begins shift
           [1518-11-03 00:24] falls asleep
           [1518-11-03 00:29] wakes up
           [1518-11-04 00:02] Guard #99 begins shift
           [1518-11-04 00:36] falls asleep
           [1518-11-04 00:46] wakes up
           [1518-11-05 00:03] Guard #99 begins shift
           [1518-11-05 00:45] falls asleep
           [1518-11-05 00:55] wakes up
           [1518-11-08 00:03] Guard #99334 begins shift
           [1518-11-08 00:45] falls asleep
           [1518-11-08 00:55] wakes up
           """) == %{
             10 => [5..24, 30..54, 24..28] |> Enum.reverse(),
             99 => [40..49, 36..45, 45..54] |> Enum.reverse(),
             99334 => [45..54]
           }
  end

  test "find_sleep_constant" do
    assert find_sleep_constant("""
           [1518-11-01 00:00] Guard #10 begins shift
           [1518-11-01 00:05] falls asleep
           [1518-11-01 00:25] wakes up
           [1518-11-01 00:30] falls asleep
           [1518-11-01 00:55] wakes up
           [1518-11-01 23:58] Guard #99 begins shift
           [1518-11-02 00:40] falls asleep
           [1518-11-02 00:50] wakes up
           [1518-11-03 00:05] Guard #10 begins shift
           [1518-11-03 00:24] falls asleep
           [1518-11-03 00:29] wakes up
           [1518-11-04 00:02] Guard #99 begins shift
           [1518-11-04 00:36] falls asleep
           [1518-11-04 00:46] wakes up
           [1518-11-05 00:03] Guard #99 begins shift
           [1518-11-05 00:45] falls asleep
           [1518-11-05 00:55] wakes up
           """) == 240
  end

  test "parses line" do
    assert parse_line("[1518-11-01 00:08] wakes up") == {:wake, 8}
    assert parse_line("[1518-11-01 00:30] falls asleep") == {:sleep, 30}
    assert parse_line("[1518-11-01 00:23] Guard #10 begins shift") == {:start, 10, 23}
    assert parse_line("[1518-11-01 00:23] Guard #99 begins shift") == {:start, 99, 23}
  end

  test "file" do
    assert 240 ==
             find_sleep_constant("""
             [1518-11-01 00:00] Guard #10 begins shift
             [1518-11-01 00:05] falls asleep
             [1518-11-01 00:25] wakes up
             [1518-11-01 00:30] falls asleep
             [1518-11-01 00:55] wakes up
             [1518-11-01 23:58] Guard #99 begins shift
             [1518-11-02 00:40] falls asleep
             [1518-11-02 00:50] wakes up
             [1518-11-03 00:05] Guard #10 begins shift
             [1518-11-03 00:24] falls asleep
             [1518-11-03 00:29] wakes up
             [1518-11-04 00:02] Guard #99 begins shift
             [1518-11-04 00:36] falls asleep
             [1518-11-04 00:46] wakes up
             [1518-11-05 00:03] Guard #99 begins shift
             [1518-11-05 00:45] falls asleep
             [1518-11-05 00:55] wakes up
             """)

    assert File.read!("./input.txt")
           |> find_sleep_constant == 30630
  end

  test "sleepiest_guard_minute" do
    assert {99, 45} ==
             sleepiest_guard_minute("""
             [1518-11-01 00:00] Guard #10 begins shift
             [1518-11-01 00:05] falls asleep
             [1518-11-01 00:25] wakes up
             [1518-11-01 00:30] falls asleep
             [1518-11-01 00:55] wakes up
             [1518-11-01 23:58] Guard #99 begins shift
             [1518-11-02 00:40] falls asleep
             [1518-11-02 00:50] wakes up
             [1518-11-03 00:05] Guard #10 begins shift
             [1518-11-03 00:24] falls asleep
             [1518-11-03 00:29] wakes up
             [1518-11-04 00:02] Guard #99 begins shift
             [1518-11-04 00:36] falls asleep
             [1518-11-04 00:46] wakes up
             [1518-11-05 00:03] Guard #99 begins shift
             [1518-11-05 00:45] falls asleep
             [1518-11-05 00:55] wakes up
             """)

    assert {guard, min} =
             File.read!("./input.txt")
             |> sleepiest_guard_minute

    assert guard * min == 99
  end
end

defmodule Rect do
  defstruct [:id, :left, :top, :width, :height]

  alias __MODULE__

  def parse(spec) do
    [id, dimensions] = String.split(spec, "@", trim: true)
    [coords, size] = String.split(dimensions, ":", trim: true)

    [left, top] = String.split(coords, ",", trim: true) |> Enum.map(&parse_number/1)

    [width, height] = String.split(size, "x", trim: true) |> Enum.map(&parse_number/1)

    %Rect{
      id: String.trim(id),
      left: left,
      top: top,
      width: width,
      height: height
    }
  end

  defp parse_number(str), do: str |> String.trim() |> String.to_integer()

  def order_horizontal(r1, r2) do
    if r1.left < r2.left do
      {r1, r2}
    else
      {r2, r1}
    end
  end

  def order_vertical(r1, r2) do
    if r1.top < r2.top do
      {r1, r2}
    else
      {r2, r1}
    end
  end

  def squares(%Rect{width: w, height: h}) when w <= 0 or h <= 0, do: []

  def squares(%Rect{} = r) do
    for x <- r.left..(r.left + r.width - 1), y <- r.top..(r.top + r.height - 1), do: {x, y}
  end
end

defmodule Overlap do
  def area(spec) when is_binary(spec) do
    spec
    |> String.split("\n", trim: true)
    |> Enum.map(&Rect.parse/1)
    |> area
  end

  def area(rects, prev_squares \\ [])

  def area([h | tl], prev_squares) do
    squares =
      tl
      |> Enum.map(fn x -> overlap(h, x) |> Rect.squares() end)

    area(tl, [squares | prev_squares])
  end

  def area([], squares),
    do:
      squares
      |> List.flatten()
      |> Enum.uniq()
      |> Enum.count()

  def find_non_overlap(spec) when is_binary(spec) do
    rects =
      spec
      |> String.split("\n", trim: true)
      |> Enum.map(&Rect.parse/1)

    find_non_overlap(rects, rects)
  end

  def find_non_overlap([h | tl], all_rects) do
    if all_rects
       |> Enum.filter(fn x -> x.id != h.id end)
       |> Enum.all?(fn x ->
         o = overlap(h, x)
         o.width <= 0 || o.height <= 0
       end) do
      h
    else
      find_non_overlap(tl, all_rects)
    end
  end

  def find_non_overlap([], _), do: raise("Not found")

  def overlap(%Rect{} = r1, %Rect{} = r2) do
    {l, r} = Rect.order_horizontal(r1, r2)

    width = min(l.left + l.width - r.left, r.width)

    {t, b} = Rect.order_vertical(r1, r2)

    height = min(t.top + t.height - b.top, b.height)

    %Rect{
      left: r.left,
      top: b.top,
      width: width,
      height: height
    }
  end
end

defmodule OverlapTest do
  use ExUnit.Case

  import Overlap

  test "greets the world" do
    assert area("""
           # 1 @ 1,3: 4x4
           # 2 @ 3,1: 4x4
           # 3 @ 5,5: 2x2
           """) == 4

    assert area("""
           # 1 @ 1,3: 4x4
           # 2 @ 3,1: 4x4
           # 3 @ 1,3: 4x4
           """) == 16

    assert File.read!("input.txt") |> area == 0
  end

  test "overlap between 2 rects" do
    assert overlap(
             %Rect{id: "# 1", left: 1, top: 3, width: 4, height: 8},
             %Rect{id: "# 2", left: 3, top: 1, width: 4, height: 4}
           ) == %Rect{id: nil, left: 3, top: 3, width: 2, height: 2}

    assert overlap(
             %Rect{id: "# 1", left: 1, top: 3, width: 4, height: 4},
             %Rect{id: "# 3", left: 5, top: 5, width: 2, height: 2}
           ) == %Rect{height: 2, id: nil, left: 5, top: 5, width: 0}
  end

  test "find_non_overlap" do
    assert find_non_overlap("""
           # 1 @ 1,3: 4x4
           # 2 @ 3,1: 4x4
           # 3 @ 5,5: 2x2
           """).id == "# 3"

    assert File.read!("input.txt") |> find_non_overlap == 0
  end
end

defmodule RectTest do
  use ExUnit.Case

  test "parse" do
    assert Rect.parse("# 1 @ 1,3: 4x3") == %Rect{id: "# 1", left: 1, top: 3, width: 4, height: 3}
  end

  test "order_horizontal" do
    {%{id: "# 1"}, %{id: "# 2"}} =
      Rect.order_horizontal(
        %Rect{id: "# 1", left: 1, top: 3, width: 4, height: 3},
        %Rect{id: "# 2", left: 3, top: 3, width: 4, height: 3}
      )

    {%{id: "# 4"}, %{id: "# 3"}} =
      Rect.order_horizontal(
        %Rect{id: "# 3", left: 10, top: 3, width: 4, height: 3},
        %Rect{id: "# 4", left: 3, top: 3, width: 4, height: 3}
      )
  end

  test "order_vertical" do
    {%{id: "# 1"}, %{id: "# 2"}} =
      Rect.order_vertical(
        %Rect{id: "# 1", left: 1, top: 1, width: 4, height: 1},
        %Rect{id: "# 2", left: 3, top: 3, width: 4, height: 3}
      )

    {%{id: "# 4"}, %{id: "# 3"}} =
      Rect.order_vertical(
        %Rect{id: "# 3", left: 10, top: 10, width: 4, height: 10},
        %Rect{id: "# 4", left: 3, top: 3, width: 4, height: 3}
      )
  end

  test "squares" do
    assert Rect.squares(%Rect{id: "# 1", left: 1, top: 3, width: 2, height: 2}) == [
             {1, 3},
             {1, 4},
             {2, 3},
             {2, 4}
           ]

    assert Rect.squares(%Rect{id: "# 1", left: 1, top: 3, width: 0, height: 0}) == []
    assert Rect.squares(%Rect{id: "# 1", left: 1, top: 3, width: 0, height: 4}) == []
    assert Rect.squares(%Rect{id: "# 1", left: 1, top: 3, width: 4, height: 0}) == []
    assert Rect.squares(%Rect{id: "# 1", left: 1, top: 3, width: 4, height: -4}) == []
    assert Rect.squares(%Rect{id: "# 1", left: 1, top: 3, width: -4, height: 4}) == []
  end
end

#! /usr/bin/env elixir

defmodule Day2 do
  def checksum(ids) do
    {two_count, three_count} =
      ids
      |> String.split("\n", trim: true)
      |> Enum.reduce({0, 0}, fn id, {two_count, three_count} ->
        char_counts =
          id
          |> String.graphemes()
          |> Enum.group_by(& &1)
          |> Enum.map(fn {_c, vals} -> Enum.count(vals) end)
          |> Enum.uniq()

        {incr_if_count(char_counts, two_count, 2), incr_if_count(char_counts, three_count, 3)}
      end)

    two_count * three_count
  end

  defp incr_if_count(counts, prev_count, matcher) do
    if matcher in counts do
      prev_count + 1
    else
      prev_count
    end
  end

  def find_common_boxes(ids) do
    ids =
      ids
      |> String.split("\n", trim: true)
      |> Enum.map(&String.graphemes/1)

    {lhs, rhs} = find_similar(ids)


    intersection(lhs, rhs)
  end

  defp intersection(lhs, rhs) do
    Enum.zip(lhs, rhs)
    |> Enum.map(fn {l, l} -> l; _ -> nil end)
    |> Enum.filter(& &1)
    |> Enum.join
  end

  defp find_similar([lhs_id | ids]) do
    matching_id =
      Enum.find(ids, fn rhs_id ->
        diff_count(lhs_id, rhs_id) == 1
      end)

    if matching_id do
      {lhs_id, matching_id}
    else
      find_similar(ids)
    end
  end

  defp diff_count(lhs, rhs) do
    Enum.zip(lhs, rhs)
    |> Enum.map(fn
      {x, x} -> 0
      _ -> 1
    end)
    |> Enum.sum()
  end
end

ExUnit.start()

defmodule Day2Test do
  use ExUnit.Case

  import Day2

  test "#checksum" do
    assert checksum("""
           abcdef
           bababc
           abbcde
           abcccd
           aabcdd
           abcdee
           ababab
           """) == 12

    assert File.read!("input.txt") |> checksum == 4693
  end

  test "#find_common_boxes" do
    assert find_common_boxes("""
           abcde
           fghij
           klmno
           pqrst
           fguij
           axcye
           wvxyz
           """) == "fgij"

    assert File.read!("input.txt") |> find_common_boxes == "pebjqsalrdnckzfihvtxysomg"
  end
end

#!/usr/bin/env elixir
# run it as follows:
# $ ./elixir.exs < input.txt
# 484

# read each line
IO.stream(:stdio, :line)
|> Stream.map(fn str ->
  {n, ""} = str |> String.trim() |> Integer.parse()
  n
end)
|> Enum.sum()
|> IO.puts()

defmodule ChronalCalibration do

  def part_2(input, start_freq \\ 0, prev_freqs \\ %{0 => true}) do
    res =
      input
      |> String.split("\n")
      |> Enum.reduce_while({start_freq, prev_freqs}, fn x, {freq, prev_freqs} ->
        {i, ""} = Integer.parse(x)
        freq = i + freq

        if prev_freqs[freq] do
          {:halt, {:succ, freq}}
        else
          {:cont, {freq, Map.put(prev_freqs, freq, true)}}
        end
      end)

    case res do
      {:succ, freq} -> freq
      {freq, prev_freqs} -> part_2(input, freq, prev_freqs)
    end
  end

end

IO.puts File.read!("input.txt") |> ChronalCalibration.part_2

defmodule BodyReader do

  def read_body(conn, opts) do
    # read the body from the connection
    {:ok, body, conn} = Plug.Conn.read_body(conn, opts)

    # compute our md5 hash
    md5sum = :crypto.hash(:md5, body) |> Base.encode16()

    # shove the md5sum into a private key on the connection
    conn = Plug.Conn.put_private(conn, :md5sum, md5sum)

    {:ok, body, conn}
  end

end

plug Plug.Parsers,
  parsers: [:urlencoded, :multipart, :json],
  pass: ["*/*"],
  body_reader: {BodyReader, :read_body, []},
  json_decoder: Phoenix.json_library()

def fb_if(n) do
  if rem(n, 3) == 0 and rem(n, 5) == 0 do
    "FizzBuzz"
  else
    if rem(n, 3) == 0 do
      "Fizz"
    else
      if rem(n, 5) == 0 do
        "Buzz"
      else
        n
      end
    end
  end
end

def fb_cond1(n) do
  cond do
    rem(n, 3) == 0 and rem(n, 5) == 0 -> "FizzBuzz"
    rem(n, 3) == 0 -> "Fizz"
    rem(n, 5) == 0 -> "Buzz"
    true -> n
  end
end

def divisible_by_3?(n), do: rem(n, 3) == 0
def divisible_by_5?(n), do: rem(n, 5) == 0

def fb_cond2(n) do
  cond do
    divisible_by_3?(n) and divisible_by_5?(n) -> "FizzBuzz"
    divisible_by_3?(n) -> "Fizz"
    divisible_by_5?(n) -> "Buzz"
    true -> n
  end
end

def fb_case(n) do
  case {rem(n, 3), rem(n,5)} do
    {0, 0} -> "FizzBuzz"
    {0, _} -> "Fizz"
    {_, 0} -> "Buzz"
    _ -> n
  end
end

def fb_fun1(n) do
  fb_fun(n, rem(n, 3), rem(n, 5))
end

def fb_fun(_, 0, 0), do: "FizzBuzz"
def fb_fun(_, 0, _), do: "Fizz"
def fb_fun(_, _, 0), do: "Buzz"
def fb_fun(n, _, _), do: n

defguard is_divisible_by_3(n) when rem(n, 3) == 0
defguard is_divisible_by_5(n) when rem(n, 5) == 0

def fb_fun3(n) when is_divisible_by_3(n) and is_divisible_by_5(n), do: "FizzBuzz"
def fb_fun3(n) when is_divisible_by_3(n), do: "Fizz"
def fb_fun3(n) when is_divisible_by_5(n), do: "Buzz"
def fb_fun3(n), do: n

defmodule X.AuthControllerTest do
  use X.ConnCase
  use ExVCR.Mock, adapter: ExVCR.Adapter.Hackney

  test "google redirect creates the user", %{conn: conn} do
    conn =
      use_cassette "google_oauth_challenge" do
        conn
        |> get(
          "/auth/google/callback?code=....................."
        )
      end

    assert ...
    # ...

  end
end

response.body
|> :erlang.term_to_binary()
|> Base.encode64()

# .iex.exs
# A tmp bucket which you can push stuff into and analyze from iex
:ets.new(:tmp, [:named_table, :public])