defmodule MyApp.Billing do

  @moduledoc """

  Licenses, plans, and what they let users do, with no payment provider.

  The app only ever asks one question, through `entitlements/1`, `can?/2`,

  and `check_limit/3`: what is this user allowed to do? The answer comes from

  licenses, however they were obtained:

    * **Admins** grant `:manual` licenses for invoiced customers, comps, and

      partners (`grant_license/3`).

    * **Payment providers** mirror their records into licenses with

      `sync_license/4` and keep everything else to themselves.

  """

  alias MyApp.Repo

  alias MyApp.Accounts.Scope

  alias MyApp.Accounts.User

  alias MyApp.Billing.{Entitlements, License}

  alias MyAppAdmin.Accounts.Scope, as: AdminScope

  ## Entitlements

  @doc """

  The current user's entitlements, merged from their active licenses.

  """

  def entitlements(%Scope{user: user}), do: entitlements_for_user(user)

  def entitlements_for_user(%User{} = user) do

    user

    |> list_active_licenses()

    |> Entitlements.merge()

  end

  @doc """

  Whether the current user's plan includes a feature.

  ## Examples

      can?(scope, :custom_domain)

  """

  def can?(%Scope{} = scope, feature) do

    scope

    |> entitlements()

    |> Entitlements.has_feature?(feature)

  end

  @doc """

  Checks whether the current user can add one more of something, given how

  many they have now. The caller counts; billing only knows the cap.

  ## Examples

      with :ok <- check_limit(scope, :projects, count_projects(scope)) do

        create_project(scope, attrs)

      end

  """

  def check_limit(%Scope{} = scope, key, count) do

    scope

    |> entitlements()

    |> Entitlements.check_limit(key, count)

  end

  ## Licenses

  @doc """

  Every license a user has held, newest first.

  """

  def list_licenses(%User{} = user) do

    License

    |> License.for_user_query(user)

    |> License.latest_query()

    |> Repo.all()

  end

  def list_active_licenses(%User{} = user) do

    License

    |> License.for_user_query(user)

    |> License.active_query(DateTime.utc_now(:second))

    |> Repo.all()

  end

  @doc """

  Users with more than one active license. Best wins keeps their access

  right, but they may be paying twice.

  """

  def list_users_with_multiple_licenses do

    Repo.all(License.users_with_multiple_active_query(DateTime.utc_now(:second)))

  end

  def change_license(%License{} = license, attrs \\ %{}) do

    License.changeset(license, attrs)

  end

  @doc """

  Grants a manual license, recording the admin who granted it.

  """

  def grant_license(%AdminScope{admin_user: admin}, %User{} = user, attrs) do

    %License{user_id: user.id, source: :manual, granted_by_id: admin.id}

    |> License.changeset(attrs)

    |> Repo.insert()

    |> broadcast_change()

  end

  @doc """

  Updates a manual license. Provider licenses return `{:error, :not_editable}`:

  change them at the provider.

  """

  def update_license(%License{} = license, attrs) do

    if License.editable?(license) do

      license

      |> License.changeset(attrs)

      |> Repo.update()

      |> broadcast_change()

    else

      {:error, :not_editable}

    end

  end

  @doc """

  Cancels a manual license now. Access drops at once to whatever the user's

  other licenses grant, or free.

  """

  def cancel_license(%License{} = license) do

    if License.editable?(license) do

      license

      |> License.cancel_changeset(DateTime.utc_now(:second))

      |> Repo.update()

      |> broadcast_change()

    else

      {:error, :not_editable}

    end

  end

  @doc """

  Creates or updates the license a payment provider holds for a user. This is

  the one call a provider makes, with its own id for the record as

  `source_ref`, every time that record changes. Replaying the same state is

  harmless.

  `attrs` takes `:plan`, `:status`, `:starts_at`, `:ends_at`, `:canceled_at`,

  and `:limit_overrides`.

  ## Examples

      sync_license(user, :stripe, "sub_123", %{

        plan: :pro,

        status: :active,

        starts_at: ~U[2026-01-01 00:00:00Z]

      })

  """

  def sync_license(%User{} = user, source, source_ref, attrs) when is_binary(source_ref) do

    %License{user_id: user.id, source: source, source_ref: source_ref}

    |> License.sync_changeset(attrs)

    |> Repo.insert(

      on_conflict:

        {:replace,

         [:plan, :status, :starts_at, :ends_at, :canceled_at, :limit_overrides, :updated_at]},

      conflict_target: [:source, :source_ref],

      returning: true

    )

    |> broadcast_change()

  end

  ## Notifications

  @doc """

  Subscribes to changes to the current user's licenses. Subscribers receive

  `{:licenses_changed, user_id}`.

  """

  def subscribe(%Scope{user: user}) do

    Phoenix.PubSub.subscribe(MyApp.PubSub, topic(user.id))

  end

  defp broadcast_change({:ok, %License{} = license} = result) do

    Phoenix.PubSub.broadcast(

      MyApp.PubSub,

      topic(license.user_id),

      {:licenses_changed, license.user_id}

    )

    result

  end

  defp broadcast_change(result), do: result

  defp topic(user_id), do: "billing:user:#{user_id}"

end

defmodule MyApp.Billing.Entitlements do

  @moduledoc """

  What a user can do, resolved from the licenses they hold.

  ## Merging licenses

  `merge/1` is the one place that decides what several licenses add up to.

  The default is **best wins**: the active license with the highest plan rank

  grants its plan, with that license's limit overrides applied. If two

  licenses have the same rank, the one that lasts longer wins.

  Best wins never stacks the same plan twice. If support creates a second Pro

  subscription by mistake, the user still gets Pro, and

  `MyApp.Billing.list_users_with_multiple_licenses/0` flags them for a look.

  No license means the free plan.

  ## Adding add-ons

  Add-ons (an extra seat pack, more storage, a stacked lifetime deal) are

  licenses whose limits add on top of the base plan. The model already holds

  them: an add-on is just a plan and a license. To support them:

    1. Add `addon?: false` to `MyApp.Billing.Plan` and define add-on plans

       with `addon?: true`, `rank: 0`, and limits of what each one adds.

    2. In `merge/1`, split the licenses with

       `Enum.split_with(licenses, &Plans.get!(&1.plan).addon?)`, pick the best

       base license as today, then sum each add-on's limits into the result.

       `nil` (unlimited) stays unlimited.

    3. Exclude add-on licenses from

       `MyApp.Billing.License.users_with_multiple_active_query/1`, since

       holding several is the point.

  Nothing else changes: providers still sync licenses, and callers still ask

  for entitlements.

  """

  alias MyApp.Billing.{License, Plans}

  defstruct [:plan, :license, limits: %{}, features: [], licenses: []]

  @doc """

  Resolves active licenses to entitlements, best wins.

  `:license` is the license granting the plan, or nil on free. `:licenses`

  is every active license considered.

  """

  def merge([]), do: for_plan(Plans.free())

  def merge(licenses) when is_list(licenses) do

    best = licenses |> Enum.sort(&outranks?/2) |> List.first()

    plan = Plans.get!(best.plan)

    %__MODULE__{

      plan: plan,

      license: best,

      limits: Map.merge(plan.limits, License.limit_overrides(best)),

      features: plan.features,

      licenses: licenses

    }

  end

  defp for_plan(plan) do

    %__MODULE__{plan: plan, limits: plan.limits, features: plan.features}

  end

  defp outranks?(a, b) do

    case {Plans.get!(a.plan).rank, Plans.get!(b.plan).rank} do

      {rank, rank} -> ends_later?(a.ends_at, b.ends_at)

      {rank_a, rank_b} -> rank_a > rank_b

    end

  end

  defp ends_later?(nil, _ends_at), do: true

  defp ends_later?(_ends_at, nil), do: false

  defp ends_later?(a, b), do: DateTime.compare(a, b) != :lt

  @doc """

  Whether the entitlements include a feature. Raises on unknown features, so a

  typo fails loudly instead of quietly locking everyone out.

  """

  def has_feature?(%__MODULE__{features: features}, feature) do

    unless feature in Plans.feature_keys() do

      raise ArgumentError, "unknown feature #{inspect(feature)}"

    end

    feature in features

  end

  @doc """

  The cap for a limit, or nil for unlimited. Raises on unknown limits.

  """

  def limit(%__MODULE__{limits: limits}, key), do: Map.fetch!(limits, key)

  @doc """

  Checks whether one more of something fits under its limit, given how many

  exist now.

  Returns `:ok` or `{:error, {:limit_reached, %{limit: key, max: max, count: count}}}`.

  ## Examples

      check_limit(entitlements, :projects, 3)

  """

  def check_limit(%__MODULE__{} = entitlements, key, count) when is_integer(count) do

    case limit(entitlements, key) do

      nil -> :ok

      max when count < max -> :ok

      max -> {:error, {:limit_reached, %{limit: key, max: max, count: count}}}

    end

  end

end

defmodule MyApp.Billing.License do

  @moduledoc """

  A user's right to a plan, from a given source, for a given time.

  The license is the only billing record the app reads. Payment providers keep

  their own records and write licenses through `MyApp.Billing.sync_license/4`;

  admins grant `:manual` ones. Either way, the app asks

  `MyApp.Billing.entitlements/1` and never cares how anyone paid.

  Only `:active` and `:canceled` are stored. Whether a license has started or

  expired comes from its dates, so nothing has to run when a license ends.

  """

  use Ecto.Schema

  import Ecto.Changeset

  import Ecto.Query

  alias MyApp.Billing.Plans

  # Payment providers add their source here, e.g. `:stripe`.

  @sources [:manual]

  @derive {Flop.Schema,

           filterable: [:email, :plan, :source],

           sortable: [:email, :plan, :starts_at, :ends_at, :inserted_at],

           default_limit: 20,

           max_limit: 100,

           default_order: %{order_by: [:inserted_at], order_directions: [:desc]},

           pagination_types: [:page],

           adapter_opts: [

             join_fields: [email: [binding: :user, field: :email, ecto_type: :string]]

           ]}

  @primary_key {:id, :binary_id, autogenerate: true}

  @foreign_key_type :binary_id

  schema "licenses" do

    field :plan, Ecto.Enum, values: Plans.keys()

    field :source, Ecto.Enum, values: @sources

    field :source_ref, :string

    field :status, Ecto.Enum, values: [:active, :canceled], default: :active

    field :starts_at, :utc_datetime

    field :ends_at, :utc_datetime

    field :canceled_at, :utc_datetime

    field :limit_overrides, :map, default: %{}

    field :note, :string

    belongs_to :user, MyApp.Accounts.User

    belongs_to :granted_by, MyAppAdmin.Accounts.AdminUser

    timestamps(type: :utc_datetime)

  end

  def sources, do: @sources

  ## Changesets

  @doc """

  The fields an admin sets when granting or editing a manual license.

  """

  def changeset(license, attrs) do

    license

    |> cast(attrs, [:plan, :starts_at, :ends_at, :limit_overrides, :source_ref, :note])

    |> validate_required([:plan, :starts_at])

    |> validate_inclusion(:plan, Enum.map(Plans.grantable(), & &1.key))

    |> validate_ends_after_starts()

    |> normalize_limit_overrides()

    |> unique_constraint([:source, :source_ref])

  end

  @doc """

  The fields a payment provider mirrors from its own records.

  """

  def sync_changeset(license, attrs) do

    license

    |> cast(attrs, [:plan, :status, :starts_at, :ends_at, :canceled_at, :limit_overrides])

    |> validate_required([:plan, :status, :starts_at])

    |> validate_inclusion(:plan, Enum.map(Plans.grantable(), & &1.key))

    |> validate_ends_after_starts()

    |> normalize_limit_overrides()

  end

  def cancel_changeset(license, now), do: change(license, status: :canceled, canceled_at: now)

  defp validate_ends_after_starts(changeset) do

    starts_at = get_field(changeset, :starts_at)

    ends_at = get_field(changeset, :ends_at)

    if starts_at && ends_at && DateTime.compare(ends_at, starts_at) != :gt do

      add_error(changeset, :ends_at, "must be after the start")

    else

      changeset

    end

  end

  # Overrides are stored with string keys, as they come back from the

  # database. Each value is a number, or nil for unlimited. Forms send "" to

  # mean the plan's default and "unlimited" for nil.

  defp normalize_limit_overrides(changeset) do

    case fetch_change(changeset, :limit_overrides) do

      {:ok, overrides} ->

        known = Enum.map(Plans.limit_keys(), &Atom.to_string/1)

        overrides

        |> Enum.map(fn {key, value} -> {to_string(key), parse_override(value)} end)

        |> Enum.reject(fn {_key, value} -> value == :default end)

        |> Enum.reduce_while({:ok, %{}}, fn

          {key, {:ok, value}}, {:ok, acc} ->

            if key in known,

              do: {:cont, {:ok, Map.put(acc, key, value)}},

              else: {:halt, {:error, "has an unknown limit #{key}"}}

          {key, :error}, _acc ->

            {:halt, {:error, "#{key} must be a whole number or \"unlimited\""}}

        end)

        |> case do

          {:ok, normalized} -> put_change(changeset, :limit_overrides, normalized)

          {:error, message} -> add_error(changeset, :limit_overrides, message)

        end

      :error ->

        changeset

    end

  end

  defp parse_override(nil), do: {:ok, nil}

  defp parse_override(value) when is_integer(value) and value >= 0, do: {:ok, value}

  defp parse_override(value) when is_binary(value) do

    case String.trim(value) do

      "" ->

        :default

      "unlimited" ->

        {:ok, nil}

      trimmed ->

        case Integer.parse(trimmed) do

          {number, ""} when number >= 0 -> {:ok, number}

          _ -> :error

        end

    end

  end

  defp parse_override(_value), do: :error

  ## Queries

  def for_user_query(query \\ __MODULE__, user) do

    from l in query, where: l.user_id == ^user.id

  end

  @doc """

  Licenses granting access right now: not canceled, started, and not ended.

  """

  def active_query(query \\ __MODULE__, now) do

    from l in query,

      where: l.status == :active and l.starts_at <= ^now,

      where: is_nil(l.ends_at) or l.ends_at > ^now

  end

  def latest_query(query \\ __MODULE__) do

    from l in query, order_by: [desc: l.inserted_at, desc: l.id]

  end

  def with_user_query(query \\ __MODULE__) do

    from l in query,

      join: u in assoc(l, :user),

      as: :user,

      preload: [user: u, granted_by: []]

  end

  @doc """

  Users holding more than one active license. Usually a mistake, like a second

  subscription created by accident, and worth a look because they may be

  paying twice.

  """

  def users_with_multiple_active_query(now) do

    user_ids =

      from l in active_query(now),

        group_by: l.user_id,

        having: count(l.id) > 1,

        select: l.user_id

    from u in MyApp.Accounts.User, where: u.id in subquery(user_ids), order_by: u.email

  end

  ## View functions

  @doc """

  Where the license is in its life: `:scheduled`, `:active`, `:expired`, or

  `:canceled`.

  """

  def display_status(%__MODULE__{status: :canceled}, _now), do: :canceled

  def display_status(%__MODULE__{} = license, now) do

    cond do

      DateTime.compare(license.starts_at, now) == :gt -> :scheduled

      license.ends_at && DateTime.compare(license.ends_at, now) != :gt -> :expired

      true -> :active

    end

  end

  @doc """

  Admins edit manual licenses. Provider licenses mirror the provider's records,

  so changes belong there, or the next sync would undo them.

  """

  def editable?(%__MODULE__{source: source}), do: source == :manual

  @doc """

  The license's overrides as an atom-keyed map of limit => cap.

  """

  def limit_overrides(%__MODULE__{limit_overrides: overrides}) do

    for key <- Plans.limit_keys(),

        Map.has_key?(overrides, Atom.to_string(key)),

        into: %{},

        do: {key, Map.fetch!(overrides, Atom.to_string(key))}

  end

end

defmodule MyApp.Billing.Plan do

  @moduledoc """

  A plan: what one license grants. Plans are defined in code, in

  `MyApp.Billing.Plans`.

    * `:rank` — higher wins when a user holds several licenses

    * `:public?` — whether the plan is offered to customers. Retired and

      custom plans set it to `false`

    * `:limits` — a cap for every key in `MyApp.Billing.Plans.limits/0`,

      or `nil` for unlimited

    * `:features` — keys from `MyApp.Billing.Plans.features/0` the plan includes

  """

  @enforce_keys [:key, :name, :rank]

  defstruct [:key, :name, :description, :rank, public?: true, limits: %{}, features: []]

end

defmodule MyApp.Billing.Plans do

  @moduledoc """

  The plan catalog.

  Plans live in code rather than the database, so changing what a plan grants

  is a reviewed, versioned change. Two rules keep that safe:

    * **Never change the terms of a plan people hold.** Add a new plan

      (`:pro_2027`) and set the old one to `public?: false`. Existing licenses

      keep what they bought.

    * **Never delete a plan that licenses reference.** Licenses store the plan

      key, so it has to keep resolving.

  Every plan defines every limit, and only known features, or the app fails to

  compile.

  """

  alias MyApp.Billing.Plan

  @limits [

    projects: "Projects",

    members: "Team members"

  ]

  @features [

    custom_domain: "Custom domain",

    api_access: "API access",

    priority_support: "Priority support",

    sso: "Single sign-on"

  ]

  @plans [

    %Plan{

      key: :free,

      name: "Free",

      rank: 0,

      description: "For trying things out.",

      limits: %{projects: 3, members: 1},

      features: []

    },

    %Plan{

      key: :pro,

      name: "Pro",

      rank: 10,

      description: "For individuals and small teams.",

      limits: %{projects: 50, members: 5},

      features: [:custom_domain, :api_access]

    },

    %Plan{

      key: :business,

      name: "Business",

      rank: 20,

      description: "For growing teams.",

      limits: %{projects: nil, members: 25},

      features: [:custom_domain, :api_access, :priority_support]

    },

    %Plan{

      key: :enterprise,

      name: "Enterprise",

      rank: 30,

      public?: false,

      description: "Custom terms, granted by your team.",

      limits: %{projects: nil, members: nil},

      features: [:custom_domain, :api_access, :priority_support, :sso]

    }

  ]

  for plan <- @plans do

    if Enum.sort(Map.keys(plan.limits)) != Enum.sort(Keyword.keys(@limits)) do

      raise ArgumentError, "plan #{inspect(plan.key)} must define exactly the limits in @limits"

    end

    if unknown = Enum.find(plan.features, &(not Keyword.has_key?(@features, &1))) do

      raise ArgumentError, "plan #{inspect(plan.key)} has unknown feature #{inspect(unknown)}"

    end

  end

  @doc "Every plan, lowest rank first."

  def all, do: @plans

  @doc "Plans offered to customers."

  def public, do: Enum.filter(@plans, & &1.public?)

  @doc "Plans a license can grant: everything but free, which needs no license."

  def grantable, do: Enum.reject(@plans, &(&1.key == :free))

  def keys, do: Enum.map(@plans, & &1.key)

  def get!(key),

    do: Enum.find(@plans, &(&1.key == key)) || raise(ArgumentError, "no plan #{inspect(key)}")

  @doc "The plan for users without an active license."

  def free, do: get!(:free)

  @doc "Limit keys with their labels, in display order."

  def limits, do: @limits

  def limit_keys, do: Keyword.keys(@limits)

  @doc "Feature keys with their labels, in display order."

  def features, do: @features

  def feature_keys, do: Keyword.keys(@features)

end

defmodule MyAppAdmin.Query.Licenses do

  alias MyApp.Repo

  alias MyApp.Billing.License

  @doc """

  Returns a paginated, sorted, and filtered list of licenses with users preloaded.

  Returns `{:ok, {licenses, meta}}` or `{:error, meta}`.

  """

  def list(params \\ %{}) do

    Flop.validate_and_run(License.with_user_query(), params, for: License)

  end

  @doc """

  Gets a single license with its user and granting admin preloaded.

  """

  def get!(id), do: Repo.get!(License.with_user_query(), id)

end

defmodule MyAppAdminWeb.BillingComponents do

  @moduledoc """

  Components shared by the admin billing pages.

  """

  use MyAppAdminWeb, :html

  alias MyApp.Billing.{Entitlements, License, Plans}

  @doc """

  Renders a license's status as a badge.

  """

  attr :license, License, required: true

  attr :now, DateTime, required: true

  def license_status_badge(assigns) do

    assigns = assign(assigns, :status, License.display_status(assigns.license, assigns.now))

    ~H"""

    <span class={["badge badge-sm", status_class(@status)]}>{status_label(@status)}</span>

    """

  end

  defp status_class(:active), do: "badge-success"

  defp status_class(:scheduled), do: "badge-info"

  defp status_class(:expired), do: "badge-ghost"

  defp status_class(:canceled), do: "badge-error"

  defp status_label(status), do: status |> Atom.to_string() |> String.capitalize()

  @doc """

  Renders what a user's entitlements add up to.

  """

  attr :entitlements, Entitlements, required: true

  def entitlements_summary(assigns) do

    ~H"""

    <.list>

      <:item title="Plan">

        {@entitlements.plan.name}

        <span :if={!@entitlements.license} class="text-base-content/60">(no license)</span>

      </:item>

      <:item :for={{key, label} <- Plans.limits()} title={label}>

        {format_limit(Entitlements.limit(@entitlements, key))}

      </:item>

      <:item title="Features">

        {feature_labels(@entitlements.features)}

      </:item>

    </.list>

    """

  end

  @doc """

  Warns that users hold several active licenses, which may mean they're

  paying twice.

  """

  slot :inner_block, required: true, doc: "the headline"

  slot :details

  def multiple_licenses_warning(assigns) do

    ~H"""

    <div role="alert" class="alert alert-warning my-6">

      <.icon name="hero-exclamation-triangle" class="size-5" />

      <div>

        <p class="font-semibold">{render_slot(@inner_block)}</p>

        <p class="text-sm">

          The best plan wins, so access is right, but check for a duplicate they're paying for.

        </p>

        <p :if={@details != []} class="text-sm mt-1">{render_slot(@details)}</p>

      </div>

    </div>

    """

  end

  def plan_name(key), do: Plans.get!(key).name

  def source_label(:manual), do: "Manual"

  def source_label(source), do: source |> Atom.to_string() |> String.capitalize()

  def format_limit(nil), do: "Unlimited"

  def format_limit(number), do: Integer.to_string(number)

  defp feature_labels([]), do: "None"

  defp feature_labels(features) do

    Plans.features()

    |> Enum.filter(fn {key, _label} -> key in features end)

    |> Enum.map_join(", ", fn {_key, label} -> label end)

  end

end

        <.sidebar_item

          icon="hero-key-mini"

          navigate={~p"/admin/licenses"}

          current={@page_selected == :licenses}

        >

          Licenses

        </.sidebar_item>

defmodule MyAppAdminWeb.LicenseLive.Form do

  use MyAppAdminWeb, :live_view

  import MyAppAdminWeb.BillingComponents

  alias MyApp.Billing

  alias MyApp.Billing.{License, Plans}

  alias MyAppAdmin.Query

  alias MyAppAdmin.Timezone

  def render(assigns) do

    ~H"""

    <Layouts.admin_ui flash={@flash} current_scope={@current_scope} page_selected={:licenses}>

      <.header>

        {@page_title}

        <:subtitle>{@user.email}</:subtitle>

      </.header>

      <.form for={@form} id="license-form" phx-change="validate" phx-submit="save" class="max-w-xl">

        <.input

          field={@form[:plan]}

          type="select"

          label="Plan"

          options={Enum.map(Plans.grantable(), &{&1.name, &1.key})}

        />

        <div class="grid gap-4 sm:grid-cols-2">

          <.input

            field={@form[:starts_at]}

            type="date"

            label="Starts on"

            value={date_value(@form[:starts_at].value)}

          />

          <.input

            field={@form[:ends_at]}

            type="date"

            label="Ends on"

            value={date_value(@form[:ends_at].value)}

          />

        </div>

        <p class="text-sm text-base-content/70 mb-4">

          Dates are in {Timezone.name()}. Access stops at the start of the end date. Leave it blank for no end.

        </p>

        <fieldset class="fieldset mb-4">

          <legend class="fieldset-legend">Limit overrides</legend>

          <p class="text-sm text-base-content/70">

            Leave blank to use the plan's limit. Enter a number, or "unlimited".

          </p>

          <div class="grid gap-4 sm:grid-cols-2">

            <.input

              :for={{key, label} <- Plans.limits()}

              id={"license_limit_overrides_#{key}"}

              name={"license[limit_overrides][#{key}]"}

              label={label}

              value={override_value(@form[:limit_overrides].value, key)}

              placeholder={"Plan: #{plan_limit(@form[:plan].value, key)}"}

            />

          </div>

          <p

            :for={error <- @form[:limit_overrides].errors}

            class="mt-1.5 flex gap-2 items-center text-sm text-error"

          >

            <.icon name="hero-exclamation-circle" class="size-5" />

            {translate_error(error)}

          </p>

        </fieldset>

        <.input

          field={@form[:source_ref]}

          label="Reference"

          placeholder="Contract or invoice number (optional)"

        />

        <.input field={@form[:note]} type="textarea" label="Note" rows="3" />

        <div class="flex gap-2 mt-4">

          <.button variant="primary" phx-disable-with="Saving...">Save license</.button>

          <.link navigate={@return_to}>

            <.button type="button">Cancel</.button>

          </.link>

        </div>

      </.form>

    </Layouts.admin_ui>

    """

  end

  def mount(params, _session, socket) do

    {:ok, apply_action(socket, socket.assigns.live_action, params)}

  end

  defp apply_action(socket, :new, %{"user_id" => user_id}) do

    user = Query.Users.get!(user_id)

    license = %License{plan: :pro, starts_at: DateTime.utc_now(:second)}

    socket

    |> assign(

      page_title: "Grant license",

      user: user,

      license: license,

      return_to: ~p"/admin/users/#{user}"

    )

    |> assign_form(Billing.change_license(license))

  end

  defp apply_action(socket, :edit, %{"id" => id}) do

    license = Query.Licenses.get!(id)

    if License.editable?(license) do

      socket

      |> assign(

        page_title: "Edit license",

        user: license.user,

        license: license,

        return_to: ~p"/admin/licenses/#{license}"

      )

      |> assign_form(Billing.change_license(license))

    else

      socket

      |> put_flash(

        :error,

        "This license mirrors #{source_label(license.source)}. Change it there."

      )

      |> push_navigate(to: ~p"/admin/licenses/#{license}")

    end

  end

  def handle_event("validate", %{"license" => params}, socket) do

    changeset = Billing.change_license(socket.assigns.license, parse_dates(params))

    {:noreply, assign_form(socket, Map.put(changeset, :action, :validate))}

  end

  def handle_event("save", %{"license" => params}, socket) do

    save_license(socket, socket.assigns.live_action, parse_dates(params))

  end

  defp save_license(socket, :new, params) do

    case Billing.grant_license(socket.assigns.current_scope, socket.assigns.user, params) do

      {:ok, _license} ->

        {:noreply,

         socket

         |> put_flash(:info, "License granted.")

         |> push_navigate(to: socket.assigns.return_to)}

      {:error, %Ecto.Changeset{} = changeset} ->

        {:noreply, assign_form(socket, changeset)}

    end

  end

  defp save_license(socket, :edit, params) do

    case Billing.update_license(socket.assigns.license, params) do

      {:ok, _license} ->

        {:noreply,

         socket

         |> put_flash(:info, "License updated.")

         |> push_navigate(to: socket.assigns.return_to)}

      {:error, %Ecto.Changeset{} = changeset} ->

        {:noreply, assign_form(socket, changeset)}

    end

  end

  defp assign_form(socket, changeset), do: assign(socket, form: to_form(changeset))

  # Date inputs pick a day on the admin calendar. A license starts or ends at

  # the beginning of that day.

  defp parse_dates(params) do

    Enum.reduce(["starts_at", "ends_at"], params, fn key, params ->

      case Map.get(params, key) do

        "" ->

          Map.put(params, key, nil)

        value when is_binary(value) ->

          case Date.from_iso8601(value) do

            {:ok, date} -> Map.put(params, key, Timezone.day_start_utc(date))

            {:error, _} -> params

          end

        _ ->

          params

      end

    end)

  end

  defp date_value(%DateTime{} = datetime),

    do: datetime |> Timezone.shift() |> DateTime.to_date() |> Date.to_iso8601()

  defp date_value(value), do: value

  defp override_value(overrides, key) when is_map(overrides) do

    case Enum.find(overrides, fn {k, _value} -> to_string(k) == Atom.to_string(key) end) do

      nil -> ""

      {_key, nil} -> "unlimited"

      {_key, value} -> to_string(value)

    end

  end

  defp override_value(_overrides, _key), do: ""

  defp plan_limit(plan, key) do

    case Enum.find(Plans.grantable(), &(to_string(&1.key) == to_string(plan))) do

      nil -> "-"

      plan -> plan.limits |> Map.fetch!(key) |> format_limit()

    end

  end

end

defmodule MyAppAdminWeb.LicenseLive.Index do

  use MyAppAdminWeb, :live_view

  import MyAppAdminWeb.BillingComponents

  alias MyApp.Billing

  alias MyApp.Billing.{License, Plans}

  alias MyAppAdmin.Query

  def render(assigns) do

    ~H"""

    <Layouts.admin_ui flash={@flash} current_scope={@current_scope} page_selected={:licenses}>

      <.header>

        Licenses

        <:subtitle>{@meta.total_count} total</:subtitle>

        <:actions>

          <form phx-change="filter" class="flex flex-wrap gap-2">

            <select name="plan" class="select select-bordered select-sm w-36">

              <option value="">All plans</option>

              <option

                :for={plan <- Plans.grantable()}

                value={plan.key}

                selected={filter_value(@meta, :plan) == Atom.to_string(plan.key)}

              >

                {plan.name}

              </option>

            </select>

            <select name="source" class="select select-bordered select-sm w-36">

              <option value="">All sources</option>

              <option

                :for={source <- License.sources()}

                value={source}

                selected={filter_value(@meta, :source) == Atom.to_string(source)}

              >

                {source_label(source)}

              </option>

            </select>

            <div class="relative">

              <.icon

                name="hero-magnifying-glass-micro"

                class="absolute left-3 top-1/2 -translate-y-1/2 h-4 w-4 text-base-content/50"

              />

              <input

                type="search"

                name="email"

                value={filter_value(@meta, :email)}

                placeholder="Search by email..."

                phx-debounce="300"

                class="input input-bordered input-sm pl-9 w-64"

              />

            </div>

          </form>

        </:actions>

      </.header>

      <.multiple_licenses_warning :if={@multiple_license_users != []}>

        {pluralize(length(@multiple_license_users), "user has", "users have")} more than one active license

        <:details>

          <.link

            :for={user <- @multiple_license_users}

            navigate={~p"/admin/users/#{user}"}

            class="link mr-3"

          >

            {user.email}

          </.link>

        </:details>

      </.multiple_licenses_warning>

      <.data_table

        items={@licenses}

        meta={@meta}

        path={~p"/admin/licenses"}

        id="licenses"

        row_click={fn license -> JS.navigate(~p"/admin/licenses/#{license}") end}

      >

        <:col :let={license} label="Email" field={:email}>{license.user.email}</:col>

        <:col :let={license} label="Plan" field={:plan}>{plan_name(license.plan)}</:col>

        <:col :let={license} label="Status">

          <.license_status_badge license={license} now={@now} />

        </:col>

        <:col :let={license} label="Source">{source_label(license.source)}</:col>

        <:col :let={license} label="Starts" field={:starts_at}>{format_date(license.starts_at)}</:col>

        <:col :let={license} label="Ends" field={:ends_at}>{format_date(license.ends_at)}</:col>

        <:action :let={license}>

          <.link navigate={~p"/admin/licenses/#{license}"}>Show</.link>

        </:action>

      </.data_table>

      <.pagination meta={@meta} path={~p"/admin/licenses"} />

    </Layouts.admin_ui>

    """

  end

  def mount(_params, _session, socket) do

    {:ok,

     assign(socket,

       multiple_license_users: Billing.list_users_with_multiple_licenses(),

       now: DateTime.utc_now(:second)

     )}

  end

  def handle_params(params, _uri, socket) do

    case Query.Licenses.list(params) do

      {:ok, {licenses, meta}} ->

        {:noreply, assign(socket, licenses: licenses, meta: meta)}

      {:error, meta} ->

        {:noreply, assign(socket, licenses: [], meta: meta)}

    end

  end

  def handle_event("filter", params, socket) do

    filters =

      [

        params["email"] not in [nil, ""] &&

          %Flop.Filter{field: :email, op: :ilike_and, value: params["email"]},

        params["plan"] not in [nil, ""] &&

          %Flop.Filter{field: :plan, op: :==, value: params["plan"]},

        params["source"] not in [nil, ""] &&

          %Flop.Filter{field: :source, op: :==, value: params["source"]}

      ]

      |> Enum.filter(& &1)

    path = Flop.Phoenix.build_path(~p"/admin/licenses", %Flop{filters: filters})

    {:noreply, push_patch(socket, to: path)}

  end

  defp pluralize(1, singular, _plural), do: "1 #{singular}"

  defp pluralize(count, _singular, plural), do: "#{count} #{plural}"

  defp filter_value(meta, field) do

    case Filter.get_value(meta.flop.filters, field) do

      nil -> nil

      value -> to_string(value)

    end

  end

end

defmodule MyAppAdminWeb.LicenseLive.Show do

  use MyAppAdminWeb, :live_view

  import MyAppAdminWeb.BillingComponents

  alias MyApp.Billing

  alias MyApp.Billing.{License, Plans}

  alias MyAppAdmin.Query

  def render(assigns) do

    ~H"""

    <Layouts.admin_ui flash={@flash} current_scope={@current_scope} page_selected={:licenses}>

      <.header>

        {plan_name(@license.plan)} license

        <:subtitle>{@license.user.email}</:subtitle>

        <:actions>

          <.link :if={License.editable?(@license)} navigate={~p"/admin/licenses/#{@license}/edit"}>

            <.button>Edit</.button>

          </.link>

          <.button

            :if={License.editable?(@license) and @license.status == :active}

            phx-click="cancel"

            data-confirm="Cancel this license? The user loses its plan right away."

          >

            Cancel license

          </.button>

          <.link navigate={~p"/admin/users/#{@license.user}"}>

            <.button>Back to user</.button>

          </.link>

        </:actions>

      </.header>

      <p :if={!License.editable?(@license)} class="text-sm text-base-content/70 mb-4">

        This license mirrors {source_label(@license.source)}. Change it there.

      </p>

      <.list>

        <:item title="Status"><.license_status_badge license={@license} now={@now} /></:item>

        <:item title="User">

          <.link navigate={~p"/admin/users/#{@license.user}"} class="link">

            {@license.user.email}

          </.link>

        </:item>

        <:item title="Plan">{plan_name(@license.plan)}</:item>

        <:item title="Source">{source_label(@license.source)}</:item>

        <:item :if={@license.source_ref} title="Reference">

          <.copy_button value={@license.source_ref} />

        </:item>

        <:item title="Starts">{format_datetime(@license.starts_at)}</:item>

        <:item title="Ends">{format_datetime(@license.ends_at)}</:item>

        <:item :if={@license.canceled_at} title="Canceled">

          {format_datetime(@license.canceled_at)}

        </:item>

        <:item

          :for={{key, value} <- License.limit_overrides(@license)}

          title={"#{limit_label(key)} override"}

        >

          {format_limit(value)}

        </:item>

        <:item :if={@license.granted_by} title="Granted by">{@license.granted_by.email}</:item>

        <:item :if={@license.note} title="Note">

          <span class="whitespace-pre-line">{@license.note}</span>

        </:item>

        <:item title="Created">{format_datetime(@license.inserted_at)}</:item>

      </.list>

    </Layouts.admin_ui>

    """

  end

  def mount(%{"id" => id}, _session, socket) do

    {:ok,

     assign(socket,

       license: Query.Licenses.get!(id),

       now: DateTime.utc_now(:second)

     )}

  end

  def handle_event("cancel", _params, socket) do

    case Billing.cancel_license(socket.assigns.license) do

      {:ok, license} ->

        {:noreply,

         socket

         |> put_flash(:info, "License canceled.")

         |> assign(license: Query.Licenses.get!(license.id), now: DateTime.utc_now(:second))}

      {:error, _reason} ->

        {:noreply, put_flash(socket, :error, "This license can't be canceled here.")}

    end

  end

  defp limit_label(key), do: Keyword.fetch!(Plans.limits(), key)

end

  import MyAppAdminWeb.BillingComponents

  alias MyApp.Billing

      <div class="mt-8">

        <.header>

          Billing

          <:actions>

            <.link navigate={~p"/admin/licenses/new?user_id=#{@user}"}>

              <.button>Grant license</.button>

            </.link>

          </:actions>

        </.header>

        <.multiple_licenses_warning :if={length(@entitlements.licenses) > 1}>

          This user has {length(@entitlements.licenses)} active licenses

        </.multiple_licenses_warning>

        <.entitlements_summary entitlements={@entitlements} />

        <.table

          :if={@licenses != []}

          id="licenses"

          rows={@licenses}

          class="mt-6"

          row_click={fn license -> JS.navigate(~p"/admin/licenses/#{license}") end}

        >

          <:col :let={license} label="Plan">{plan_name(license.plan)}</:col>

          <:col :let={license} label="Status">

            <.license_status_badge license={license} now={@now} />

          </:col>

          <:col :let={license} label="Source">{source_label(license.source)}</:col>

          <:col :let={license} label="Starts">{format_date(license.starts_at)}</:col>

          <:col :let={license} label="Ends">{format_date(license.ends_at)}</:col>

        </.table>

      </div>

    user = Query.Users.get!(id)

    {:ok,

     assign(socket,

       user: user,

       entitlements: Billing.entitlements_for_user(user),

       licenses: Billing.list_licenses(user),

       now: DateTime.utc_now(:second)

     )}

        <li>

          <.link href={~p"/billing"}>Billing</.link>

        </li>

defmodule MyAppWeb.BillingLive do

  use MyAppWeb, :live_view

  alias MyApp.Billing

  alias MyApp.Billing.{Entitlements, Plan, Plans}

  @impl true

  def render(assigns) do

    ~H"""

    <Layouts.app flash={@flash} current_scope={@current_scope}>

      <.header>

        Billing

        <:subtitle>You're on the {@entitlements.plan.name} plan.</:subtitle>

      </.header>

      <p :if={@entitlements.license && @entitlements.license.ends_at} class="text-sm">

        Your plan ends on {format_date(@entitlements.license.ends_at)}.

      </p>

      <.list>

        <:item :for={{key, label} <- Plans.limits()} title={label}>

          {format_limit(Entitlements.limit(@entitlements, key))}

        </:item>

        <:item :for={{key, label} <- Plans.features()} title={label}>

          {if Entitlements.has_feature?(@entitlements, key), do: "Included", else: "Not included"}

        </:item>

      </.list>

      <div class="mt-10">

        <.header>

          Plans

          <:subtitle>To change your plan, contact us.</:subtitle>

        </.header>

        <div class="grid gap-4 sm:grid-cols-3">

          <.plan_card

            :for={plan <- Plans.public()}

            plan={plan}

            current={plan.key == @entitlements.plan.key}

          />

        </div>

      </div>

    </Layouts.app>

    """

  end

  attr :plan, Plan, required: true

  attr :current, :boolean, required: true

  defp plan_card(assigns) do

    ~H"""

    <div

      id={"plan-#{@plan.key}"}

      class={[

        "rounded-box border p-5 space-y-3",

        if(@current, do: "border-primary", else: "border-base-300")

      ]}

    >

      <div class="flex items-center justify-between">

        <h2 class="font-semibold">{@plan.name}</h2>

        <span :if={@current} class="badge badge-primary badge-sm">Current plan</span>

      </div>

      <p class="text-sm text-base-content/70">{@plan.description}</p>

      <ul class="text-sm space-y-1">

        <li :for={{key, label} <- Plans.limits()}>

          {label}: {format_limit(Map.fetch!(@plan.limits, key))}

        </li>

        <li :for={{key, label} <- Plans.features()} :if={key in @plan.features}>

          <.icon name="hero-check-micro" class="size-4 text-success" /> {label}

        </li>

      </ul>

    </div>

    """

  end

  @impl true

  def mount(_params, _session, socket) do

    if connected?(socket), do: Billing.subscribe(socket.assigns.current_scope)

    {:ok, assign_entitlements(socket)}

  end

  @impl true

  def handle_info({:licenses_changed, _user_id}, socket) do

    {:noreply, assign_entitlements(socket)}

  end

  defp assign_entitlements(socket) do

    assign(socket, entitlements: Billing.entitlements(socket.assigns.current_scope))

  end

  defp format_limit(nil), do: "Unlimited"

  defp format_limit(number), do: Integer.to_string(number)

  defp format_date(datetime), do: Calendar.strftime(datetime, "%b %-d, %Y")

end

      live "/billing", BillingLive, :index

      live "/licenses", LicenseLive.Index

      live "/licenses/new", LicenseLive.Form, :new

      live "/licenses/:id", LicenseLive.Show

      live "/licenses/:id/edit", LicenseLive.Form, :edit

defmodule MyApp.Repo.Migrations.CreateLicenses do

  use Ecto.Migration

  def change do

    create table(:licenses, primary_key: false) do

      add :id, :binary_id, primary_key: true

      add :user_id, references(:users, type: :binary_id, on_delete: :delete_all), null: false

      add :plan, :string, null: false

      # Where the license came from: "manual" for admin grants, or a payment

      # provider. source_ref is that source's id for it (a Stripe subscription,

      # a contract number) and makes provider syncs idempotent.

      add :source, :string, null: false

      add :source_ref, :string

      add :status, :string, null: false

      add :starts_at, :utc_datetime, null: false

      add :ends_at, :utc_datetime

      add :canceled_at, :utc_datetime

      # Per-license limit changes on top of the plan, for custom deals.

      add :limit_overrides, :map, null: false, default: %{}

      add :note, :text

      add :granted_by_id, references(:admin_users, type: :binary_id, on_delete: :nilify_all)

      timestamps(type: :utc_datetime)

    end

    create index(:licenses, [:user_id, :status])

    create index(:licenses, [:granted_by_id])

    # Postgres treats NULLs as distinct, so manual grants without a ref never

    # collide here.

    create unique_index(:licenses, [:source, :source_ref])

  end

end

defmodule MyApp.BillingTest do

  use MyApp.DataCase, async: true

  import MyApp.AccountsFixtures

  import MyApp.BillingFixtures

  alias MyApp.Accounts.Scope

  alias MyApp.Billing

  alias MyApp.Billing.{Entitlements, License, Plans}

  describe "plans" do

    test "free is the lowest plan and not grantable" do

      assert Plans.free().rank == 0

      refute Plans.free() in Plans.grantable()

      assert Enum.all?(Plans.grantable(), &(&1.rank > 0))

    end

    test "ranks are unique, so best wins is never a coin toss" do

      ranks = Enum.map(Plans.all(), & &1.rank)

      assert ranks == Enum.uniq(ranks)

    end

  end

  describe "entitlements/1" do

    test "a user without licenses is on free" do

      scope = user_scope_fixture()

      entitlements = Billing.entitlements(scope)

      assert entitlements.plan.key == :free

      assert entitlements.license == nil

      assert entitlements.limits == Plans.free().limits

    end

    test "an active license grants its plan" do

      user = user_fixture()

      license = license_fixture(user, plan: :business)

      entitlements = Billing.entitlements(Scope.for_user(user))

      assert entitlements.plan.key == :business

      assert entitlements.license.id == license.id

      assert Entitlements.has_feature?(entitlements, :priority_support)

    end

    test "ignores canceled, expired, and scheduled licenses" do

      user = user_fixture()

      {:ok, _} = user |> license_fixture(plan: :enterprise) |> Billing.cancel_license()

      license_fixture(user,

        plan: :business,

        starts_at: days_from_now(-30),

        ends_at: days_from_now(-1)

      )

      license_fixture(user, plan: :business, starts_at: days_from_now(1))

      assert Billing.entitlements(Scope.for_user(user)).plan.key == :free

    end

    test "best wins: the highest-ranked plan, not the newest" do

      user = user_fixture()

      license_fixture(user, plan: :business)

      license_fixture(user, plan: :pro)

      assert Billing.entitlements(Scope.for_user(user)).plan.key == :business

    end