Rails Inertia Stripe Billing

# frozen_string_literal: true

module Admin
  module Accounts
    class BillingWaiversController < Admin::BaseController
      before_action :set_account

      def create
        @account.comp
        redirect_back fallback_location: admin_customers_path, notice: "Account comped."
      end

      def destroy
        @account.uncomp
        redirect_back fallback_location: admin_customers_path, notice: "Account uncomped."
      end

      private
        def set_account
          @account = Account.find_by!(external_account_id: params[:account_id])
        end
    end
  end
end

# frozen_string_literal: true

module Admin
  class CustomersController < BaseController
    def index
      base = params[:query].present? ? Identity.search(params[:query]) : Identity.all
      scope = filter_by_status(base)

      pagy, identities = pagy(
        scope.includes(users: { account: :cancellation }).order(sort_column => sort_direction),
        limit: 25
      )

      render inertia: "admin/customers/index", props: {
        customers: identities.map { |i| customer_props(i) },
        pagination: pagination_props(pagy),
        counts: {
          all: base.count,
          active: filter_by_status(base, "active").count,
          cancelled: filter_by_status(base, "cancelled").count,
          suspended: filter_by_status(base, "suspended").count
        },
        filters: {
          status: params[:status] || "all",
          query: params[:query] || "",
          sort: params[:sort] || "created_at",
          direction: params[:direction] || "desc"
        }
      }
    end

    def show
      identity = Identity.includes(users: { account: [ :cancellation, :subscription, :billing_waiver ] }).find(params[:id])

      render inertia: "admin/customers/show", props: {
        customer: customer_detail_props(identity),
        is_self: identity == Current.identity
      }
    end

    private

      def filter_by_status(scope, status = params[:status])
        case status
        when "active" then scope.admin_active
        when "cancelled" then scope.admin_cancelled
        when "suspended" then scope.suspended
        else scope
        end
      end

      def sort_column
        %w[email created_at].include?(params[:sort]) ? params[:sort] : "created_at"
      end

      def sort_direction
        %w[asc desc].include?(params[:direction]) ? params[:direction] : "desc"
      end

      def customer_props(identity)
        {
          id: identity.id,
          email: identity.email,
          name: identity.display_name,
          auth_method: identity.auth_method,
          staff: identity.staff?,
          status: identity.status,
          accounts_count: identity.users.size,
          created_at: identity.created_at.iso8601
        }
      end

      def customer_detail_props(identity)
        {
          id: identity.id,
          email: identity.email,
          name: identity.display_name,
          auth_method: identity.auth_method,
          staff: identity.staff?,
          status: identity.status,
          suspended_at: identity.suspended_at&.iso8601,
          created_at: identity.created_at.iso8601,
          memberships: identity.users.map { |user| membership_props(user) }
        }
      end

      def membership_props(user)
        cancellation = user.account.cancellation
        subscription = user.account.subscription
        plan = membership_plan_for(user.account, subscription)

        {
          id: user.id,
          account_id: user.account.external_account_id,
          account_name: user.account.name,
          role: user.role,
          active: user.active?,
          account_cancelled: user.account.cancelled?,
          days_until_deletion: cancellation ? days_remaining(cancellation) : nil,
          can_reactivate: user.owner? && user.account.cancelled?,
          created_at: user.created_at.iso8601,
          plan_name: plan.name,
          plan_key: plan.key,
          subscription_status: subscription&.status,
          current_period_end: subscription&.current_period_end&.iso8601,
          cancel_at: subscription&.cancel_at&.iso8601,
          to_be_canceled: subscription&.to_be_canceled? || false,
          plan_price: plan.price,
          next_amount_due: subscription&.next_amount_due,
          comped: user.account.comped?,
          stripe_customer_url: stripe_customer_url_for(subscription)
        }
      end

      def membership_plan_for(account, subscription)
        if account.comped?
          account.plan
        elsif subscription
          subscription.plan
        else
          account.plan
        end
      end

      def stripe_customer_url_for(subscription)
        return unless subscription&.stripe_customer_id

        "https://dashboard.stripe.com#{stripe_dashboard_mode_prefix}/customers/#{subscription.stripe_customer_id}"
      end

      def stripe_dashboard_mode_prefix
        if ENV["STRIPE_SECRET_KEY"]&.start_with?("sk_live_")
          ""
        else
          "/test"
        end
      end

      def days_remaining(cancellation)
        seconds = (cancellation.created_at + Account::Incineratable::INCINERATION_GRACE_PERIOD - Time.current)
        [ seconds.to_i / 86400, 0 ].max
      end
  end
end

# frozen_string_literal: true

module Admin
  class DashboardsController < BaseController
    def show
      render inertia: "admin/dashboard/show", props: {
        date_range: date_range.to_h,
        stats: InertiaRails.defer { report.stats },
        comparison: InertiaRails.defer { report.comparison },
        chart_data: InertiaRails.defer { report.chart_data },
        recent_signups: InertiaRails.defer { recent_signups_props },
        comped_accounts: InertiaRails.defer { comped_accounts_props }
      }
    end

    private
      def date_range
        @date_range ||= DashboardDateRange.new(
          preset_id: params[:preset_id],
          start_date: params[:start_date],
          end_date: params[:end_date]
        )
      end

      def report
        @report ||= DashboardReport.new(date_range)
      end

      def recent_signups_props
        Account.order(created_at: :desc).limit(10).includes(:subscription, :billing_waiver, users: :identity).map do |account|
          owner = account.users.find { |u| u.role == "owner" }
          {
            id: account.id,
            name: account.name,
            external_id: account.external_account_id,
            owner_email: owner&.identity&.email,
            owner_identity_id: owner&.identity_id,
            plan_name: account.plan.name,
            comped: account.comped?,
            created_at: account.created_at.iso8601
          }
        end
      end

      def comped_accounts_props
        Account::BillingWaiver.includes(account: { users: :identity }).order(created_at: :desc).limit(20).map do |waiver|
          owner = waiver.account.users.find { |u| u.role == "owner" }
          {
            id: waiver.account.id,
            name: waiver.account.name,
            external_id: waiver.account.external_account_id,
            owner_email: owner&.identity&.email,
            owner_identity_id: owner&.identity_id,
            comped_at: waiver.created_at.iso8601
          }
        end
      end
  end
end

# frozen_string_literal: true

module Admin
  module Settings
    class NotificationsController < Admin::BaseController
      def show
        settings = SiteSetting.current

        render inertia: "admin/settings/notifications/show", props: {
          settings: settings_props(settings)
        }
      end

      def update
        settings = SiteSetting.current

        if settings.update(site_setting_params)
          redirect_to admin_settings_notifications_path, notice: "Notification settings updated."
        else
          redirect_to admin_settings_notifications_path, inertia: inertia_errors(settings)
        end
      end

      private
        def settings_props(settings)
          {
            admin_notification_recipients: settings.admin_notification_recipients,
            notify_admin_new_subscription: settings.notify_admin_new_subscription,
            notify_admin_account_cancellation: settings.notify_admin_account_cancellation
          }
        end

        def site_setting_params
          params.expect(site_setting: [
            :notify_admin_new_subscription,
            :notify_admin_account_cancellation,
            admin_notification_recipients: []
          ])
        end
    end
  end
end

# frozen_string_literal: true

module App
  class BillingPortalsController < BaseController
    include BillingPortalConfiguration

    before_action :ensure_admin
    before_action :ensure_not_comped
    before_action :ensure_has_stripe_customer

    def create
      portal_session = Stripe::BillingPortal::Session.create(
        customer: Current.account.subscription.stripe_customer_id,
        configuration: billing_portal_configuration_id,
        return_url: app_billing_url
      )
      inertia_location portal_session.url
    rescue Stripe::StripeError, BillingPortalConfiguration::MissingConfigurationError => e
      redirect_to app_billing_path, alert: "Billing error: #{e.message}"
    end

    private
      def ensure_not_comped
        if Current.account.comped?
          redirect_to app_billing_path, alert: "Your account has complimentary access."
        end
      end

      def ensure_has_stripe_customer
        unless Current.account.has_stripe_customer?
          redirect_to app_billing_path, alert: "No billing information found."
        end
      end
  end
end

# frozen_string_literal: true

module App
  class BillingsController < BaseController
    before_action :ensure_admin

    def show
      render inertia: "app/billing/show", props: {
        subscription: subscription_props,
        scheduled_plan_change: scheduled_plan_change_props,
        plans: plans_props
      }
    end

    private
      def current_subscription
        @current_subscription ||= Current.account.subscription
      end

      def subscription_props
        sub = current_subscription
        return nil unless sub

        {
          status: sub.status,
          plan_key: sub.plan_key,
          plan_name: sub.plan.name,
          current_period_end: sub.current_period_end&.iso8601,
          cancel_at: sub.cancel_at&.iso8601,
          next_amount_due: sub.next_amount_due,
          to_be_canceled: sub.to_be_canceled?
        }
      end

      def scheduled_plan_change_props
        sub = current_subscription
        return unless sub&.scheduled_plan_change?
        return if sub.scheduled_plan_key == sub.plan_key

        {
          plan_key: sub.scheduled_plan_key,
          starts_at: sub.scheduled_starts_at.iso8601
        }
      end

      def plans_props
        Plan.visible.map do |plan|
          {
            key: plan.key,
            name: plan.name,
            price: plan.price,
            monthly: plan.monthly?,
            yearly: plan.yearly?,
            limits: plan.limits_for_json,
            annual_savings: plan.annual_savings
          }
        end
      end
  end
end

# frozen_string_literal: true

module App
  class SubscriptionsController < BaseController
    before_action :ensure_admin
    before_action :ensure_valid_plan, only: :create
    before_action :ensure_can_checkout, only: :create

    def show
      stripe_session = nil
      selected_plan = Current.account.plan

      if params[:session_id]
        stripe_session = Stripe::Checkout::Session.retrieve(params[:session_id])
        unless stripe_session.metadata["account_id"] == Current.account.id.to_s
          render_error_response(404, "Not Found", "Session not found.")
          return
        end

        selected_plan = Plan[stripe_session.metadata["plan_key"]] || selected_plan
      end

      render inertia: "app/subscription/show", props: {
        stripe_session_status: stripe_session&.payment_status,
        plan_name: selected_plan.name,
        subscription_active: Current.account.active_paid_subscription?
      }
    rescue Stripe::InvalidRequestError
      redirect_to app_billing_path, alert: "Checkout session not found."
    end

    def create
      session = Stripe::Checkout::Session.create(
        customer: find_or_create_stripe_customer,
        mode: "subscription",
        line_items: [ { price: plan_param.stripe_price_id, quantity: 1 } ],
        success_url: app_subscription_url + "?session_id={CHECKOUT_SESSION_ID}",
        cancel_url: app_billing_url,
        metadata: { account_id: Current.account.id, plan_key: plan_param.key },
        automatic_tax: { enabled: true },
        tax_id_collection: { enabled: true },
        billing_address_collection: "required",
        customer_update: { address: "auto", name: "auto" }
      )

      inertia_location session.url
    rescue Stripe::StripeError => e
      redirect_to app_billing_path, alert: "Billing error: #{e.message}"
    end

    private
      def plan_param
        @plan_param ||= Plan[params[:plan_key]]
      end

      def ensure_valid_plan
        unless plan_param&.paid? && plan_param.stripe_price_id.present?
          redirect_to app_billing_path, alert: "Invalid plan selected."
        end
      end

      def ensure_can_checkout
        if Current.account.active_paid_subscription?
          redirect_to app_billing_path, alert: "You already have an active subscription."
        end
      end

      def find_or_create_stripe_customer
        if Current.account.subscription&.stripe_customer_id
          Current.account.subscription.update!(plan_key: plan_param.key, status: "incomplete") unless Current.account.subscription.active?
          Current.account.subscription.stripe_customer_id
        else
          customer = Stripe::Customer.create(
            email: Current.identity.email,
            name: Current.account.name,
            metadata: { account_id: Current.account.id }
          )
          Current.account.create_subscription!(
            stripe_customer_id: customer.id,
            plan_key: plan_param.key,
            status: "incomplete"
          )
          customer.id
        end
      rescue ActiveRecord::RecordNotUnique
        Current.account.reload
        Current.account.subscription.stripe_customer_id
      end
  end
end

# frozen_string_literal: true

module App
  module Subscriptions
    class DowngradesController < UpdatePlanController
      before_action :ensure_yearly_plan

      private
        def target_plan = Plan.monthly

        def ensure_yearly_plan
          unless Current.account.plan.yearly?
            render_error_response(400, "Bad Request", "Can only downgrade from yearly plan.")
          end
        end
    end
  end
end

# frozen_string_literal: true

module App
  module Subscriptions
    class UpdatePlanController < App::BaseController
      include BillingPortalConfiguration

      before_action :ensure_admin
      before_action :ensure_active_subscription

      def create
        portal_session = Stripe::BillingPortal::Session.create(
          customer: subscription.stripe_customer_id,
          configuration: billing_portal_configuration_id,
          return_url: app_billing_url,
          flow_data: {
            type: "subscription_update_confirm",
            subscription_update_confirm: {
              subscription: subscription.stripe_subscription_id,
              items: [ { id: stripe_subscription_item_id, price: target_plan.stripe_price_id } ]
            },
            after_completion: {
              type: "redirect",
              redirect: { return_url: app_billing_url }
            }
          }
        )
        inertia_location portal_session.url
      rescue Stripe::StripeError, BillingPortalConfiguration::MissingConfigurationError => e
        redirect_to app_billing_path, alert: "Billing error: #{e.message}"
      end

      private
        def target_plan
          raise NotImplementedError
        end

        def subscription
          @subscription ||= Current.account.subscription
        end

        def stripe_subscription_item_id
          Stripe::Subscription.retrieve(subscription.stripe_subscription_id).items.data.first.id
        end

        def ensure_active_subscription
          if Current.account.comped?
            redirect_to app_billing_path, alert: "Your account has complimentary access."
          elsif !(Current.account.active_paid_subscription? && subscription&.stripe_subscription_id.present?)
            redirect_to app_billing_path, alert: "No active subscription."
          end
        end
    end
  end
end

# frozen_string_literal: true

module App
  module Subscriptions
    class UpgradesController < UpdatePlanController
      before_action :ensure_monthly_plan

      private
        def target_plan = Plan.yearly

        def ensure_monthly_plan
          unless Current.account.plan.monthly?
            render_error_response(400, "Bad Request", "Can only upgrade from monthly plan.")
          end
        end
    end
  end
end

# frozen_string_literal: true

module Authentication
  extend ActiveSupport::Concern

  included do
    prepend_before_action :set_current_identity, unless: :devise_controller?
    before_action :store_user_location, if: :storable_location?
    before_action :authenticate_identity!, unless: -> { devise_controller? || authenticated_by_access_token? }
    before_action :require_active_identity, unless: -> { devise_controller? || authenticated_by_access_token? }
    before_action :configure_permitted_parameters, if: :devise_controller?
    helper_method :authenticated?
  end

  class_methods do
    def allow_unauthenticated_access(**options)
      skip_before_action :authenticate_identity!, **options
      skip_before_action :require_active_identity, **options
      allow_unauthorized_access(**options)
    end
  end

  private

    def authenticated?
      Current.identity.present?
    end

    def set_current_identity
      authenticate_by_access_token || set_identity_from_session
    end

    def set_identity_from_session
      Current.identity = current_identity if respond_to?(:current_identity)
    end

    def authenticate_by_access_token
      return unless bearer_token_request?

      authenticate_or_request_with_http_token do |token|
        identity, access_token = AccessToken.authenticate(token)
        if identity&.active_for_authentication? && access_token&.allows?(request.method)
          access_token.touch(:last_used_at)
          Current.identity = identity
          @current_access_token = access_token
        end
      end
    end

    def bearer_token_request?
      request.authorization.to_s.start_with?("Bearer")
    end

    def authenticated_by_access_token?
      @current_access_token.present?
    end

    def require_active_identity
      if authenticated? && !Current.identity.active_for_authentication?
        inactive_message = Current.identity.inactive_message
        clear_stored_location_for(:identity)
        sign_out(:identity)
        Current.reset
        redirect_to new_identity_session_path, alert: I18n.t("devise.failure.#{inactive_message}")
      end
    end

    def storable_location?
      request.get? && is_navigational_format? && !devise_controller? && !request.xhr?
    end

    def store_user_location
      store_location_for(:identity, request.fullpath)
    end

    def clear_stored_location_for(resource_or_scope)
      session.delete(stored_location_key_for(resource_or_scope))
    end

    def configure_permitted_parameters
      devise_parameter_sanitizer.permit(:sign_up, keys: [])
      devise_parameter_sanitizer.permit(:account_update, keys: [])
    end

    def after_authentication_path_for(resource)
      stored_location = stored_location_for(resource)

      if stored_location.present? && allowed_stored_location?(stored_location, resource)
        stored_location
      else
        default_after_authentication_path_for(resource)
      end
    end

    def allowed_stored_location?(location, resource)
      if location.start_with?("/admin")
        resource.staff?
      elsif location == app_access_tokens_path
        true
      elsif location == app_path || location.start_with?("/app/")
        resource.accessible_memberships.exists?
      else
        false
      end
    end

    def default_after_authentication_path_for(resource)
      if (path = pricing_intent_path_for(resource))
        path
      elsif resource.accessible_memberships.exists? || resource.cancelled_memberships.exists?
        app_path
      elsif resource.staff?
        admin_dashboard_path
      else
        root_path
      end
    end

    def pricing_intent_path_for(identity)
      plan_key = session.delete(:pricing_intent)
      return nil unless plan_key

      billing_capable = identity.accessible_memberships
        .where(role: %w[owner admin])
        .includes(:account)
        .by_role_priority
        .order(created_at: :asc)
        .first
      return nil unless billing_capable

      app_billing_path(account_id: billing_capable.account.external_account_id, plan_key: plan_key)
    end

    def authentication_page_props
      {
        google_oauth_enabled: Devise.omniauth_configs.key?(:google_oauth2),
        google_oauth_authenticity_token: form_authenticity_token(
          form_options: {
            action: identity_google_oauth2_omniauth_authorize_path,
            method: :post
          }
        )
      }
    end
end

# frozen_string_literal: true

module BillingPortalConfiguration
  extend ActiveSupport::Concern

  class MissingConfigurationError < StandardError; end

  private
    def billing_portal_configuration_id
      if (configuration_id = ENV["STRIPE_BILLING_PORTAL_CONFIGURATION_ID"]).present?
        configuration_id
      else
        raise MissingConfigurationError, "STRIPE_BILLING_PORTAL_CONFIGURATION_ID is not set."
      end
    end
end

# frozen_string_literal: true

module Identities
  class RegistrationsController < Devise::RegistrationsController
    include InertiaFlash
    rate_limit to: 10, within: 3.minutes, only: :create

    def new
      if params[:intent] == "upgrade" && params[:plan_key].present? && Plan.visible.map(&:key).include?(params[:plan_key])
        session[:pricing_intent] = params[:plan_key]
      end
      render inertia: "identities/registration/new", props: authentication_page_props
    end

    def create
      build_resource(sign_up_params)
      user_name = params.dig(:user, :name).presence || resource.email.to_s.split("@").first

      Identity.transaction do
        resource.save!
        resource.mark_password_set
        Account.create_with_user(identity: resource, name: user_name)
      end

      set_flash_message!(:notice, :signed_up)
      sign_up(resource_name, resource)
      redirect_to after_sign_up_path_for(resource)
    rescue ActiveRecord::RecordInvalid => error
      clean_up_passwords resource
      redirect_to new_identity_registration_path, inertia: { errors: registration_errors(error) }
    rescue ActiveRecord::RecordNotUnique
      clean_up_passwords resource
      redirect_to new_identity_registration_path,
        inertia: { errors: duplicate_email_error }
    end

    protected

      def after_sign_up_path_for(resource)
        pricing_intent_path_for(resource) || app_path
      end

    private
      def registration_errors(error)
        errors = resource.errors.to_hash
        errors.merge!(error.record.errors.to_hash) unless error.record == resource

        if email_taken_error?(resource) || email_taken_error?(error.record)
          errors[:email] = duplicate_email_error[:email]
        end

        errors
      end

      def email_taken_error?(record)
        record&.errors&.details&.fetch(:email, [])&.any? { |detail| detail[:error] == :taken }
      end

      def duplicate_email_error
        { email: "We couldn't create your account. Try signing in or resetting your password." }
      end
  end
end

# frozen_string_literal: true

module Identities
  class SessionsController < Devise::SessionsController
    include InertiaFlash
    rate_limit to: 10, within: 3.minutes, only: :create

    def new
      render inertia: "identities/session/new", props: authentication_page_props
    end

    def create
      self.resource = warden.authenticate!(auth_options)
      set_flash_message!(:notice, :signed_in)
      sign_in(resource_name, resource)
      redirect_to after_sign_in_path_for(resource)
    end

    def destroy
      clear_stored_location_for(resource_name)
      session.delete(:pricing_intent)
      signed_out = (Devise.sign_out_all_scopes ? sign_out : sign_out(resource_name))
      set_flash_message!(:notice, :signed_out) if signed_out
      redirect_to after_sign_out_path_for(resource_name), status: :see_other
    end

    protected

      def after_sign_in_path_for(resource)
        after_authentication_path_for(resource)
      end

      def after_sign_out_path_for(_resource)
        root_path
      end
  end
end

# frozen_string_literal: true

class InertiaController < ApplicationController
  include InertiaFlash
  include InertiaUtils

  # Share data with all Inertia responses
  inertia_share current_user: -> { current_user_props }
  inertia_share current_identity: -> { current_identity_props }
  inertia_share request_context: -> { request_context_props }
  inertia_share plan: -> { plan_props }

  private

    def current_user_props
      return nil unless Current.user && Current.account

      {
        id: Current.user.id,
        name: Current.user.name,
        email: Current.user.email,
        role: Current.user.role,
        staff: Current.identity&.staff? || false,
        account_id: Current.account.external_account_id,
        account_name: Current.account.name
      }
    end

    def current_identity_props
      return nil unless Current.identity

      default_membership = current_identity_default_membership

      {
        id: Current.identity.id,
        name: Current.identity.display_name,
        email: Current.identity.email,
        staff: Current.identity.staff?,
        default_account_id: default_membership&.account&.external_account_id,
        default_account_name: default_membership&.account&.name,
        default_account_role: default_membership&.role
      }
    end

    def current_identity_default_membership
      Current.identity.accessible_memberships
        .includes(:account)
        .by_role_priority
        .order(created_at: :asc)
        .first
    end

    def request_context_props
      {
        request_id: Current.request_id,
        current_time: Time.current.iso8601,
        timezone: Time.zone.tzinfo.name,
        platform: platform.type
      }
    end

    def plan_props
      return unless Current.account

      {
        key: Current.account.plan.key,
        name: Current.account.plan.name,
        free: Current.account.plan.free?,
        active_paid: Current.account.active_paid_subscription?,
        has_stripe_customer: Current.account.has_stripe_customer?,
        recoverable: Current.account.recoverable_subscription?,
        comped: Current.account.comped?,
        subscription_status: Current.account.subscription&.status,
        limits: Current.account.plan.limits_for_json
      }
    end
end

# frozen_string_literal: true

class PagesController < InertiaController
  # Public marketing pages: allow guests and reject accidental /app/:account_id scoping.
  allow_unauthenticated_access
  disallow_account_scope

  def home
    render inertia: "pages/home"
  end

  def about
    render inertia: "pages/about"
  end

  def pricing
    render inertia: "pages/pricing", props: {
      plans: plans_props
    }
  end

  def privacy
    render inertia: "pages/privacy"
  end

  def terms
    render inertia: "pages/terms"
  end

  def contact
    render inertia: "pages/contact"
  end

  private
    def plans_props
      Plan.visible.map do |plan|
        {
          key: plan.key,
          name: plan.name,
          price: plan.price,
          monthly: plan.monthly?,
          yearly: plan.yearly?,
          limits: plan.limits_for_json,
          annual_savings: plan.annual_savings
        }
      end
    end
end

# frozen_string_literal: true

class Stripe::WebhooksController < ApplicationController
  allow_unauthenticated_access
  skip_before_action :verify_authenticity_token

  def create
    if event = verify_webhook_signature
      Rails.logger.info("[Stripe Webhook] Processing #{event.type} (#{event.id})")
      dispatch_stripe_event(event)
      head :ok
    else
      head :bad_request
    end
  end

  private
    def dispatch_stripe_event(event)
      case event.type
      when "checkout.session.completed"
        sync_new_subscription(event.data.object.subscription, plan_key: event.data.object.metadata["plan_key"]) if event.data.object.mode == "subscription"
      when "customer.subscription.updated", "customer.subscription.deleted"
        sync_subscription(event.data.object.id)
      end
    end

    def verify_webhook_signature
      payload = request.body.read
      sig_header = request.env["HTTP_STRIPE_SIGNATURE"]
      Stripe::Webhook.construct_event(payload, sig_header, ENV["STRIPE_WEBHOOK_SECRET"])
    rescue Stripe::SignatureVerificationError => e
      Rails.logger.error("[Stripe Webhook] Signature verification failed: #{e.message}")
      nil
    rescue JSON::ParserError => e
      Rails.logger.error("[Stripe Webhook] Malformed payload: #{e.message}")
      nil
    end

    def sync_new_subscription(stripe_subscription_id, plan_key:)
      sync_subscription(stripe_subscription_id) do |properties|
        properties[:plan_key] = plan_key if plan_key
      end
    end

    def sync_subscription(stripe_subscription_id)
      stripe_subscription = Stripe::Subscription.retrieve(stripe_subscription_id)

      if subscription = find_subscription_by_stripe_customer(stripe_subscription.customer)
        # Guard: skip if this event is for a different (older) subscription
        if subscription.stripe_subscription_id.present? && subscription.stripe_subscription_id != stripe_subscription.id
          Rails.logger.info("[Stripe Webhook] Skipping event for old subscription #{stripe_subscription.id}, current is #{subscription.stripe_subscription_id}")
          return
        end

        properties = subscription_properties_for(stripe_subscription)
        yield properties if block_given?

        sends_activation_email = false
        subscription.with_lock do
          sends_activation_email = sends_activation_email?(subscription, properties[:status])
          if refreshes_subscription_started_at?(subscription, properties[:status])
            # Incomplete rows are created at checkout start to persist the Stripe customer.
            # Move the analytics timestamp to the first paid activation.
            properties[:created_at] = Time.current
          end
          properties[:stripe_subscription_id] = nil if stripe_subscription.status == "canceled"
          subscription.update!(properties)
        end

        SubscriptionMailer.activated(subscription).deliver_later if sends_activation_email && subscription.notification_email.present?
        AdminNotificationMailer.new_subscription(subscription).deliver_later if sends_activation_email && AdminNotificationMailer.enabled_for?(:new_subscription)
      end
    end

    def find_subscription_by_stripe_customer(id)
      Account::Subscription.find_by(stripe_customer_id: id)
    end

    def current_period_end_for(stripe_subscription)
      timestamp = stripe_subscription.items.data.first&.current_period_end
      Time.at(timestamp) if timestamp
    end

    def next_amount_due_for(stripe_subscription)
      return nil if stripe_subscription.status == "canceled"
      preview = Stripe::Invoice.create_preview(customer: stripe_subscription.customer, subscription: stripe_subscription.id)
      preview.amount_due
    rescue Stripe::InvalidRequestError
      nil
    end

    def plan_key_for(stripe_subscription)
      price_id = stripe_subscription.items.data.first&.price&.id
      Plan.find_by_price_id(price_id)&.key
    end

    def subscription_properties_for(stripe_subscription)
      properties = {
        stripe_subscription_id: stripe_subscription.id,
        status: stripe_subscription.status,
        current_period_end: current_period_end_for(stripe_subscription),
        cancel_at: stripe_subscription.cancel_at ? Time.at(stripe_subscription.cancel_at) : nil,
        next_amount_due_in_cents: next_amount_due_for(stripe_subscription)
      }

      resolved_plan_key = plan_key_for(stripe_subscription)
      properties[:plan_key] = resolved_plan_key if resolved_plan_key

      merge_scheduled_plan_change(properties, stripe_subscription)

      properties
    end

    # Returns nil when the schedule lookup fails (Stripe API error),
    # signaling that we should keep existing DB values unchanged.
    # Returns a hash with :plan_key and :starts_at (possibly nil) on success.
    def scheduled_plan_change_for(stripe_subscription, current_plan_key:)
      unless stripe_subscription.schedule.present?
        return { plan_key: nil, starts_at: nil }
      end

      schedule = Stripe::SubscriptionSchedule.retrieve(stripe_subscription.schedule)
      unless schedule.status == "active" && schedule.current_phase&.end_date
        return { plan_key: nil, starts_at: nil }
      end

      next_phase = schedule.phases.find { |phase| phase.start_date == schedule.current_phase.end_date }
      unless next_phase
        return { plan_key: nil, starts_at: nil }
      end

      price_id = next_phase.items.first&.price
      price_id = price_id.id if price_id.respond_to?(:id)
      plan = Plan.find_by_price_id(price_id)
      unless plan && plan.key != current_plan_key
        return { plan_key: nil, starts_at: nil }
      end

      { plan_key: plan.key, starts_at: Time.at(next_phase.start_date) }
    rescue Stripe::StripeError => e
      Rails.logger.warn("[Stripe Webhook] Schedule lookup failed: #{e.message}")
      nil
    end

    def merge_scheduled_plan_change(properties, stripe_subscription)
      scheduled = scheduled_plan_change_for(stripe_subscription, current_plan_key: properties[:plan_key])
      return unless scheduled # nil = Stripe error, keep existing DB values

      properties[:scheduled_plan_key] = scheduled[:plan_key]
      properties[:scheduled_starts_at] = scheduled[:starts_at]
    end

    def refreshes_subscription_started_at?(subscription, status)
      subscription.incomplete? &&
        subscription.stripe_subscription_id.blank? &&
        subscribed_status?(status)
    end

    def sends_activation_email?(subscription, status)
      refreshes_subscription_started_at?(subscription, status) && status == "active"
    end

    def subscribed_status?(status)
      %w[active trialing past_due].include?(status)
    end
end

import {
  Activity,
  BarChart3,
  LayoutDashboard,
  Settings2,
  Users,
  Zap,
} from "lucide-react"

import {
  Sidebar,
  SidebarContent,
  SidebarFooter,
  SidebarHeader,
  SidebarRail,
} from "@/components/ui/sidebar"
import { NavUser } from "@/components/admin/nav-user"
import { TeamSwitcher } from "@/components/admin/team-switcher"
import { NavMain } from "@/components/shared/nav-main"

const navOverview = [
  {
    title: "Dashboard",
    url: "/admin/dashboard",
    icon: LayoutDashboard,
  },
  {
    title: "Customers",
    url: "/admin/customers",
    icon: Users,
  },
]

const navAnalytics = [
  {
    title: "Live",
    url: "/admin/analytics/live",
    icon: Activity,
  },
  {
    title: "Reports",
    url: "/admin/analytics/reports",
    icon: BarChart3,
  },
]

const navSystem = [
  {
    title: "Jobs",
    url: "/admin/jobs",
    icon: Zap,
    external: true,
  },
  {
    title: "Settings",
    url: "/admin/settings",
    icon: Settings2,
  },
]

export function AppSidebar(props: React.ComponentProps<typeof Sidebar>) {
  return (
    <Sidebar collapsible="icon" {...props}>
      <SidebarHeader>
        <TeamSwitcher />
      </SidebarHeader>
      <SidebarContent>
        <NavMain items={navOverview} />
        <NavMain label="Analytics" items={navAnalytics} />
        <NavMain label="System" items={navSystem} />
      </SidebarContent>
      <SidebarFooter>
        <NavUser />
      </SidebarFooter>
      <SidebarRail />
    </Sidebar>
  )
}

import { useEffect, useMemo, useRef, useState, type ReactNode } from "react"
import {
  Calendar,
  Check,
  ChevronDown,
  ChevronLeft,
  ChevronRight,
  Clock,
} from "lucide-react"

import {
  addDaysInTimeZone,
  addMonthsInTimeZone,
  endOfDayInTimeZone,
  formatInTimeZone,
  getZonedDayIndex,
  getZonedParts,
  getZonedWeekday,
  startOfDayInTimeZone,
  zonedPartsToUtc,
} from "@/lib/timezone"
import { cn } from "@/lib/utils"

export type DateRange = {
  start: Date
  end: Date
}

type DateRangePreset = {
  id: string
  label: string
  getRange: () => DateRange
}

type DateRangePickerProps = {
  value?: DateRange
  presetId?: string
  onChange?: (range: DateRange, meta?: { presetId: string }) => void
  presets?: DateRangePreset[]
  buttonLabel?: (range: DateRange, presetLabel?: string) => string
  timeZone?: string
  now?: string
}

type PresetGroup = {
  id: string
  presets: DateRangePreset[]
}

function buildPresetGroups(now: Date, timeZone?: string): PresetGroup[] {
  const nowParts = getZonedParts(now, timeZone)
  const startOfCurrentMonth = zonedPartsToUtc(
    {
      year: nowParts.year,
      month: nowParts.month,
      day: 1,
      hour: 0,
      minute: 0,
      second: 0,
    },
    timeZone
  )

  return [
    {
      id: "quick",
      presets: [
        {
          id: "today",
          label: "Today",
          getRange: () => ({ start: startOfDay(now, timeZone), end: now }),
        },
        {
          id: "yesterday",
          label: "Yesterday",
          getRange: () => {
            const date = addDays(now, -1, timeZone)
            return {
              start: startOfDay(date, timeZone),
              end: endOfDay(date, timeZone),
            }
          },
        },
        {
          id: "last-30-minutes",
          label: "Last 30 minutes",
          getRange: () => {
            const end = now
            const start = new Date(end.getTime() - 30 * 60 * 1000)
            return { start, end }
          },
        },
        {
          id: "last-12-hours",
          label: "Last 12 hours",
          getRange: () => {
            const end = now
            const start = new Date(end.getTime() - 12 * 60 * 60 * 1000)
            return { start, end }
          },
        },
      ],
    },
    {
      id: "rolling-days",
      presets: [
        {
          id: "last-7-days",
          label: "Last 7 days",
          getRange: () => ({ start: addDays(now, -7, timeZone), end: now }),
        },
        {
          id: "last-30-days",
          label: "Last 30 days",
          getRange: () => ({ start: addDays(now, -30, timeZone), end: now }),
        },
        {
          id: "last-90-days",
          label: "Last 90 days",
          getRange: () => ({ start: addDays(now, -90, timeZone), end: now }),
        },
        {
          id: "last-365-days",
          label: "Last 365 days",
          getRange: () => ({ start: addDays(now, -365, timeZone), end: now }),
        },
        {
          id: "last-12-months",
          label: "Last 12 months",
          getRange: () => {
            const end = endOfDay(
              addDays(startOfCurrentMonth, -1, timeZone),
              timeZone
            )
            const startMonthAnchor = addMonths(end, -11, timeZone)
            const startMonthParts = getZonedParts(startMonthAnchor, timeZone)
            const start = zonedPartsToUtc(
              {
                year: startMonthParts.year,
                month: startMonthParts.month,
                day: 1,
                hour: 0,
                minute: 0,
                second: 0,
              },
              timeZone
            )
            const endParts = getZonedParts(end, timeZone)
            const endDate = zonedPartsToUtc(
              {
                year: endParts.year,
                month: endParts.month,
                day: endParts.day,
                hour: 23,
                minute: 59,
                second: 59,
              },
              timeZone
            )
            return { start, end: endDate }
          },
        },
      ],
    },
    {
      id: "last-periods",
      presets: [
        {
          id: "last-week",
          label: "Last week",
          getRange: () => {
            const anchor = addDays(now, -7, timeZone)
            const start = startOfWeek(anchor, 1, timeZone)
            const end = endOfWeek(anchor, timeZone)
            return { start, end }
          },
        },
        {
          id: "last-month",
          label: "Last month",
          getRange: () => {
            const end = endOfDay(
              addDays(startOfCurrentMonth, -1, timeZone),
              timeZone
            )
            const endParts = getZonedParts(end, timeZone)
            const start = zonedPartsToUtc(
              {
                year: endParts.year,
                month: endParts.month,
                day: 1,
                hour: 0,
                minute: 0,
                second: 0,
              },
              timeZone
            )
            return { start, end }
          },
        },
        {
          id: "last-quarter",
          label: "Last quarter",
          getRange: () => {
            const currentQuarter = Math.floor((nowParts.month - 1) / 3)
            const lastQuarterStartMonth =
              currentQuarter === 0 ? 10 : (currentQuarter - 1) * 3 + 1
            const lastQuarterYear =
              currentQuarter === 0 ? nowParts.year - 1 : nowParts.year
            const start = zonedPartsToUtc(
              {
                year: lastQuarterYear,
                month: lastQuarterStartMonth,
                day: 1,
                hour: 0,
                minute: 0,
                second: 0,
              },
              timeZone
            )
            const end = endOfDay(
              addDays(addMonths(start, 3, timeZone), -1, timeZone),
              timeZone
            )
            return { start, end }
          },
        },
        {
          id: "last-year",
          label: "Last year",
          getRange: () => {
            const start = zonedPartsToUtc(
              {
                year: nowParts.year - 1,
                month: 1,
                day: 1,
                hour: 0,
                minute: 0,
                second: 0,
              },
              timeZone
            )
            const end = zonedPartsToUtc(
              {
                year: nowParts.year - 1,
                month: 12,
                day: 31,
                hour: 23,
                minute: 59,
                second: 59,
              },
              timeZone
            )
            return { start, end }
          },
        },
      ],
    },
    {
      id: "to-date",
      presets: [
        {
          id: "week-to-date",
          label: "Week to date",
          getRange: () => ({ start: startOfWeek(now, 1, timeZone), end: now }),
        },
        {
          id: "month-to-date",
          label: "Month to date",
          getRange: () => ({
            start: startOfDay(startOfCurrentMonth, timeZone),
            end: now,
          }),
        },
        {
          id: "quarter-to-date",
          label: "Quarter to date",
          getRange: () => {
            const currentQuarter = Math.floor((nowParts.month - 1) / 3)
            const start = zonedPartsToUtc(
              {
                year: nowParts.year,
                month: currentQuarter * 3 + 1,
                day: 1,
                hour: 0,
                minute: 0,
                second: 0,
              },
              timeZone
            )
            return { start, end: now }
          },
        },
        {
          id: "year-to-date",
          label: "Year to date",
          getRange: () => {
            const start = zonedPartsToUtc(
              {
                year: nowParts.year,
                month: 1,
                day: 1,
                hour: 0,
                minute: 0,
                second: 0,
              },
              timeZone
            )
            return { start, end: now }
          },
        },
      ],
    },
  ]
}

function useClickOutside(
  ref: React.RefObject<HTMLElement | null>,
  onClose: () => void
) {
  useEffect(() => {
    const handleClick = (event: MouseEvent) => {
      if (!ref.current || ref.current.contains(event.target as Node)) return
      onClose()
    }
    document.addEventListener("mousedown", handleClick)
    return () => document.removeEventListener("mousedown", handleClick)
  }, [onClose, ref])
}

export function DateRangePicker({
  value,
  presetId,
  onChange,
  presets,
  buttonLabel,
  timeZone,
  now,
}: DateRangePickerProps) {
  const baseNow = useMemo(() => (now ? new Date(now) : new Date()), [now])
  const presetGroups = useMemo(
    () => buildPresetGroups(baseNow, timeZone),
    [baseNow, timeZone]
  )
  const defaultPresets = useMemo(
    () => presetGroups.flatMap((group) => group.presets),
    [presetGroups]
  )
  const resolvedPresets = presets ?? defaultPresets
  const resolvedPresetGroups = presets
    ? [{ id: "custom", presets }]
    : presetGroups

  const initialRange = value ??
    resolvedPresets[0]?.getRange() ?? { start: baseNow, end: baseNow }
  const initialParts = getZonedParts(initialRange.start, timeZone)
  const [committedRange, setCommittedRange] = useState<DateRange>(initialRange)
  const [draftRange, setDraftRange] = useState<DateRange>(initialRange)
  const [rangeAnchor, setRangeAnchor] = useState<Date | null>(null)
  const [open, setOpen] = useState(false)
  const [activePreset, setActivePreset] = useState<string>(
    presetId ?? resolvedPresets[0]?.id ?? ""
  )
  const [displayMonth, setDisplayMonth] = useState(initialParts.month - 1)
  const [displayYear, setDisplayYear] = useState(initialParts.year)

  const popoverRef = useRef<HTMLDivElement>(null)
  useClickOutside(popoverRef, () => setOpen(false))

  useEffect(() => {
    if (!open) return
    const handleKeyDown = (e: KeyboardEvent) => {
      if (e.key === "Escape") setOpen(false)
    }
    document.addEventListener("keydown", handleKeyDown)
    return () => document.removeEventListener("keydown", handleKeyDown)
  }, [open])

  useEffect(() => {
    if (!value) return
    setCommittedRange(value)
    setDraftRange(value)
  }, [value])

  useEffect(() => {
    if (presetId) setActivePreset(presetId)
  }, [presetId])

  useEffect(() => {
    if (!open) return
    setDraftRange(committedRange)
    const parts = getZonedParts(committedRange.start, timeZone)
    setDisplayMonth(parts.month - 1)
    setDisplayYear(parts.year)
    setRangeAnchor(null)
  }, [open, committedRange, timeZone])

  const handlePresetSelect = (preset: DateRangePreset) => {
    const range = preset.getRange()
    setDraftRange(range)
    setActivePreset(preset.id)
    const parts = getZonedParts(range.start, timeZone)
    setDisplayMonth(parts.month - 1)
    setDisplayYear(parts.year)
    setRangeAnchor(null)
  }

  const handleDaySelect = (date: Date) => {
    setActivePreset("custom")
    if (!rangeAnchor) {
      setRangeAnchor(date)
      setDraftRange({ start: date, end: date })
      return
    }
    if (date < rangeAnchor) {
      setDraftRange({ start: date, end: rangeAnchor })
    } else {
      setDraftRange({ start: rangeAnchor, end: date })
    }
    setRangeAnchor(null)
  }

  const handleApply = () => {
    setCommittedRange(draftRange)
    onChange?.(draftRange, { presetId: activePreset })
    setOpen(false)
    setRangeAnchor(null)
  }

  const handleCancel = () => {
    setDraftRange(committedRange)
    setOpen(false)
    setRangeAnchor(null)
  }

  const label = buttonLabel
    ? buttonLabel(
        committedRange,
        resolvedPresets.find((preset) => preset.id === activePreset)?.label
      )
    : formatButtonLabel(
        committedRange,
        resolvedPresets.find((preset) => preset.id === activePreset)?.label,
        timeZone
      )

  const months = useMemo(() => {
    const first = { month: displayMonth, year: displayYear }
    const secondDate = new Date(Date.UTC(displayYear, displayMonth + 1, 1))
    const second = {
      month: secondDate.getUTCMonth(),
      year: secondDate.getUTCFullYear(),
    }
    return [first, second]
  }, [displayMonth, displayYear])

  return (
    <div ref={popoverRef} className="relative inline-flex">
      <button
        type="button"
        onClick={() => setOpen((prev) => !prev)}
        className="flex items-center gap-1.5 rounded-md border border-input bg-background px-3 py-1.5 text-xs font-medium text-foreground shadow-xs transition-colors hover:bg-accent hover:text-accent-foreground"
      >
        <Calendar className="size-3.5 text-muted-foreground" />
        <span>{label}</span>
        <ChevronDown className="size-3 text-muted-foreground" />
      </button>

      {open ? (
        <div className="absolute top-full right-0 z-40 mt-1.5 w-[calc(100vw-2rem)] overflow-hidden rounded-lg border border-border bg-popover shadow-md sm:w-[320px] md:w-[580px]">
          <div className="grid grid-cols-1 md:grid-cols-[160px_1fr]">
            {/* Desktop sidebar */}
            <div className="hidden max-h-[320px] overflow-y-auto border-r border-border bg-muted/30 p-2 md:block">
              <div className="flex flex-col">
                {resolvedPresetGroups.map((group, groupIndex) => (
                  <div key={group.id}>
                    {groupIndex > 0 && (
                      <div className="my-1.5 border-t border-border" />
                    )}
                    <div className="flex flex-col gap-0.5">
                      {group.presets.map((preset) => (
                        <button
                          key={preset.id}
                          type="button"
                          onClick={() => handlePresetSelect(preset)}
                          className={cn(
                            "flex items-center justify-between rounded-md px-2 py-1 text-left text-[11px]",
                            activePreset === preset.id
                              ? "bg-accent font-medium text-accent-foreground"
                              : "text-muted-foreground hover:bg-accent/50 hover:text-accent-foreground"
                          )}
                        >
                          <span>{preset.label}</span>
                          {activePreset === preset.id ? (
                            <Check className="size-3" />
                          ) : null}
                        </button>
                      ))}
                    </div>
                  </div>
                ))}
              </div>
            </div>

            <div className="flex flex-col p-3">
              {/* Mobile preset dropdown */}
              <div className="relative mb-2 md:hidden">
                <select
                  value={activePreset}
                  onChange={(e) => {
                    const preset = resolvedPresets.find(
                      (p) => p.id === e.target.value
                    )
                    if (preset) handlePresetSelect(preset)
                  }}
                  className="w-full appearance-none rounded-md border border-input bg-background px-2.5 py-1.5 pr-8 text-xs text-foreground outline-hidden focus:ring-1 focus:ring-ring"
                >
                  {resolvedPresets.map((preset) => (
                    <option key={preset.id} value={preset.id}>
                      {preset.label}
                    </option>
                  ))}
                </select>
                <ChevronDown className="pointer-events-none absolute top-1/2 right-2.5 size-3.5 -translate-y-1/2 text-muted-foreground" />
              </div>

              <div className="flex items-center gap-2">
                <DateInput
                  value={formatShortDate(draftRange.start, timeZone)}
                />
                <span className="text-xs text-muted-foreground">&rarr;</span>
                <DateInput
                  value={formatShortDate(draftRange.end, timeZone)}
                  icon={<Clock className="size-3.5" />}
                />
              </div>

              {/* Mobile: single calendar, Desktop: two calendars */}
              <div className="mt-3 grid grid-cols-1 gap-4 md:grid-cols-2">
                {/* Mobile shows only first month with both arrows */}
                <div className="md:hidden">
                  <CalendarMonth
                    month={displayMonth}
                    year={displayYear}
                    range={draftRange}
                    onSelect={handleDaySelect}
                    onPrev={() => setMonthOffset(-1)}
                    onNext={() => setMonthOffset(1)}
                    showPrev
                    showNext
                    timeZone={timeZone}
                    today={baseNow}
                  />
                </div>
                {/* Desktop shows both months */}
                {months.map((month, i) => (
                  <div
                    key={`${month.year}-${month.month}`}
                    className="hidden md:block"
                  >
                    <CalendarMonth
                      month={month.month}
                      year={month.year}
                      range={draftRange}
                      onSelect={handleDaySelect}
                      onPrev={() => setMonthOffset(-1)}
                      onNext={() => setMonthOffset(1)}
                      showPrev={i === 0}
                      showNext={i === 1}
                      timeZone={timeZone}
                      today={baseNow}
                    />
                  </div>
                ))}
              </div>
            </div>
          </div>

          {/* Footer */}
          <div className="flex items-center justify-end gap-2 border-t border-border px-3 py-2">
            <button
              type="button"
              onClick={handleCancel}
              className="rounded-md border border-input bg-background px-3 py-1 text-[11px] font-medium text-foreground shadow-xs hover:bg-accent hover:text-accent-foreground"
            >
              Cancel
            </button>
            <button
              type="button"
              onClick={handleApply}
              className="rounded-md bg-primary px-3 py-1 text-[11px] font-medium text-primary-foreground shadow-xs hover:bg-primary/90"
            >
              Apply
            </button>
          </div>
        </div>
      ) : null}
    </div>
  )

  function setMonthOffset(offset: number) {
    const date = new Date(Date.UTC(displayYear, displayMonth + offset, 1))
    setDisplayMonth(date.getUTCMonth())
    setDisplayYear(date.getUTCFullYear())
  }
}

function DateInput({ value, icon }: { value: string; icon?: ReactNode }) {
  return (
    <div className="relative w-full">
      <input
        type="text"
        value={value}
        readOnly
        className="w-full rounded-md border border-input bg-background px-2 py-1 text-[11px] text-foreground outline-hidden"
      />
      {icon ? (
        <span className="absolute top-1/2 right-1.5 -translate-y-1/2 text-muted-foreground">
          {icon}
        </span>
      ) : null}
    </div>
  )
}

function CalendarMonth({
  month,
  year,
  range,
  onSelect,
  onPrev,
  onNext,
  showPrev,
  showNext,
  timeZone,
  today,
}: {
  month: number
  year: number
  range: DateRange
  onSelect: (date: Date) => void
  onPrev: () => void
  onNext: () => void
  showPrev: boolean
  showNext: boolean
  timeZone?: string
  today?: Date
}) {
  const monthLabel = formatInTimeZone(
    zonedPartsToUtc(
      { year, month: month + 1, day: 1, hour: 0, minute: 0, second: 0 },
      timeZone
    ),
    { month: "long", year: "numeric" },
    timeZone
  )

  const days = getMonthGrid(year, month, timeZone)

  return (
    <div>
      <div className="flex items-center justify-between">
        <button
          type="button"
          onClick={onPrev}
          className={cn(
            "rounded-md p-1 text-muted-foreground hover:bg-accent",
            showPrev ? "" : "invisible"
          )}
        >
          <ChevronLeft className="size-4" />
        </button>
        <span className="text-xs font-medium text-foreground">
          {monthLabel}
        </span>
        <button
          type="button"
          onClick={onNext}
          className={cn(
            "rounded-md p-1 text-muted-foreground hover:bg-accent",
            showNext ? "" : "invisible"
          )}
        >
          <ChevronRight className="size-4" />
        </button>
      </div>

      <div className="mt-2 grid grid-cols-7 text-[10px] text-muted-foreground">
        {["Su", "Mo", "Tu", "We", "Th", "Fr", "Sa"].map((day) => (
          <div key={day} className="flex h-5 items-center justify-center">
            {day}
          </div>
        ))}
      </div>

      <div className="mt-1 grid grid-cols-7 text-[11px]">
        {days.map((day, index) => {
          if (!day.currentMonth) {
            return <div key={`empty-${index}`} className="h-6" />
          }

          const isFuture =
            today &&
            getZonedDayIndex(day.date, timeZone) >
              getZonedDayIndex(today, timeZone)
          const isSelectedStart = isSameDay(day.date, range.start, timeZone)
          const isSelectedEnd = isSameDay(day.date, range.end, timeZone)
          const isInRange = isWithinRange(day.date, range, timeZone)
          const isRangeMiddle = isInRange && !isSelectedStart && !isSelectedEnd
          const dayParts = getZonedParts(day.date, timeZone)

          if (isFuture) {
            return (
              <div
                key={`${day.date.toISOString()}-${index}`}
                className="flex h-6 items-center justify-center text-muted-foreground/40"
              >
                {dayParts.day}
              </div>
            )
          }

          return (
            <button
              key={`${day.date.toISOString()}-${index}`}
              type="button"
              onClick={() => onSelect(day.date)}
              className={cn(
                "relative flex h-6 items-center justify-center text-foreground transition-colors",
                isRangeMiddle && "bg-accent",
                isSelectedStart &&
                  !isSelectedEnd &&
                  "bg-linear-to-l from-accent to-transparent",
                isSelectedEnd &&
                  !isSelectedStart &&
                  "bg-linear-to-r from-accent to-transparent",
                isSelectedStart && isSelectedEnd && "",
                !isInRange && "rounded-xs hover:bg-accent/50"
              )}
            >
              <span
                className={cn(
                  "flex size-6 items-center justify-center",
                  (isSelectedStart || isSelectedEnd) &&
                    "rounded-xs bg-primary text-primary-foreground"
                )}
              >
                {dayParts.day}
              </span>
            </button>
          )
        })}
      </div>
    </div>
  )
}

type CalendarDay = {
  date: Date
  currentMonth: boolean
}

function getMonthGrid(
  year: number,
  month: number,
  timeZone?: string
): CalendarDay[] {
  const firstOfMonth = new Date(Date.UTC(year, month, 1))
  const startWeekday = firstOfMonth.getUTCDay()
  const daysInMonth = new Date(Date.UTC(year, month + 1, 0)).getUTCDate()
  const totalCells = Math.ceil((startWeekday + daysInMonth) / 7) * 7
  const days: CalendarDay[] = []

  for (let i = 0; i < totalCells; i += 1) {
    const dayNumber = i - startWeekday + 1
    const isCurrentMonth = dayNumber >= 1 && dayNumber <= daysInMonth

    if (isCurrentMonth) {
      const zonedDate = zonedPartsToUtc(
        {
          year,
          month: month + 1,
          day: dayNumber,
          hour: 0,
          minute: 0,
          second: 0,
        },
        timeZone
      )
      days.push({ date: zonedDate, currentMonth: true })
    } else {
      days.push({ date: new Date(0), currentMonth: false })
    }
  }

  return days
}

function isSameDay(left: Date, right: Date, timeZone?: string) {
  return getZonedDayIndex(left, timeZone) === getZonedDayIndex(right, timeZone)
}

function isWithinRange(date: Date, range: DateRange, timeZone?: string) {
  const dayIndex = getZonedDayIndex(date, timeZone)
  const startIndex = getZonedDayIndex(range.start, timeZone)
  const endIndex = getZonedDayIndex(range.end, timeZone)
  return dayIndex >= startIndex && dayIndex <= endIndex
}

function startOfDay(date: Date, timeZone?: string) {
  return startOfDayInTimeZone(date, timeZone)
}

function endOfDay(date: Date, timeZone?: string) {
  return endOfDayInTimeZone(date, timeZone)
}

function addDays(date: Date, days: number, timeZone?: string) {
  return addDaysInTimeZone(date, days, timeZone)
}

function addMonths(date: Date, months: number, timeZone?: string) {
  return addMonthsInTimeZone(date, months, timeZone)
}

function startOfWeek(date: Date, weekStartsOn = 1, timeZone?: string) {
  const day = getZonedWeekday(date, timeZone)
  const diff = (day < weekStartsOn ? 7 : 0) + day - weekStartsOn
  return startOfDay(addDays(date, -diff, timeZone), timeZone)
}

function endOfWeek(date: Date, timeZone?: string) {
  const start = startOfWeek(date, 1, timeZone)
  return endOfDay(addDays(start, 6, timeZone), timeZone)
}

function formatLongDate(date: Date, timeZone?: string) {
  return formatInTimeZone(
    date,
    {
      month: "long",
      day: "numeric",
      year: "numeric",
    },
    timeZone
  )
}

function formatShortDate(date: Date, timeZone?: string) {
  return formatInTimeZone(
    date,
    {
      month: "short",
      day: "numeric",
      year: "numeric",
    },
    timeZone
  )
}

function formatButtonLabel(
  range: DateRange,
  presetLabel?: string,
  timeZone?: string
) {
  if (presetLabel) return presetLabel
  return `${formatLongDate(range.start, timeZone)} \u2013 ${formatLongDate(range.end, timeZone)}`
}