ami

defmodule Ami.Buddyship do
  use Ecto.Schema

  import Ecto.{
    Query,
    Changeset
  }

  alias Ami.{
    Course,
    CoursePeriod,
    Enrollment,
    User,
    Repo
  }

  schema "buddyships" do
    @timestamps_opts [type: :naive_datetime_usec]
    
    field(:relationship_to_user, :string)
    field(:name, :string)
    field(:email, :string)
    field(:status, :integer)
    field(:created_at, :utc_datetime_usec)
    field(:updated_at, :utc_datetime_usec)

    belongs_to(:user, User)
    belongs_to(:buddy, User, foreign_key: :buddy_id)
    belongs_to(:course_period, CoursePeriod)
    belongs_to(:course, Course)

    has_one(:enrollment, Enrollment, on_delete: :nilify_all)
  end

  def buddyship_status(status) do
    case status do
      0 -> "awaiting buddy response"
      1 -> "Buddy is: "
      2 -> "removed"
      3 -> "refused invitation"
    end
  end

  def find_or_initialize_changeset(buddyship, params \\ %{}) do
    buddyship
    |> cast(params, [
      :user_id,
      :relationship_to_user,
      :name,
      :email,
      :course_period_id,
      :course_id,
      :created_at,
      :updated_at
    ])
    |> validate_relevance(params)
    |> validate_required([:course_id, :user_id, :course_period_id, :email])
  end

  def update(buddyship, params \\ %{}) do
    Ecto.Changeset.change(buddyship, params) |> Repo.update()
  end

  def changeset(buddyship, params \\ %{}) do
    buddyship
    |> cast(params, [
      :user_id,
      :buddy_id,
      :relationship_to_user,
      :name,
      :email,
      :course_period_id,
      :course_id,
      :status,
      :created_at,
      :updated_at
    ])
    |> validate_required([:course_id, :user_id, :buddy_id, :course_period_id])
  end

  def staled_buddyships_for(user_id) do
    Repo.all(
      from(
        b in __MODULE__,
        where: b.user_id == ^user_id,
        where: b.status == 0,
        where: b.created_at <= ^Timex.shift(DateTime.utc_now(), days: -3)
      )
    )
  end

  defp validate_relevance(changeset, params) do
    user = Repo.get(User, params["user_id"])
    tobebuddy = Repo.one(from(u in User, where: u.email == ^params["email"]))

    existing_buddyship =
      cond do
        is_nil(tobebuddy) ->
          Repo.one(
            from(
              b in __MODULE__,
              where: b.user_id == ^params["user_id"],
              where: b.course_id == ^params["course_id"],
              where: b.email == ^params["email"],
              where: b.course_period_id == ^params["course_period_id"]
            )
          )

        !is_nil(tobebuddy) ->
          Repo.one(
            from(
              b in __MODULE__,
              where: b.user_id == ^params["user_id"],
              where: b.course_id == ^params["course_id"],
              where: b.buddy_id == ^tobebuddy.id,
              where: b.course_period_id == ^params["course_period_id"]
            )
          )
      end

    if !is_nil(existing_buddyship), do: Repo.delete(existing_buddyship)

    cond do
      user.email != params["email"] && !is_nil(tobebuddy) ->
        cast(changeset, %{buddy_id: tobebuddy.id}, [:buddy_id])

      user.email != params["email"] && is_nil(tobebuddy) ->
        cast(changeset, %{email: params["email"]}, [:email])

      user.email == params["email"] ->
        add_error(
          changeset,
          :email,
          "You cannot add yourself as a buddy"
        )
    end
  end
end