plans.ex

defmodule Plausible.Billing.Plans do
  use Plausible.Repo

  @unlisted_plans_v1 [
    %{limit: 150_000_000, yearly_product_id: "648089", yearly_cost: "$4800"}
  ]

  @unlisted_plans_v2 [
    %{limit: 10_000_000, monthly_product_id: "655350", monthly_cost: "$250"}
  ]

  @sandbox_plans [
    %{
      limit: 10_000,
      monthly_product_id: "19878",
      yearly_product_id: "20127",
      monthly_cost: "$6",
      yearly_cost: "$60"
    },
    %{
      limit: 100_000,
      monthly_product_id: "20657",
      yearly_product_id: "20658",
      monthly_cost: "$12.34",
      yearly_cost: "$120.34"
    }
  ]

  @type plan() ::
          %{
            limit: non_neg_integer(),
            monthly_product_id: String.t(),
            yearly_product_id: String.t(),
            monthly_cost: String.t(),
            yearly_cost: String.t()
          }
          | :enterprise

  def plans_for(user) do
    user = Repo.preload(user, :subscription)
    sandbox_plans = plans_sandbox()
    v1_plans = plans_v1()
    v2_plans = plans_v2()
    v3_plans = plans_v3()

    raw_plans =
      cond do
        contains?(v1_plans, user.subscription) ->
          v1_plans

        contains?(v2_plans, user.subscription) ->
          v2_plans

        contains?(v3_plans, user.subscription) ->
          v3_plans

        contains?(sandbox_plans, user.subscription) ->
          sandbox_plans

        true ->
          cond do
            Application.get_env(:plausible, :environment) == "dev" -> sandbox_plans
            Timex.before?(user.inserted_at, ~D[2022-01-01]) -> v2_plans
            true -> v3_plans
          end
      end

    Enum.map(raw_plans, fn plan -> Map.put(plan, :volume, number_format(plan[:limit])) end)
  end

  def all_yearly_plan_ids do
    Enum.map(all_plans(), fn plan -> plan[:yearly_product_id] end)
  end

  def for_product_id(product_id) do
    Enum.find(all_plans(), fn plan ->
      product_id in [plan[:monthly_product_id], plan[:yearly_product_id]]
    end)
  end

  def subscription_interval(%Plausible.Billing.Subscription{paddle_plan_id: "free_10k"}),
    do: "N/A"

  def subscription_interval(subscription) do
    case for_product_id(subscription.paddle_plan_id) do
      nil ->
        enterprise_plan = get_enterprise_plan(subscription)

        enterprise_plan && enterprise_plan.billing_interval

      plan ->
        if subscription.paddle_plan_id == plan[:monthly_product_id] do
          "monthly"
        else
          "yearly"
        end
    end
  end

  def allowance(%Plausible.Billing.Subscription{paddle_plan_id: "free_10k"}), do: 10_000

  def allowance(subscription) do
    found = for_product_id(subscription.paddle_plan_id)

    if found do
      Map.fetch!(found, :limit)
    else
      enterprise_plan = get_enterprise_plan(subscription)

      if enterprise_plan do
        enterprise_plan.monthly_pageview_limit
      else
        Sentry.capture_message("Unknown allowance for plan",
          extra: %{
            paddle_plan_id: subscription.paddle_plan_id
          }
        )
      end
    end
  end

  defp get_enterprise_plan(%Plausible.Billing.Subscription{} = subscription) do
    Repo.get_by(Plausible.Billing.EnterprisePlan,
      user_id: subscription.user_id,
      paddle_plan_id: subscription.paddle_plan_id
    )
  end

  @enterprise_level_usage 10_000_000
  @spec suggested_plan(Plausible.Auth.User.t(), non_neg_integer()) :: plan()
  def suggested_plan(user, usage_during_cycle) do
    cond do
      usage_during_cycle > @enterprise_level_usage -> :enterprise
      Plausible.Auth.enterprise?(user) -> :enterprise
      true -> Enum.find(plans_for(user), fn plan -> usage_during_cycle < plan[:limit] end)
    end
  end

  defp contains?(_plans, nil), do: false

  defp contains?(plans, subscription) do
    Enum.any?(plans, fn plan ->
      plan[:monthly_product_id] == subscription.paddle_plan_id ||
        plan[:yearly_product_id] == subscription.paddle_plan_id
    end)
  end

  defp number_format(num) do
    PlausibleWeb.StatsView.large_number_format(num)
  end

  defp all_plans() do
    plans_v1() ++
      @unlisted_plans_v1 ++ plans_v2() ++ @unlisted_plans_v2 ++ plans_v3() ++ plans_sandbox()
  end

  defp plans_v1() do
    File.read!(Application.app_dir(:plausible) <> "/priv/plans_v1.json")
    |> Jason.decode!(keys: :atoms)
  end

  defp plans_v2() do
    File.read!(Application.app_dir(:plausible) <> "/priv/plans_v2.json")
    |> Jason.decode!(keys: :atoms)
  end

  defp plans_v3() do
    File.read!(Application.app_dir(:plausible) <> "/priv/plans_v3.json")
    |> Jason.decode!(keys: :atoms)
  end

  defp plans_sandbox() do
    case Application.get_env(:plausible, :environment) do
      "dev" -> @sandbox_plans
      _ -> []
    end
  end
end