{:oban, "~> 2.18"},

      {:stripity_stripe, "~> 3.2"},

# Background jobs. The `stripe_sync` queue runs the Stripe event poller, which

# a cron entry enqueues every minute to keep subscription state in sync.

config :my_app, Oban,

  engine: Oban.Engines.Basic,

  repo: MyApp.Repo,

  queues: [stripe_sync: 1],

  plugins: [

    {Oban.Plugins.Cron,

     crontab: [

       {"* * * * *", MyApp.Workers.StripeEventsPoller}

     ]}

  ]

# Stub Stripe Price ids so the subscribe flow is fully clickable in dev without

# real keys. With no `:stripity_stripe` api_key set, `MyApp.Billing.Stripe` runs

# in stub mode and threads these ids through the checkout round-trip. Set real

# test keys/price ids via env (picked up in config/runtime.exs) to hit Stripe.

config :my_app, :billing,

  price_ids: %{

    pro: "price_dev_pro",

    business: "price_dev_business"

  }

# Stripe secret key. Set in any environment to talk to the real Stripe API;

# leave it unset to keep `MyApp.Billing.Stripe` in stub mode (dev/test default).

# Guarded so it never clobbers the stub-mode config in dev/test.

if api_key = System.get_env("STRIPE_SECRET_KEY") do

  config :stripity_stripe, api_key: api_key

end

  # Stripe billing: the publishable key and the live Price id for each plan.

  config :my_app, :billing,

    publishable_key: System.get_env("STRIPE_PUBLISHABLE_KEY"),

    price_ids: %{

      pro: System.get_env("STRIPE_PRICE_PRO"),

      business: System.get_env("STRIPE_PRICE_BUSINESS")

    }

# Run Oban jobs inline and disable cron/queues during tests.

config :my_app, Oban, testing: :manual

# Test Stripe Price ids. No `:stripity_stripe` api_key is set in tests, so

# `MyApp.Billing.Stripe` stays in stub mode (no network calls).

config :my_app, :billing,

  price_ids: %{

    pro: "price_test_pro",

    business: "price_test_business"

  }

    field :stripe_customer_id, :string

      {Oban, Application.fetch_env!(:my_app, Oban)},

defmodule MyApp.Billing do

  @moduledoc """

  Subscription billing powered by Stripe Checkout + the Customer Portal.

  The flow is intentionally webhook-light: a user subscribes through Stripe

  Checkout, and we learn the result two ways — both of which converge on

  `upsert_subscription/2`:

    1. **On return** (`sync_checkout_session/2`) — when Stripe redirects the user

       back, we poll the session immediately so the UI reflects the new

       subscription without waiting for an event.

    2. **From the event poller** (`handle_stripe_event/1`) — a background job

       drains Stripe's event stream and resyncs on `customer.subscription.*`,

       catching everything that happens after checkout (renewals, cancellations,

       failed payments) without needing a public webhook endpoint.

  Stripe is always the source of truth; we only ever mirror it locally.

  """

  import Ecto.Query, warn: false

  alias MyApp.Accounts.User

  alias MyApp.Billing.Plans

  alias MyApp.Billing.Stripe, as: StripeAPI

  alias MyApp.Billing.Subscription

  alias MyApp.Repo

  ## Reads

  @doc """

  Returns the user's current live subscription (active, trialing, or past_due),

  or nil. The most recently created one wins if several exist.

  """

  def active_subscription(%User{} = user) do

    Subscription

    |> where(user_id: ^user.id)

    |> where([s], s.status in ^[:active, :trialing, :past_due])

    |> order_by(desc: :inserted_at)

    |> limit(1)

    |> Repo.one()

  end

  @doc "True when the user has a live subscription."

  def subscribed?(%User{} = user), do: active_subscription(user) != nil

  @doc """

  The plan the user is currently on, as a `MyApp.Billing.Plans` map, or nil when

  they have no subscription (or it maps to no known plan).

  """

  def current_plan(%User{} = user) do

    case active_subscription(user) do

      nil -> nil

      %Subscription{stripe_price_id: price_id} -> Plans.for_price_id(price_id)

    end

  end

  @doc "Lists every subscription row for a user, newest first."

  def list_subscriptions(%User{} = user) do

    Subscription

    |> where(user_id: ^user.id)

    |> order_by(desc: :inserted_at)

    |> Repo.all()

  end

  ## Stripe customer

  @doc """

  Returns the user's Stripe Customer id, creating the customer on first use and

  persisting it so future checkouts and portal sessions reuse it.

  """

  def ensure_customer(%User{stripe_customer_id: id} = _user) when is_binary(id), do: {:ok, id}

  def ensure_customer(%User{} = user) do

    with {:ok, customer_id} <- StripeAPI.create_customer(user),

         {:ok, _user} <- save_customer_id(user, customer_id) do

      {:ok, customer_id}

    end

  end

  defp save_customer_id(user, customer_id) do

    user

    |> Ecto.Changeset.change(stripe_customer_id: customer_id)

    |> Repo.update()

  end

  ## Checkout

  @doc """

  Starts a Stripe Checkout Session for `plan_id`. Returns `{:ok, %{id, url}}` —

  redirect the user to `url`. Fails with `:unknown_plan` or `:plan_not_purchasable`

  when the plan doesn't exist or has no Stripe Price configured.

  """

  def create_checkout_session(%User{} = user, plan_id, success_url, cancel_url) do

    with %{} = plan <- Plans.get(plan_id) || {:error, :unknown_plan},

         price_id when is_binary(price_id) <-

           Plans.stripe_price_id(plan) || {:error, :plan_not_purchasable},

         {:ok, customer_id} <- ensure_customer(user) do

      StripeAPI.create_checkout_session(user, customer_id, price_id, success_url, cancel_url)

    else

      {:error, _} = err -> err

    end

  end

  @doc """

  Polls a completed Checkout Session and syncs the resulting subscription.

  Returns `{:ok, %Subscription{}}`, `{:ok, :pending}` (payment still

  processing), or `{:error, reason}`.

  """

  def sync_checkout_session(%User{} = user, session_id) do

    with {:ok, session} <- StripeAPI.fetch_checkout_session(session_id),

         sub_id when is_binary(sub_id) <- session.subscription || {:ok, :pending},

         {:ok, sub} <- StripeAPI.fetch_subscription(sub_id) do

      upsert_subscription(user, sub)

    else

      {:ok, :pending} -> {:ok, :pending}

      {:error, _} = err -> err

    end

  end

  ## Customer Portal

  @doc """

  Creates a Stripe Customer Portal session for the user to manage their

  subscription. Returns `{:ok, url}` or `{:error, :no_customer}` if they've

  never started a checkout.

  """

  def create_customer_portal_session(%User{stripe_customer_id: nil}, _return_url),

    do: {:error, :no_customer}

  def create_customer_portal_session(%User{stripe_customer_id: customer_id}, return_url)

      when is_binary(customer_id) do

    StripeAPI.create_customer_portal_session(customer_id, return_url)

  end

  ## Sync

  @doc """

  Inserts or updates the local subscription mirror from a normalized Stripe

  subscription map (see `MyApp.Billing.Stripe`). Upserts on the Stripe

  subscription id, so the return-poll and the event poller are idempotent and

  can race safely.

  """

  def upsert_subscription(%User{} = user, sub) do

    attrs = %{

      user_id: user.id,

      stripe_subscription_id: sub.id,

      stripe_customer_id: sub.customer,

      stripe_price_id: sub.price_id,

      status: status_from_stripe(sub.status),

      current_period_end: sub.current_period_end,

      cancel_at_period_end: sub.cancel_at_period_end || false,

      canceled_at: sub.canceled_at

    }

    case Repo.get_by(Subscription, stripe_subscription_id: sub.id) do

      nil -> %Subscription{}

      existing -> existing

    end

    |> Subscription.changeset(attrs)

    |> Repo.insert_or_update()

  end

  # Map Stripe's subscription statuses onto our enum.

  defp status_from_stripe("active"), do: :active

  defp status_from_stripe("trialing"), do: :trialing

  defp status_from_stripe("past_due"), do: :past_due

  defp status_from_stripe("unpaid"), do: :past_due

  defp status_from_stripe("canceled"), do: :canceled

  defp status_from_stripe("incomplete_expired"), do: :canceled

  defp status_from_stripe("incomplete"), do: :incomplete

  defp status_from_stripe(_), do: :incomplete

  ## Event handling

  @doc """

  Handles a single Stripe event from the poller. We only act on

  `customer.subscription.*` events; everything else is ignored. Always returns

  `:ok` so one unhandled event never stalls the poller's checkpoint.

  """

  def handle_stripe_event(%{"type" => "customer.subscription." <> _} = event) do

    handle_subscription_event(event)

    :ok

  end

  def handle_stripe_event(_event), do: :ok

  defp handle_subscription_event(event) do

    object = get_in(event, ["data", "object"]) || %{}

    sub_id = object["id"]

    customer_id = object["customer"]

    # We re-fetch the subscription from Stripe rather than trusting the event

    # payload, because events are point-in-time snapshots that may already be

    # stale by the time we process them.

    with user when not is_nil(user) <- find_user_for_event(sub_id, customer_id),

         sub_id when is_binary(sub_id) <- sub_id,

         {:ok, sub} <- StripeAPI.fetch_subscription(sub_id) do

      upsert_subscription(user, sub)

    end

  end

  # Prefer an existing local subscription (cheap, exact); fall back to mapping

  # the Stripe customer to a user for brand-new subscriptions.

  defp find_user_for_event(sub_id, customer_id) do

    with nil <- user_by_subscription(sub_id),

         nil <- user_by_customer(customer_id) do

      nil

    end

  end

  defp user_by_subscription(nil), do: nil

  defp user_by_subscription(sub_id) do

    case Repo.get_by(Subscription, stripe_subscription_id: sub_id) do

      %Subscription{user_id: user_id} -> Repo.get(User, user_id)

      nil -> nil

    end

  end

  defp user_by_customer(nil), do: nil

  defp user_by_customer(customer_id), do: Repo.get_by(User, stripe_customer_id: customer_id)

end

defmodule MyApp.Billing.Plans do

  @moduledoc """

  The catalog of subscription plans the app offers.

  Plan *metadata* (name, blurb, displayed price, feature list) lives here in

  code so it's versioned and easy to reason about. The live Stripe Price id is

  pulled from config, because it differs per environment/account and shouldn't

  be hard-coded:

      config :my_app, :billing,

        price_ids: %{pro: "price_...", business: "price_..."}

  A plan is only *purchasable* once its price id is configured, so an

  unconfigured plan simply doesn't show a buy button (handy in dev/stub mode).

  The displayed `amount` is for presentation only — Stripe charges whatever the

  Price says, so the two should be kept in agreement.

  """

  @plans [

    %{

      id: :pro,

      name: "Pro",

      description: "For individuals and small teams getting started.",

      amount: "$19",

      interval: "month",

      features: [

        "Everything in Free",

        "Unlimited projects",

        "Priority email support"

      ]

    },

    %{

      id: :business,

      name: "Business",

      description: "For growing teams that need more.",

      amount: "$49",

      interval: "month",

      features: [

        "Everything in Pro",

        "Team roles & permissions",

        "Audit log",

        "SSO"

      ]

    }

  ]

  @doc "All known plans, in display order."

  def all, do: @plans

  @doc "Fetches a plan by id (atom or string). Returns nil when unknown."

  def get(id) when is_atom(id), do: Enum.find(@plans, &(&1.id == id))

  def get(id) when is_binary(id) do

    case Enum.find(@plans, &(Atom.to_string(&1.id) == id)) do

      nil -> nil

      plan -> plan

    end

  end

  @doc """

  Plans that can currently be purchased — i.e. that have a Stripe Price id

  configured. In stub mode (no price ids set) this is empty.

  """

  def purchasable do

    Enum.filter(@plans, &(stripe_price_id(&1) != nil))

  end

  @doc "The configured Stripe Price id for a plan, or nil if not configured."

  def stripe_price_id(%{id: id}), do: stripe_price_id(id)

  def stripe_price_id(id) when is_atom(id) do

    :my_app

    |> Application.get_env(:billing, [])

    |> Keyword.get(:price_ids, %{})

    |> Map.get(id)

  end

  @doc "Finds the plan that owns a given Stripe Price id, or nil."

  def for_price_id(nil), do: nil

  def for_price_id(price_id) when is_binary(price_id) do

    Enum.find(@plans, &(stripe_price_id(&1) == price_id))

  end

end

defmodule MyApp.Billing.Stripe do

  @moduledoc """

  The Stripe API surface for subscription billing.

  Two design choices worth calling out:

    * **Normalized returns.** Every function returns plain maps with a fixed

      shape, never raw `Stripe.*` structs. Stripe's struct shapes shift between

      API versions; keeping that churn in one module means the rest of the app

      (and its tests) work against a stable contract.

    * **Stub mode.** When no API key is configured

      (`config :stripity_stripe, api_key: ...`), every call returns a believable

      stub instead of hitting the network. The stub threads the selected price

      through the checkout → session → subscription round-trip, so you can click

      the entire subscribe flow locally before wiring up real keys.

  """

  require Logger

  alias MyApp.Accounts.User

  @stub_session_prefix "cs_stub_"

  @stub_subscription_prefix "sub_stub_"

  defp configured? do

    is_binary(Application.get_env(:stripity_stripe, :api_key))

  end

  ## Customers

  @doc "Creates a Stripe Customer for a user. Returns `{:ok, customer_id}`."

  def create_customer(%User{} = user) do

    if configured?() do

      params = %{email: user.email, metadata: %{user_id: user.id}}

      case Stripe.Customer.create(params) do

        {:ok, %{id: id}} -> {:ok, id}

        {:error, err} -> log_and_wrap("create_customer", err)

      end

    else

      stub_log("create_customer", user: user.id)

      {:ok, "cus_stub_#{user.id}"}

    end

  end

  ## Checkout

  @doc """

  Creates a subscription-mode Checkout Session for `price_id`, billed to the

  user's existing Stripe Customer. Returns `{:ok, %{id, url}}`.

  Promo codes are enabled so you can run discounts from the Stripe dashboard

  without redeploying.

  """

  def create_checkout_session(%User{} = user, customer_id, price_id, success_url, cancel_url) do

    if configured?() do

      params = %{

        mode: "subscription",

        customer: customer_id,

        line_items: [%{price: price_id, quantity: 1}],

        allow_promotion_codes: true,

        success_url: success_url <> "?session_id={CHECKOUT_SESSION_ID}",

        cancel_url: cancel_url,

        client_reference_id: user.id

      }

      case Stripe.Checkout.Session.create(params) do

        {:ok, session} -> {:ok, %{id: session.id, url: session.url}}

        {:error, err} -> log_and_wrap("create_checkout_session", err)

      end

    else

      # Encode the price into the stub session id so the rest of the stubbed

      # round-trip can reconstruct which plan was bought.

      session_id = @stub_session_prefix <> encode_stub(price_id)

      stub_log("create_checkout_session", user: user.id, price: price_id)

      {:ok, %{id: session_id, url: success_url <> "?session_id=#{session_id}"}}

    end

  end

  @doc """

  Fetches a Checkout Session by id. Returns a normalized map:

  `%{id, payment_status, subscription, client_reference_id}`. `subscription` is

  the created subscription id (or nil if the session hasn't produced one yet).

  """

  def fetch_checkout_session(session_id) do

    if configured?() do

      case Stripe.Checkout.Session.retrieve(session_id) do

        {:ok, session} ->

          {:ok,

           %{

             id: session.id,

             payment_status: session.payment_status,

             subscription: session.subscription,

             client_reference_id: session.client_reference_id

           }}

        {:error, err} ->

          log_and_wrap("fetch_checkout_session", err)

      end

    else

      stub_log("fetch_checkout_session", session: session_id)

      {:ok,

       %{

         id: session_id,

         payment_status: "paid",

         subscription: stub_subscription_id_for(session_id),

         client_reference_id: nil

       }}

    end

  end

  ## Subscriptions

  @doc """

  Fetches a subscription by id. Returns a normalized map:

  `%{id, customer, price_id, status, current_period_end, cancel_at_period_end,

  canceled_at}`.

  """

  def fetch_subscription(subscription_id) do

    if configured?() do

      case Stripe.Subscription.retrieve(subscription_id) do

        {:ok, sub} -> {:ok, normalize_subscription(sub)}

        {:error, err} -> log_and_wrap("fetch_subscription", err)

      end

    else

      stub_log("fetch_subscription", subscription: subscription_id)

      {:ok, stub_subscription(subscription_id)}

    end

  end

  ## Customer Portal

  @doc """

  Creates a Stripe Customer Portal session so the user can manage or cancel

  their subscription. Returns `{:ok, url}`.

  """

  def create_customer_portal_session(customer_id, return_url) do

    if configured?() do

      params = %{customer: customer_id, return_url: return_url}

      case Stripe.BillingPortal.Session.create(params) do

        {:ok, %{url: url}} -> {:ok, url}

        {:error, err} -> log_and_wrap("create_customer_portal_session", err)

      end

    else

      stub_log("create_customer_portal_session", customer: customer_id)

      {:ok, return_url <> "?stub_portal=true"}

    end

  end

  ## Events (consumed by the poller)

  @doc """

  Lists platform events, newest first, for `MyApp.Workers.StripeEventsPoller`.

  Supported opts: `ending_before` (cursor — Stripe returns events newer than

  this id) and `limit` (defaults to 100, Stripe's max). Each event is normalized

  to a string-keyed map (`"id"`, `"type"`, `"created"`, `"data"`). In stub mode

  returns `{:ok, []}` so the poller is a local no-op.

  """

  def list_events(opts \\ []) do

    if configured?() do

      params = %{limit: Keyword.get(opts, :limit, 100)}

      params =

        case Keyword.get(opts, :ending_before) do

          nil -> params

          cursor when is_binary(cursor) -> Map.put(params, :ending_before, cursor)

        end

      case Stripe.Event.list(params) do

        {:ok, %{data: events}} -> {:ok, Enum.map(events, &normalize_event/1)}

        {:error, err} -> log_and_wrap("list_events", err)

      end

    else

      stub_log("list_events", opts: opts)

      {:ok, []}

    end

  end

  ## Normalization helpers

  defp normalize_subscription(sub) do

    %{

      id: sub.id,

      customer: sub.customer,

      price_id: extract_price_id(sub),

      status: sub.status,

      current_period_end: from_unix(Map.get(sub, :current_period_end)),

      cancel_at_period_end: Map.get(sub, :cancel_at_period_end) || false,

      canceled_at: from_unix(Map.get(sub, :canceled_at))

    }

  end

  # A subscription's price lives on its first line item.

  defp extract_price_id(%{items: %{data: [%{price: %{id: id}} | _]}}), do: id

  defp extract_price_id(_), do: nil

  # Stripe event structs carry atom keys; normalize to string-keyed maps so

  # handlers can pattern-match on `"type"` regardless of source (live, stub).

  defp normalize_event(%Stripe.Event{} = event) do

    %{

      "id" => event.id,

      "type" => event.type,

      "created" => event.created,

      "data" => deep_stringify(event.data)

    }

  end

  defp deep_stringify(%_{} = struct), do: struct |> Map.from_struct() |> deep_stringify()

  defp deep_stringify(map) when is_map(map),

    do: Map.new(map, fn {k, v} -> {to_string(k), deep_stringify(v)} end)

  defp deep_stringify(list) when is_list(list), do: Enum.map(list, &deep_stringify/1)

  defp deep_stringify(other), do: other

  defp from_unix(nil), do: nil

  defp from_unix(0), do: nil

  defp from_unix(unix) when is_integer(unix), do: DateTime.from_unix!(unix)

  ## Stub helpers

  # The stub round-trip encodes the price id into the session/subscription ids

  # so a configured-but-keyless dev environment produces a believable, fully

  # attributed subscription.

  defp encode_stub(nil), do: "none"

  defp encode_stub(price_id) when is_binary(price_id),

    do: Base.url_encode64(price_id, padding: false)

  defp decode_stub("none"), do: nil

  defp decode_stub(encoded), do: Base.url_decode64!(encoded, padding: false)

  defp stub_subscription_id_for(@stub_session_prefix <> encoded),

    do: @stub_subscription_prefix <> encoded

  defp stub_subscription_id_for(_), do: @stub_subscription_prefix <> "none"

  defp stub_subscription(@stub_subscription_prefix <> encoded = sub_id) do

    %{

      id: sub_id,

      customer: "cus_stub",

      price_id: decode_stub(encoded),

      status: "active",

      current_period_end: DateTime.add(DateTime.utc_now(:second), 30, :day),

      cancel_at_period_end: false,

      canceled_at: nil

    }

  end

  defp stub_subscription(sub_id) do

    %{

      id: sub_id,

      customer: "cus_stub",

      price_id: nil,

      status: "active",

      current_period_end: DateTime.add(DateTime.utc_now(:second), 30, :day),

      cancel_at_period_end: false,

      canceled_at: nil

    }

  end

  ## Logging

  defp log_and_wrap(action, %Stripe.ApiErrors{} = err) do

    Logger.error("[Billing.Stripe] #{action} failed: #{err.message} (code: #{err.code})")

    {:error, err.message || "Stripe request failed"}

  end

  defp log_and_wrap(action, err) do

    Logger.error("[Billing.Stripe] #{action} failed: #{inspect(err)}")

    {:error, "Stripe request failed"}

  end

  defp stub_log(action, meta) do

    Logger.info("[Billing.Stripe stub] #{action} #{inspect(meta)}")

  end

end

defmodule MyApp.Billing.Stripe.Checkpoint do

  @moduledoc """

  Tracks where each Stripe event-polling stream left off, so the next poll can

  ask Stripe for *only* events newer than what we've already processed.

  Billing polls a single source — `"platform"` — but the table is generic so a

  future Stripe Connect feature can add `"connect:acct_xxx"` streams.

  See `MyApp.Workers.StripeEventsPoller`.

  """

  use Ecto.Schema

  import Ecto.Changeset

  import Ecto.Query

  alias MyApp.Repo

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

  schema "stripe_event_checkpoints" do

    field :source, :string

    field :last_event_id, :string

    field :last_polled_at, :utc_datetime

    timestamps(type: :utc_datetime)

  end

  def changeset(checkpoint, attrs) do

    checkpoint

    |> cast(attrs, [:source, :last_event_id, :last_polled_at])

    |> validate_required([:source])

    |> unique_constraint(:source)

  end

  @doc "Returns the checkpoint for a source, or nil if none exists."

  def get(source) when is_binary(source) do

    Repo.get_by(__MODULE__, source: source)

  end

  @doc """

  Records the most recently seen event id for a source. Inserts the checkpoint

  row on first call.

  """

  def update(source, last_event_id) when is_binary(source) do

    now = DateTime.utc_now(:second)

    case get(source) do

      nil ->

        %__MODULE__{}

        |> changeset(%{source: source, last_event_id: last_event_id, last_polled_at: now})

        |> Repo.insert()

      checkpoint ->

        checkpoint

        |> changeset(%{last_event_id: last_event_id, last_polled_at: now})

        |> Repo.update()

    end

  end

  @doc "Builds the canonical source key for a polling scope."

  def source_key(:platform), do: "platform"

  @doc "Lists every checkpoint we know about — for admin/debug surfaces."

  def list do

    from(c in __MODULE__, order_by: c.source) |> Repo.all()

  end

end

defmodule MyApp.Billing.Subscription do

  @moduledoc """

  A local mirror of a Stripe Subscription belonging to a user.

  Stripe is the source of truth — these rows are kept in sync from two places:

  the checkout-return poll (`MyApp.Billing.sync_checkout_session/2`) and the

  event poller (`MyApp.Workers.StripeEventsPoller`). We never compute billing

  state ourselves; we only reflect what Stripe reports.

  """

  use Ecto.Schema

  import Ecto.Changeset

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

  @foreign_key_type :binary_id

  # Mirrors Stripe's subscription statuses we care about. `incomplete_expired`

  # and `unpaid` are folded into `canceled`/`past_due` in the context layer.

  @statuses ~w(active trialing past_due canceled incomplete)a

  schema "subscriptions" do

    field :stripe_subscription_id, :string

    field :stripe_customer_id, :string

    field :stripe_price_id, :string

    field :status, Ecto.Enum, values: @statuses

    field :current_period_end, :utc_datetime

    field :cancel_at_period_end, :boolean, default: false

    field :canceled_at, :utc_datetime

    belongs_to :user, MyApp.Accounts.User

    timestamps(type: :utc_datetime)

  end

  def statuses, do: @statuses

  def changeset(subscription, attrs) do

    subscription

    |> cast(attrs, [

      :user_id,

      :stripe_subscription_id,

      :stripe_customer_id,

      :stripe_price_id,

      :status,

      :current_period_end,

      :cancel_at_period_end,

      :canceled_at

    ])

    |> validate_required([

      :user_id,

      :stripe_subscription_id,

      :stripe_customer_id,

      :status

    ])

    |> unique_constraint(:stripe_subscription_id)

  end

  @doc """

  True when the subscription still grants access — active, trialing, or in the

  grace period of a failed payment (`past_due`).

  """

  def active?(%__MODULE__{status: status}), do: status in [:active, :trialing, :past_due]

  def active?(_), do: false

end

defmodule MyApp.Workers.StripeEventsPoller do

  @moduledoc """

  Drains Stripe's `/v1/events` stream and dispatches each event to

  `MyApp.Billing.handle_stripe_event/1`.

  This is what keeps local subscription state in sync *after* checkout —

  renewals, cancellations, failed payments — without exposing a public webhook

  endpoint. An Oban cron entry runs it every minute (see `config/config.exs`).

  A `MyApp.Billing.Stripe.Checkpoint` row remembers the last processed event id,

  so each run fetches only new events. On the very first run (no checkpoint) we

  *bootstrap*: record the latest event id without processing it, so we don't

  replay the account's entire event history.

  The `unique` clause covers the 60s cron interval (doubled for safety): if a

  poll is still running when the next tick fires, the duplicate is dropped

  instead of piling up.

  """

  use Oban.Worker,

    queue: :stripe_sync,

    max_attempts: 3,

    unique: [period: 120, fields: [:worker, :args]]

  require Logger

  alias MyApp.Billing

  alias MyApp.Billing.Stripe, as: StripeAPI

  alias MyApp.Billing.Stripe.Checkpoint

  @impl Oban.Worker

  def perform(_job), do: poll()

  defp poll do

    source = Checkpoint.source_key(:platform)

    case Checkpoint.get(source) do

      nil -> bootstrap(source)

      %Checkpoint{last_event_id: nil} -> bootstrap(source)

      %Checkpoint{last_event_id: last_id} -> drain(source, last_id)

    end

  end

  # First run: record the most recent event id without processing anything

  # older, so we don't replay months of history.

  defp bootstrap(source) do

    case StripeAPI.list_events(limit: 1) do

      {:ok, [%{"id" => id} | _]} ->

        Checkpoint.update(source, id)

        :ok

      {:ok, []} ->

        # No events yet — mark as polled so we don't keep bootstrapping.

        Checkpoint.update(source, nil)

        :ok

      {:error, reason} ->

        {:error, reason}

    end

  end

  defp drain(source, last_event_id) do

    case StripeAPI.list_events(ending_before: last_event_id) do

      {:ok, []} ->

        # Nothing new — refresh last_polled_at, keep the cursor.

        Checkpoint.update(source, last_event_id)

        :ok

      {:ok, events} ->

        # Stripe returns newest-first; process oldest-first so a partial crash

        # leaves the oldest unprocessed event as the next checkpoint target.

        events

        |> Enum.reverse()

        |> Enum.each(&Billing.handle_stripe_event/1)

        newest_id = events |> List.first() |> Map.fetch!("id")

        Checkpoint.update(source, newest_id)

        :ok

      {:error, reason} ->

        Logger.error("[StripeEventsPoller] #{source}: list_events failed: #{inspect(reason)}")

        {:error, reason}

    end

  end

end

defmodule MyAppWeb.BillingController do

  @moduledoc """

  Handles the return leg of Stripe Checkout.

  Stripe redirects the user here with `?session_id=...` after a successful

  checkout. We poll the session immediately and sync the subscription, so the

  billing page reflects the new state right away — we don't wait on the event

  poller for the happy path.

  """

  use MyAppWeb, :controller

  alias MyApp.Billing

  def return(conn, %{"session_id" => session_id}) do

    user = conn.assigns.current_scope.user

    case Billing.sync_checkout_session(user, session_id) do

      {:ok, %Billing.Subscription{}} ->

        conn

        |> put_flash(:info, "You're subscribed — thanks!")

        |> redirect(to: ~p"/billing")

      {:ok, :pending} ->

        conn

        |> put_flash(:info, "Payment is processing. Your subscription will activate shortly.")

        |> redirect(to: ~p"/billing")

      {:error, _reason} ->

        conn

        |> put_flash(:error, "We couldn't confirm your subscription. Please contact support.")

        |> redirect(to: ~p"/billing")

    end

  end

  def return(conn, _params) do

    conn

    |> put_flash(:error, "Missing checkout session.")

    |> redirect(to: ~p"/billing")

  end

end

defmodule MyAppWeb.BillingLive do

  @moduledoc """

  The user's billing page: shows their current subscription (if any), lets them

  manage it through the Stripe Customer Portal, and lists the plans they can

  subscribe to.

  Subscribing redirects out to Stripe Checkout; the user comes back through

  `MyAppWeb.BillingController.return/2`.

  """

  use MyAppWeb, :live_view

  alias MyApp.Billing

  alias MyApp.Billing.Plans

  @impl true

  def mount(_params, _session, socket) do

    {:ok, assign_billing(socket)}

  end

  defp assign_billing(socket) do

    user = socket.assigns.current_scope.user

    subscription = Billing.active_subscription(user)

    socket

    |> assign(:page_title, "Billing")

    |> assign(:subscription, subscription)

    |> assign(:current_plan, Billing.current_plan(user))

    |> assign(:plans, Plans.purchasable())

  end

  @impl true

  def handle_event("subscribe", %{"plan" => plan_id}, socket) do

    user = socket.assigns.current_scope.user

    success_url = url(~p"/billing/return")

    cancel_url = url(~p"/billing")

    case Billing.create_checkout_session(user, plan_id, success_url, cancel_url) do

      {:ok, %{url: checkout_url}} ->

        {:noreply, redirect(socket, external: checkout_url)}

      {:error, _reason} ->

        {:noreply, put_flash(socket, :error, "Could not start checkout. Please try again.")}

    end

  end

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

    user = socket.assigns.current_scope.user

    return_url = url(~p"/billing")

    case Billing.create_customer_portal_session(user, return_url) do

      {:ok, portal_url} ->

        {:noreply, redirect(socket, external: portal_url)}

      {:error, _reason} ->

        {:noreply,

         put_flash(socket, :error, "Could not open the billing portal. Please try again.")}

    end

  end

  @impl true

  def render(assigns) do

    ~H"""

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

      <.header>

        Billing

        <:subtitle>Manage your subscription and plan.</:subtitle>

      </.header>

      <section :if={@subscription} class="border-base-300 mt-8 border p-5 sm:p-6">

        <div class="flex items-start justify-between gap-4">

          <div>

            <p class="text-base-content/60 text-sm">Current plan</p>

            <p class="text-lg font-semibold">

              {(@current_plan && @current_plan.name) || "Subscription"}

            </p>

            <p class="mt-1">

              <.status_badge subscription={@subscription} />

            </p>

            <p :if={@subscription.current_period_end} class="text-base-content/70 mt-2 text-sm">

              {renewal_line(@subscription)}

            </p>

          </div>

          <.button phx-click="manage" phx-disable-with="Opening…">

            Manage billing

          </.button>

        </div>

      </section>

      <section class="mt-10 space-y-3">

        <h2 class="text-lg font-semibold">

          {if @subscription, do: "Change plan", else: "Choose a plan"}

        </h2>

        <p :if={@plans == []} class="text-base-content/60 text-sm">

          No plans are available yet. Configure Stripe Price ids in

          <code>config :my_app, :billing, price_ids: ...</code>

          to enable checkout.

        </p>

        <div

          :for={plan <- @plans}

          class="border-base-content/10 border p-4"

        >

          <div class="flex items-start justify-between gap-4">

            <div class="flex-1">

              <p class="font-medium">{plan.name}</p>

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

              <p class="mt-2 text-2xl font-semibold">

                {plan.amount}

                <span class="text-base-content/60 text-sm font-normal">

                  per {plan.interval}

                </span>

              </p>

              <ul class="text-base-content/70 mt-3 space-y-1 text-sm">

                <li :for={feature <- plan.features} class="flex items-center gap-2">

                  <.icon name="hero-check-circle" class="size-4 text-success" />

                  {feature}

                </li>

              </ul>

            </div>

            <div class="shrink-0">

              <span

                :if={current_plan?(@current_plan, plan)}

                class="border-base-content/10 text-base-content/60 inline-block border px-4 py-2 text-sm"

              >

                Current plan

              </span>

              <.button

                :if={not current_plan?(@current_plan, plan)}

                variant="primary"

                phx-click="subscribe"

                phx-value-plan={plan.id}

                phx-disable-with="Redirecting…"

              >

                {if @subscription, do: "Switch", else: "Subscribe"}

              </.button>

            </div>

          </div>

        </div>

      </section>

    </Layouts.app>

    """

  end

  attr :subscription, :map, required: true

  defp status_badge(assigns) do

    ~H"""

    <span class={[

      "inline-block px-2 py-0.5 text-xs font-medium",

      badge_class(@subscription.status)

    ]}>

      {status_label(@subscription)}

    </span>

    """

  end

  defp badge_class(:active), do: "bg-success/10 text-success"

  defp badge_class(:trialing), do: "bg-info/10 text-info"

  defp badge_class(:past_due), do: "bg-warning/10 text-warning"

  defp badge_class(_), do: "bg-base-200 text-base-content/60"

  defp status_label(%{cancel_at_period_end: true}), do: "Cancels at period end"

  defp status_label(%{status: :active}), do: "Active"

  defp status_label(%{status: :trialing}), do: "Trial"

  defp status_label(%{status: :past_due}), do: "Past due"

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

  defp renewal_line(%{cancel_at_period_end: true, current_period_end: ends_at}),

    do: "Access ends #{format_date(ends_at)}"

  defp renewal_line(%{current_period_end: renews_at}),

    do: "Renews #{format_date(renews_at)}"

  defp format_date(%DateTime{} = dt), do: Calendar.strftime(dt, "%B %-d, %Y")

  defp current_plan?(nil, _plan), do: false

  defp current_plan?(%{id: id}, %{id: id}), do: true

  defp current_plan?(_current, _plan), do: false

end

      live "/billing", BillingLive, :index

    # Stripe Checkout redirects the user back here after paying.

    get "/billing/return", BillingController, :return

defmodule MyApp.Repo.Migrations.AddObanJobsTable do

  use Ecto.Migration

  def up, do: Oban.Migration.up(version: 14)

  def down, do: Oban.Migration.down(version: 1)

end

defmodule MyApp.Repo.Migrations.CreateBillingTables do

  use Ecto.Migration

  def change do

    # Each user maps to exactly one Stripe Customer. We store the id on the

    # user so we can reuse the same customer across checkouts and open the

    # billing portal without creating duplicates.

    alter table(:users) do

      add :stripe_customer_id, :string

    end

    create unique_index(:users, [:stripe_customer_id])

    # A local mirror of a Stripe Subscription. Stripe is the source of truth;

    # rows here are kept in sync by the checkout-return poll and the event

    # poller. A user can accumulate several rows over time (cancel + resubscribe

    # creates a new Stripe subscription), so `user_id` is not unique — the

    # "current" subscription is the one whose status is still live.

    create table(:subscriptions, 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 :stripe_subscription_id, :string, null: false

      add :stripe_customer_id, :string, null: false

      add :stripe_price_id, :string

      add :status, :string, null: false

      add :current_period_end, :utc_datetime

      add :cancel_at_period_end, :boolean, default: false, null: false

      add :canceled_at, :utc_datetime

      timestamps(type: :utc_datetime)

    end

    create unique_index(:subscriptions, [:stripe_subscription_id])

    create index(:subscriptions, [:user_id])

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

    # Polling cursor for the Stripe event stream. One row per source; the

    # billing feature only polls the platform account, but the column is kept

    # generic so a future Stripe Connect feature can add per-account streams.

    create table(:stripe_event_checkpoints, primary_key: false) do

      add :id, :binary_id, primary_key: true

      add :source, :string, null: false

      add :last_event_id, :string

      add :last_polled_at, :utc_datetime

      timestamps(type: :utc_datetime)

    end

    create unique_index(:stripe_event_checkpoints, [:source])

  end

end

defmodule MyApp.BillingTest do

  use MyApp.DataCase, async: true

  alias MyApp.Billing

  alias MyApp.Billing.Plans

  alias MyApp.Billing.Subscription

  import MyApp.AccountsFixtures

  describe "ensure_customer/1" do

    test "creates and persists a Stripe customer id, and is idempotent" do

      user = user_fixture()

      refute user.stripe_customer_id

      assert {:ok, customer_id} = Billing.ensure_customer(user)

      assert is_binary(customer_id)

      reloaded = Repo.get!(MyApp.Accounts.User, user.id)

      assert reloaded.stripe_customer_id == customer_id

      # Second call reuses the stored id rather than creating a new customer.

      assert {:ok, ^customer_id} = Billing.ensure_customer(reloaded)

    end

  end

  describe "create_checkout_session/4" do

    test "returns a checkout url for a purchasable plan" do

      user = user_fixture()

      assert {:ok, %{id: session_id, url: url}} =

               Billing.create_checkout_session(

                 user,

                 "pro",

                 "https://x/return",

                 "https://x/billing"

               )

      assert is_binary(session_id)

      assert url =~ "session_id="

    end

    test "rejects unknown plans" do

      user = user_fixture()

      assert {:error, :unknown_plan} =

               Billing.create_checkout_session(

                 user,

                 "nope",

                 "https://x/return",

                 "https://x/billing"

               )

    end

  end

  describe "sync_checkout_session/2 (stub flow)" do

    test "creates an active subscription mapped to the purchased plan" do

      user = user_fixture()

      {:ok, %{id: session_id}} =

        Billing.create_checkout_session(user, "pro", "https://x/return", "https://x/billing")

      assert {:ok, %Subscription{} = sub} = Billing.sync_checkout_session(user, session_id)

      assert sub.status == :active

      assert sub.user_id == user.id

      assert Billing.subscribed?(user)

      assert Billing.current_plan(user) == Plans.get(:pro)

    end

  end

  describe "upsert_subscription/2" do

    test "is idempotent on the Stripe subscription id" do

      user = user_fixture()

      sub = %{

        id: "sub_123",

        customer: "cus_123",

        price_id: "price_test_pro",

        status: "active",

        current_period_end: DateTime.utc_now(:second),

        cancel_at_period_end: false,

        canceled_at: nil

      }

      assert {:ok, first} = Billing.upsert_subscription(user, sub)

      assert {:ok, second} = Billing.upsert_subscription(user, %{sub | status: "past_due"})

      assert first.id == second.id

      assert second.status == :past_due

      assert Repo.aggregate(Subscription, :count) == 1

    end

  end

  describe "handle_stripe_event/1" do

    test "ignores unrelated events" do

      assert :ok = Billing.handle_stripe_event(%{"type" => "invoice.paid", "data" => %{}})

    end

    test "resyncs the subscription on customer.subscription.* events" do

      user = user_fixture()

      {:ok, %{id: session_id}} =

        Billing.create_checkout_session(user, "pro", "https://x/return", "https://x/billing")

      {:ok, sub} = Billing.sync_checkout_session(user, session_id)

      event = %{

        "type" => "customer.subscription.updated",

        "data" => %{

          "object" => %{"id" => sub.stripe_subscription_id, "customer" => sub.stripe_customer_id}

        }

      }

      assert :ok = Billing.handle_stripe_event(event)

      assert Billing.subscribed?(user)

    end

  end

end