defmodule Cannery.Fixtures do
  @moduledoc """
  This module defines test helpers for creating entities
  """

  import Cannery.DataCase

  alias Cannery.{
    Accounts,
    Accounts.User,
    ActivityLog.ShotRecord,
    Ammo,
    Ammo.Pack,
    Ammo.Type,
    Containers,
    Containers.Container,
    Containers.Tag,
    Email,
    Repo
  }

  @spec user_fixture() :: User.t()
  @spec user_fixture(attrs :: map()) :: User.t()
  def user_fixture(attrs \\ %{}) do
    attrs
    |> Enum.into(%{
      email: unique_user_email(),
      password: valid_user_password()
    })
    |> Accounts.register_user()
    |> unwrap_ok_tuple()
  end

  @spec admin_fixture() :: User.t()
  @spec admin_fixture(attrs :: map()) :: User.t()
  def admin_fixture(attrs \\ %{}) do
    attrs
    |> Enum.into(%{
      email: unique_user_email(),
      password: valid_user_password()
    })
    |> Accounts.register_user()
    |> unwrap_ok_tuple()
    |> User.role_changeset(:admin)
    |> Repo.update!()
  end

  def extract_user_token(fun) do
    %{args: %{attrs: attrs, email: email_key, user_id: user_id}} = fun.(&"[TOKEN]#{&1}[TOKEN]")

    # convert atoms to string keys
    attrs = attrs |> Map.new(fn {atom_key, value} -> {atom_key |> Atom.to_string(), value} end)

    email =
      email_key
      |> Atom.to_string()
      |> Email.generate_email(Accounts.get_user!(user_id), attrs)

    [_, html_token | _] = email.html_body |> String.split("[TOKEN]")
    [_, text_token | _] = email.text_body |> String.split("[TOKEN]")
    ^text_token = html_token
  end

  def valid_user_attributes(attrs \\ %{}) do
    Enum.into(attrs, %{
      email: unique_user_email(),
      password: valid_user_password()
    })
  end

  @doc """
  Generate a ShotRecord
  """
  @spec shot_record_fixture(User.t(), Pack.t()) :: ShotRecord.t()
  @spec shot_record_fixture(attrs :: map(), User.t(), Pack.t()) :: ShotRecord.t()
  def shot_record_fixture(attrs \\ %{}, %User{} = user, %Pack{} = pack) do
    attrs
    |> Enum.into(%{
      count: 20,
      date: ~N[2022-02-13 03:17:00],
      notes: random_string()
    })
    |> Cannery.ActivityLog.create_shot_record(user, pack)
    |> unwrap_ok_tuple()
  end

  @doc """
  Generate a Container
  """
  @spec container_fixture(User.t()) :: Container.t()
  @spec container_fixture(attrs :: map(), User.t()) :: Container.t()
  def container_fixture(attrs \\ %{}, %User{} = user) do
    attrs
    |> Enum.into(%{
      name: random_string(),
      type: "Ammo can",
      location: random_string(),
      desc: random_string()
    })
    |> Containers.create_container(user)
    |> unwrap_ok_tuple()
  end

  @doc """
  Generate a Type
  """
  @spec type_fixture(User.t()) :: Type.t()
  @spec type_fixture(attrs :: map(), User.t()) :: Type.t()
  def type_fixture(attrs \\ %{}, %User{} = user) do
    attrs
    |> Enum.into(%{
      name: random_string(),
      class: :rifle,
      desc: random_string(),
      bullet_type: random_string(),
      bullet_core: random_string(),
      cartridge: random_string(),
      caliber: random_string(),
      case_material: random_string(),
      jacket_type: random_string(),
      muzzle_velocity: 3,
      powder_type: random_string(),
      powder_grains_per_charge: 5,
      grains: 7,
      pressure: random_string(),
      primer_type: random_string(),
      firing_type: random_string(),
      wadding: random_string(),
      shot_type: random_string(),
      shot_material: random_string(),
      shot_size: random_string(),
      unfired_length: random_string(),
      brass_height: random_string(),
      chamber_size: random_string(),
      load_grains: 9,
      shot_charge_weight: random_string(),
      dram_equivalent: random_string(),
      tracer: false,
      incendiary: false,
      blank: false,
      corrosive: false,
      manufacturer: random_string(),
      upc: random_string()
    })
    |> Ammo.create_type(user)
    |> unwrap_ok_tuple()
  end

  @doc """
  Generate a Pack
  """
  @spec pack_fixture(Type.t(), Container.t(), User.t()) ::
          {count :: non_neg_integer(), [Pack.t()]}
  @spec pack_fixture(attrs :: map(), Type.t(), Container.t(), User.t()) ::
          {count :: non_neg_integer(), [Pack.t()]}
  @spec pack_fixture(
          attrs :: map(),
          multiplier :: non_neg_integer(),
          Type.t(),
          Container.t(),
          User.t()
        ) :: {count :: non_neg_integer(), [Pack.t()]}
  def pack_fixture(
        attrs \\ %{},
        multiplier \\ 1,
        %Type{id: type_id},
        %Container{id: container_id},
        %User{} = user
      ) do
    attrs
    |> Enum.into(%{
      type_id: type_id,
      container_id: container_id,
      count: 20,
      purchased_on: Date.utc_today()
    })
    |> Ammo.create_packs(multiplier, user)
    |> unwrap_ok_tuple()
  end

  @doc """
  Generates a Tag
  """
  @spec tag_fixture(User.t()) :: Tag.t()
  @spec tag_fixture(attrs :: map(), User.t()) :: Tag.t()
  def tag_fixture(attrs \\ %{}, %User{} = user) do
    attrs
    |> Enum.into(%{
      bg_color: "#100000",
      name: random_string(),
      text_color: "#000000"
    })
    |> Containers.create_tag(user)
    |> unwrap_ok_tuple()
  end

  defp unwrap_ok_tuple({:ok, value}), do: value
end