Bookra/apps/backend/internal/billing/service.go

package billing

import (
	"context"
	"encoding/json"
	"errors"
	"fmt"
	"io"
	"net/http"
	"slices"
	"strings"
	"time"

	"bookra/apps/backend/internal/config"
	"bookra/apps/backend/internal/db"
	"bookra/apps/backend/internal/domain"
	"bookra/apps/backend/internal/shared"

	"github.com/jackc/pgx/v5"
	"github.com/stripe/stripe-go/v81"
	portalsession "github.com/stripe/stripe-go/v81/billingportal/session"
	checkoutsession "github.com/stripe/stripe-go/v81/checkout/session"
	"github.com/stripe/stripe-go/v81/customer"
	"github.com/stripe/stripe-go/v81/subscription"
	"github.com/stripe/stripe-go/v81/webhook"
)

var (
	ErrBillingMembership      = errors.New("billing membership not found")
	ErrBillingPlanUnsupported = errors.New("billing plan is not configured")
	ErrBillingCustomerMissing = errors.New("billing customer is not available")
	ErrStripeNotConfigured    = errors.New("stripe is not configured")
	ErrStripeSignatureMissing = errors.New("stripe signature is missing")
	ErrStripeWebhookMissing   = errors.New("stripe webhook secret is not configured")
)

var allowedStripeWebhookEvents = []stripe.EventType{
	stripe.EventTypeCheckoutSessionCompleted,
	stripe.EventTypeCustomerSubscriptionCreated,
	stripe.EventTypeCustomerSubscriptionUpdated,
	stripe.EventTypeCustomerSubscriptionDeleted,
	stripe.EventTypeInvoicePaid,
	stripe.EventTypeInvoicePaymentFailed,
	stripe.EventTypePaymentIntentSucceeded,
	stripe.EventTypePaymentIntentPaymentFailed,
}

type Service struct {
	cfg  config.Config
	repo db.Repository
}

func NewService(cfg config.Config, repo db.Repository) *Service {
	if strings.TrimSpace(cfg.StripeAPIKey) != "" {
		stripe.Key = cfg.StripeAPIKey
	}
	return &Service{cfg: cfg, repo: repo}
}

// GetEntitlements returns the plan entitlements for a tenant (used by other services for limit enforcement)
func (s *Service) GetEntitlements(ctx context.Context, tenantID string) (domain.PlanEntitlements, error) {
	tenant, err := s.repo.GetTenantByID(ctx, tenantID)
	if err != nil {
		if errors.Is(err, pgx.ErrNoRows) {
			// Default to Pro entitlements for tenants without billing
			return entitlementsForPlan("pro"), nil
		}
		return domain.PlanEntitlements{}, err
	}
	return entitlementsForPlan(tenant.PlanCode), nil
}

func (s *Service) GetSubscription(ctx context.Context, principal domain.Principal) (domain.SubscriptionSnapshot, error) {
	membership, err := s.repo.GetTenantMembershipBySubject(ctx, principal.Subject)
	if err != nil {
		if errors.Is(err, pgx.ErrNoRows) {
			return domain.SubscriptionSnapshot{}, ErrBillingMembership
		}
		return domain.SubscriptionSnapshot{}, err
	}

	record, err := s.repo.GetSubscriptionSnapshot(ctx, membership.Tenant.ID)
	if err != nil {
		if errors.Is(err, pgx.ErrNoRows) {
			return toSnapshot(membership.Tenant, db.BillingSnapshotRecord{
				TenantID:        membership.Tenant.ID,
				BillingProvider: "stripe",
				Status:          firstNonEmpty(membership.Tenant.SubscriptionStatus, "inactive"),
				PlanCode:        shared.NormalizePlanCode(membership.Tenant.PlanCode),
				Currency:        "czk",
			}, s.cfg), nil
		}
		return domain.SubscriptionSnapshot{}, err
	}

	return toSnapshot(membership.Tenant, record, s.cfg), nil
}

func (s *Service) CreateCheckoutSession(ctx context.Context, principal domain.Principal, planCode string, currency string, billingInterval string) (domain.CheckoutLaunchResponse, error) {
	membership, err := s.repo.GetTenantMembershipBySubject(ctx, principal.Subject)
	if err != nil {
		if errors.Is(err, pgx.ErrNoRows) {
			return domain.CheckoutLaunchResponse{}, ErrBillingMembership
		}
		return domain.CheckoutLaunchResponse{}, err
	}
	if !s.cfg.StripeConfigured() {
		return domain.CheckoutLaunchResponse{}, ErrStripeNotConfigured
	}

	// Default to monthly if not specified
	if billingInterval == "" {
		billingInterval = "monthly"
	}

	return s.createStripeCheckoutSession(ctx, principal, membership, planCode, currency, billingInterval)
}

func (s *Service) createStripeCheckoutSession(ctx context.Context, principal domain.Principal, membership db.TenantMembershipRecord, planCode string, currency string, billingInterval string) (domain.CheckoutLaunchResponse, error) {
	priceID, resolvedPlanCode, resolvedCurrency := s.stripePriceForPlan(planCode, currency, billingInterval)
	if priceID == "" {
		return domain.CheckoutLaunchResponse{}, ErrBillingPlanUnsupported
	}

	// Ensure customer exists (KV sync model: always pre-create customers)
	customerID := derefString(membership.Tenant.BillingCustomerID)
	if customerID == "" {
		cust, err := customer.New(&stripe.CustomerParams{
			Email: stripe.String(strings.TrimSpace(principal.Email)),
			Metadata: map[string]string{
				"tenantId":   membership.Tenant.ID,
				"tenantSlug": membership.Tenant.Slug,
				"userId":     principal.Subject,
			},
		})
		if err != nil {
			return domain.CheckoutLaunchResponse{}, fmt.Errorf("failed to create stripe customer: %w", err)
		}
		customerID = cust.ID
		if err := s.repo.UpdateTenantBillingCustomerID(ctx, membership.Tenant.ID, "stripe", customerID); err != nil {
			return domain.CheckoutLaunchResponse{}, err
		}
	}

	// Create checkout session - 15-day free trial for Starter/Pro only (not Business)
	// Trial requires credit card to be entered
	trialDays := int64(0)
	if resolvedPlanCode == "starter" || resolvedPlanCode == "pro" {
		trialDays = 15
	}

	params := &stripe.CheckoutSessionParams{
		Customer:                stripe.String(customerID),
		SuccessURL:              stripe.String(strings.TrimRight(s.cfg.FrontendURL, "/") + "/dashboard?billing=success&session_id={CHECKOUT_SESSION_ID}"),
		CancelURL:               stripe.String(strings.TrimRight(s.cfg.FrontendURL, "/") + "/dashboard?billing=cancelled"),
		Mode:                    stripe.String(string(stripe.CheckoutSessionModeSubscription)),
		PaymentMethodCollection: stripe.String("always"), // Require credit card even for free trial
		LineItems: []*stripe.CheckoutSessionLineItemParams{
			{
				Price:    stripe.String(priceID),
				Quantity: stripe.Int64(1),
			},
		},
		SubscriptionData: &stripe.CheckoutSessionSubscriptionDataParams{
			TrialPeriodDays: stripe.Int64(trialDays),
		},
		Metadata: map[string]string{
			"tenantId":        membership.Tenant.ID,
			"tenantSlug":      membership.Tenant.Slug,
			"userId":          principal.Subject,
			"userEmail":       strings.TrimSpace(principal.Email),
			"planCode":        resolvedPlanCode,
			"currency":        resolvedCurrency,
			"billingInterval": billingInterval,
			"source":          "bookra-dashboard",
		},
	}
	sess, err := checkoutsession.New(params)
	if err != nil {
		return domain.CheckoutLaunchResponse{}, fmt.Errorf("failed to create stripe checkout session: %w", err)
	}

	return domain.CheckoutLaunchResponse{
		CheckoutURL:        sess.URL,
		SuccessRedirectURL: sess.SuccessURL,
		CancelRedirectURL:  sess.CancelURL,
	}, nil
}

func (s *Service) Refresh(ctx context.Context, principal domain.Principal) (domain.SubscriptionSnapshot, error) {
	membership, err := s.repo.GetTenantMembershipBySubject(ctx, principal.Subject)
	if err != nil {
		if errors.Is(err, pgx.ErrNoRows) {
			return domain.SubscriptionSnapshot{}, ErrBillingMembership
		}
		return domain.SubscriptionSnapshot{}, err
	}

	customerID := derefString(membership.Tenant.BillingCustomerID)
	if customerID == "" {
		return toSnapshot(membership.Tenant, db.BillingSnapshotRecord{
			TenantID:        membership.Tenant.ID,
			BillingProvider: "stripe",
			Status:          "inactive",
			PlanCode:        shared.NormalizePlanCode(membership.Tenant.PlanCode),
			Currency:        "czk",
		}, s.cfg), nil
	}

	if !s.cfg.StripeConfigured() {
		return domain.SubscriptionSnapshot{}, ErrStripeNotConfigured
	}

	record, err := s.syncStripeDataToKV(ctx, membership.Tenant, customerID)
	if err != nil {
		return domain.SubscriptionSnapshot{}, err
	}
	return toSnapshot(membership.Tenant, record, s.cfg), nil
}

func (s *Service) CreatePortalSession(ctx context.Context, principal domain.Principal) (domain.PortalSessionResponse, error) {
	membership, err := s.repo.GetTenantMembershipBySubject(ctx, principal.Subject)
	if err != nil {
		if errors.Is(err, pgx.ErrNoRows) {
			return domain.PortalSessionResponse{}, ErrBillingMembership
		}
		return domain.PortalSessionResponse{}, err
	}

	customerID := derefString(membership.Tenant.BillingCustomerID)
	if customerID == "" {
		return domain.PortalSessionResponse{}, ErrBillingCustomerMissing
	}
	if !s.cfg.StripeConfigured() {
		return domain.PortalSessionResponse{}, ErrStripeNotConfigured
	}

	return s.createStripePortalSession(customerID)
}

func (s *Service) createStripePortalSession(customerID string) (domain.PortalSessionResponse, error) {
	params := &stripe.BillingPortalSessionParams{
		Customer:  stripe.String(customerID),
		ReturnURL: stripe.String(s.cfg.FrontendURL + "/dashboard?billing=refresh"),
	}
	sess, err := portalsession.New(params)
	if err != nil {
		return domain.PortalSessionResponse{}, fmt.Errorf("failed to create stripe portal session: %w", err)
	}
	return domain.PortalSessionResponse{URL: sess.URL}, nil
}

func (s *Service) HandleStripeWebhook(ctx context.Context, req *http.Request) error {
	return s.handleStripeWebhook(ctx, req)
}

func (s *Service) handleStripeWebhook(ctx context.Context, req *http.Request) error {
	if s.cfg.StripeWebhookKey == "" {
		return ErrStripeWebhookMissing
	}
	if strings.TrimSpace(req.Header.Get("Stripe-Signature")) == "" {
		return ErrStripeSignatureMissing
	}

	body, err := io.ReadAll(req.Body)
	if err != nil {
		return err
	}

	event, err := webhook.ConstructEvent(body, req.Header.Get("Stripe-Signature"), s.cfg.StripeWebhookKey)
	if err != nil {
		return fmt.Errorf("invalid stripe webhook signature: %w", err)
	}

	if !slices.Contains(allowedStripeWebhookEvents, event.Type) {
		return nil
	}

	// Extract customer ID from event data
	var customerID string
	var eventID = event.ID

	switch event.Type {
	case "checkout.session.completed":
		var sess stripe.CheckoutSession
		if err := json.Unmarshal(event.Data.Raw, &sess); err != nil {
			return err
		}
		customerID = sess.Customer.ID
		if sess.Metadata != nil {
			if tenantID := sess.Metadata["tenantId"]; tenantID != "" {
				tenant, err := s.repo.GetTenantByID(ctx, tenantID)
				if err != nil {
					if errors.Is(err, pgx.ErrNoRows) {
						return nil
					}
					return err
				}
				if customerID != "" && derefString(tenant.BillingCustomerID) == "" {
					if err := s.repo.UpdateTenantBillingCustomerID(ctx, tenant.ID, "stripe", customerID); err != nil {
						return err
					}
					tenant.BillingCustomerID = &customerID
				}
				_, err = s.syncStripeDataToKV(ctx, tenant, customerID)
				return err
			}
		}

	default:
		var data struct {
			Customer struct {
				ID string `json:"id"`
			} `json:"customer"`
		}
		if err := json.Unmarshal(event.Data.Raw, &data); err != nil {
			return err
		}
		customerID = data.Customer.ID
	}

	if customerID == "" {
		return nil
	}

	tenant, err := s.repo.GetTenantByBillingCustomerID(ctx, customerID)
	if err != nil {
		if errors.Is(err, pgx.ErrNoRows) {
			return nil
		}
		return err
	}

	inserted, err := s.repo.RecordBillingEvent(ctx, tenant.ID, "stripe", eventID, string(event.Type), event.Data.Raw)
	if err != nil || !inserted {
		return err
	}

	_, err = s.syncStripeDataToKV(ctx, tenant, customerID)
	return err
}

// syncStripeDataToKV is the core sync function following the KV sync model.
// It fetches full subscription state from Stripe and stores it in the database.
// This function is called after checkout success and on every relevant webhook event.
func (s *Service) syncStripeDataToKV(ctx context.Context, tenant db.TenantRecord, customerID string) (db.BillingSnapshotRecord, error) {
	// Fetch all subscriptions for this customer from Stripe
	iter := subscription.List(&stripe.SubscriptionListParams{
		Customer: stripe.String(customerID),
	})

	var selected *stripe.Subscription
	for iter.Next() {
		sub := iter.Subscription()
		if selected == nil || stripeSubscriptionRank(sub) > stripeSubscriptionRank(selected) {
			selected = sub
		}
	}
	if iter.Err() != nil {
		return db.BillingSnapshotRecord{}, fmt.Errorf("failed to list stripe subscriptions: %w", iter.Err())
	}

	now := time.Now().UTC()
	record := db.BillingSnapshotRecord{
		TenantID:              tenant.ID,
		BillingProvider:       "stripe",
		BillingCustomerID:     customerID,
		BillingSubscriptionID: "",
		Status:                "inactive",
		PlanCode:              shared.NormalizePlanCode(tenant.PlanCode),
		Currency:              "czk",
		PriceID:               "",
		LastSyncedAt:          &now,
	}

	if selected != nil {
		record.BillingSubscriptionID = selected.ID
		record.Status = normalizeStripeSubscriptionStatus(selected.Status)
		record.Currency = strings.ToLower(string(selected.Currency))
		record.CancelAtPeriodEnd = selected.CancelAtPeriodEnd
		record.CurrentPeriodStart = stripeTimeToPtr(selected.CurrentPeriodStart)
		record.CurrentPeriodEnd = stripeTimeToPtr(selected.CurrentPeriodEnd)

		// Extract price ID from subscription items
		if len(selected.Items.Data) > 0 {
			record.PriceID = selected.Items.Data[0].Price.ID
			record.PlanCode = s.stripePlanCodeForPrice(record.PriceID, tenant.PlanCode)
		}

		// Get payment method info if available
		if selected.DefaultPaymentMethod != nil && selected.DefaultPaymentMethod.Card != nil {
			record.PaymentMethodBrand = string(selected.DefaultPaymentMethod.Card.Brand)
			record.PaymentMethodLast4 = selected.DefaultPaymentMethod.Card.Last4
		}
	}

	// Store normalized snapshot in DB (KV cache)
	if err := s.repo.UpsertSubscriptionSnapshot(ctx, record); err != nil {
		return db.BillingSnapshotRecord{}, err
	}
	if err := s.repo.UpdateTenantBillingState(ctx, tenant.ID, "stripe", record.PlanCode, record.Status, record.BillingSubscriptionID); err != nil {
		return db.BillingSnapshotRecord{}, err
	}

	return record, nil
}

func stripeSubscriptionRank(sub *stripe.Subscription) int {
	switch sub.Status {
	case stripe.SubscriptionStatusActive:
		return 6
	case stripe.SubscriptionStatusTrialing:
		return 5
	case stripe.SubscriptionStatusPastDue:
		return 4
	case stripe.SubscriptionStatusPaused:
		return 3
	case stripe.SubscriptionStatusCanceled:
		return 2
	default:
		return 1
	}
}

func normalizeStripeSubscriptionStatus(status stripe.SubscriptionStatus) string {
	switch status {
	case stripe.SubscriptionStatusActive:
		return "active"
	case stripe.SubscriptionStatusTrialing:
		return "trialing"
	case stripe.SubscriptionStatusPastDue:
		return "past_due"
	case stripe.SubscriptionStatusPaused:
		return "paused"
	case stripe.SubscriptionStatusCanceled:
		return "canceled"
	case stripe.SubscriptionStatusUnpaid:
		return "canceled"
	default:
		return "inactive"
	}
}

func stripeTimeToPtr(t int64) *time.Time {
	if t == 0 {
		return nil
	}
	ts := time.Unix(t, 0).UTC()
	return &ts
}

func toSnapshot(tenant db.TenantRecord, record db.BillingSnapshotRecord, cfg config.Config) domain.SubscriptionSnapshot {
	if record.PlanCode == "" {
		record.PlanCode = shared.NormalizePlanCode(tenant.PlanCode)
	} else {
		record.PlanCode = shared.NormalizePlanCode(record.PlanCode)
	}
	record.Currency = normalizeCurrency(record.Currency)
	if record.Status == "" {
		record.Status = firstNonEmpty(tenant.SubscriptionStatus, "inactive")
	}

	customerID := firstNonEmpty(record.BillingCustomerID, derefString(tenant.BillingCustomerID))
	provider := firstNonEmpty(record.BillingProvider, tenant.BillingProvider, "stripe")

	return domain.SubscriptionSnapshot{
		TenantID:           tenant.ID,
		Provider:           provider,
		CustomerID:         customerID,
		SubscriptionID:     firstNonEmpty(record.BillingSubscriptionID, derefString(tenant.BillingSubscription)),
		Status:             record.Status,
		PlanCode:           record.PlanCode,
		Currency:           record.Currency,
		PriceID:            record.PriceID,
		CancelAtPeriodEnd:  record.CancelAtPeriodEnd,
		CurrentPeriodStart: record.CurrentPeriodStart,
		CurrentPeriodEnd:   record.CurrentPeriodEnd,
		PaymentMethodBrand: record.PaymentMethodBrand,
		PaymentMethodLast4: record.PaymentMethodLast4,
		Entitlements:       entitlementsForPlan(record.PlanCode),
		DisplayPrices:      displayPricesForPlan(record.PlanCode),
		TrialDays: func() int {
			if record.PlanCode == "starter" || record.PlanCode == "pro" {
				return 15
			}
			return 0
		}(),
		LastSyncedAt:         record.LastSyncedAt,
		CheckoutURLAvailable: billingCheckoutAvailable(cfg, record.PlanCode),
		SyncAvailable:        cfg.StripeConfigured(),
		PortalAvailable:      cfg.StripeConfigured() && customerID != "",
	}
}

func entitlementsForPlan(planCode string) domain.PlanEntitlements {
	switch shared.NormalizePlanCode(planCode) {
	case "starter":
		// Starter: 1 location, 1 staff, 50 bookings/month
		return domain.PlanEntitlements{
			MaxLocations:      1,
			MaxStaff:          1,
			MaxBookingsMonth:  50,
			EmailReminders:    false,
			AdvancedReporting: false,
			WidgetEmbedding:   true,
			UmamiTracking:     false,
			APIAccess:         false,
			SMSAvailable:      false,
		}
	case "business":
		// Business: Unlimited everything, API access, dedicated manager
		return domain.PlanEntitlements{
			MaxLocations:      -1, // Unlimited
			MaxStaff:          -1, // Unlimited
			MaxBookingsMonth:  -1, // Unlimited
			EmailReminders:    true,
			AdvancedReporting: true,
			WidgetEmbedding:   true,
			UmamiTracking:     true,
			APIAccess:         true,
			DedicatedManager:  true,
			SMSAvailable:      true,
		}
	default:
		// Pro: 3 locations, 10 staff, unlimited bookings, email reminders, analytics
		return domain.PlanEntitlements{
			MaxLocations:      3,
			MaxStaff:          10,
			MaxBookingsMonth:  -1, // Unlimited
			EmailReminders:    true,
			AdvancedReporting: true,
			WidgetEmbedding:   true,
			UmamiTracking:     true,
			APIAccess:         false,
			SMSAvailable:      true,
		}
	}
}

func (s *Service) stripePlanCodeForPrice(priceID string, fallback string) string {
	for planCode, currencies := range s.cfg.StripePriceMatrix {
		for _, configuredPriceID := range currencies {
			if configuredPriceID != "" && configuredPriceID == priceID {
				return shared.NormalizePlanCode(planCode)
			}
		}
	}
	return shared.NormalizePlanCode(fallback)
}

func (s *Service) stripePriceForPlan(planCode string, currency string, billingInterval string) (string, string, string) {
	resolvedPlan := shared.NormalizePlanCode(strings.TrimSpace(planCode))
	if resolvedPlan == "" {
		resolvedPlan = "pro"
	}
	resolvedCurrency := normalizeCurrency(currency)
	resolvedInterval := billingInterval
	if resolvedInterval == "" {
		resolvedInterval = "monthly"
	}

	// Build the price key: plan:currency:interval (e.g., "pro:usd:monthly", "pro:usd:yearly")
	priceKey := resolvedPlan + ":" + resolvedCurrency + ":" + resolvedInterval
	if priceID := s.cfg.StripePriceMatrix[resolvedPlan][priceKey]; priceID != "" {
		return priceID, resolvedPlan, resolvedCurrency
	}

	// Fall back to plan:currency format (for backwards compatibility)
	priceKey = resolvedPlan + ":" + resolvedCurrency
	if priceID := s.cfg.StripePriceMatrix[resolvedPlan][priceKey]; priceID != "" {
		return priceID, resolvedPlan, resolvedCurrency
	}

	// Try just plan code with interval
	if resolvedInterval != "monthly" {
		priceKey = resolvedPlan + ":" + resolvedInterval
		if priceID := s.cfg.StripePriceMatrix[resolvedPlan][priceKey]; priceID != "" {
			return priceID, resolvedPlan, resolvedCurrency
		}
	}

	// Default currency fallback
	if resolvedCurrency != "usd" {
		priceKey = resolvedPlan + ":usd:" + resolvedInterval
		if priceID := s.cfg.StripePriceMatrix[resolvedPlan][priceKey]; priceID != "" {
			return priceID, resolvedPlan, "usd"
		}
	}

	return s.cfg.StripePriceMatrix[resolvedPlan][resolvedPlan+":czk"], resolvedPlan, "czk"
}

func displayPricesForPlan(planCode string) []domain.PlanDisplayPrice {
	switch shared.NormalizePlanCode(planCode) {
	case "starter":
		// Starter: $5/month, $50/year (save $10 = ~17%)
		return []domain.PlanDisplayPrice{
			{Currency: "czk", AmountCents: 11900, Formatted: "119 Kč/mo", YearlyAmountCents: 119000, YearlyFormatted: "1 190 Kč/yr", YearlySavings: "Save 199 Kč", YearlySavingsPercent: 17},
			{Currency: "usd", AmountCents: 500, Formatted: "$5/mo", YearlyAmountCents: 5000, YearlyFormatted: "$50/yr", YearlySavings: "Save $10", YearlySavingsPercent: 17},
		}
	case "business":
		// Business: $50/month, $500/year (save $100 = ~17%)
		return []domain.PlanDisplayPrice{
			{Currency: "czk", AmountCents: 119900, Formatted: "1 199 Kč/mo", YearlyAmountCents: 1199000, YearlyFormatted: "11 990 Kč/yr", YearlySavings: "Save 1 999 Kč", YearlySavingsPercent: 17},
			{Currency: "usd", AmountCents: 5000, Formatted: "$50/mo", YearlyAmountCents: 50000, YearlyFormatted: "$500/yr", YearlySavings: "Save $100", YearlySavingsPercent: 17},
		}
	default:
		// Pro: $20/month, $200/year (save $40 = ~17%)
		return []domain.PlanDisplayPrice{
			{Currency: "czk", AmountCents: 49900, Formatted: "499 Kč/mo", YearlyAmountCents: 499000, YearlyFormatted: "4 990 Kč/yr", YearlySavings: "Save 999 Kč", YearlySavingsPercent: 17},
			{Currency: "usd", AmountCents: 2000, Formatted: "$20/mo", YearlyAmountCents: 20000, YearlyFormatted: "$200/yr", YearlySavings: "Save $40", YearlySavingsPercent: 17},
		}
	}
}

func normalizeCurrency(currency string) string {
	switch strings.ToLower(strings.TrimSpace(currency)) {
	case "usd":
		return "usd"
	case "eur":
		return "eur"
	default:
		return "czk"
	}
}

func billingCheckoutAvailable(cfg config.Config, planCode string) bool {
	if !cfg.StripeConfigured() || !cfg.StripeWebhookConfigured() {
		return false
	}
	planCode = shared.NormalizePlanCode(planCode)
	for _, priceID := range cfg.StripePriceMatrix[planCode] {
		if strings.TrimSpace(priceID) != "" {
			return true
		}
	}
	return false
}

func derefString(value *string) string {
	if value == nil {
		return ""
	}
	return *value
}

func firstNonEmpty(values ...string) string {
	for _, value := range values {
		if strings.TrimSpace(value) != "" {
			return strings.TrimSpace(value)
		}
	}
	return ""
}

// CheckAndSendTrialEndingEmails checks all tenants with trials and sends emails for those ending soon
func (s *Service) CheckAndSendTrialEndingEmails(ctx context.Context, notificationService interface {
	SendTrialEndingEmail(ctx context.Context, tenantID string, daysRemaining int) error
}) error {
	// Get all tenants with trial status
	tenants, _, err := s.repo.ListAllTenants(ctx, 1000, 0)
	if err != nil {
		return err
	}

	now := time.Now().UTC()
	for _, tenant := range tenants {
		if tenant.SubscriptionStatus != "trialing" && tenant.SubscriptionStatus != "trial" {
			continue
		}

		// Get subscription to check trial end date
		snapshot, err := s.repo.GetSubscriptionSnapshot(ctx, tenant.ID)
		if err != nil {
			continue
		}

		// Calculate trial end: assume 15-day trial from period start
		var trialEnd time.Time
		if snapshot.CurrentPeriodStart != nil {
			trialEnd = snapshot.CurrentPeriodStart.Add(15 * 24 * time.Hour)
		} else {
			// Default to 15 days from now if no start date
			trialEnd = now.Add(15 * 24 * time.Hour)
		}

		daysRemaining := int(trialEnd.Sub(now).Hours() / 24)

		// Send email if trial ends in 1-3 days
		if daysRemaining >= 1 && daysRemaining <= 3 {
			if err := notificationService.SendTrialEndingEmail(ctx, tenant.ID, daysRemaining); err != nil {
				// Log but don't fail
				fmt.Printf("Failed to send trial ending email for tenant %s: %v\n", tenant.ID, err)
			}
		}
	}

	return nil
}