Momento/memento-note/lib/billing/stripe-prices.ts

import type { SubscriptionTier } from '@/lib/plan-entitlements';
import { stripe } from '@/lib/stripe';
import { getConfigValue } from '@/lib/config';

export type BillingTier = 'PRO' | 'BUSINESS';
export type BillingInterval = 'month' | 'year';

export interface DynamicPrice {
  display: string;
  amount: number;
  currency: string;
}

export const DEFAULT_PRICES: Record<BillingTier, Record<BillingInterval, DynamicPrice>> = {
  PRO: {
    month: { display: '9,90 €', amount: 9.90, currency: 'EUR' },
    year: { display: '99,00 €', amount: 99.00, currency: 'EUR' },
  },
  BUSINESS: {
    month: { display: '29,90 €', amount: 29.90, currency: 'EUR' },
    year: { display: '299,00 €', amount: 299.00, currency: 'EUR' },
  },
};

export async function isBillingEnabled(): Promise<boolean> {
  const flag = await getConfigValue('BILLING_ENABLED', '');
  if (flag === 'true') return true;
  if (flag === 'false') return false;
  return process.env.NEXT_PUBLIC_FEATURE_BILLING_ENABLED === 'true'
    || process.env.NODE_ENV === 'development';
}

export async function getDynamicPrices(): Promise<Record<BillingTier, Record<BillingInterval, DynamicPrice>>> {
  const isMock = !process.env.STRIPE_SECRET_KEY || process.env.STRIPE_SECRET_KEY === 'sk_test_placeholder';
  if (isMock) {
    return DEFAULT_PRICES;
  }

  const result: Record<BillingTier, Record<BillingInterval, DynamicPrice>> = {
    PRO: {
      month: { ...DEFAULT_PRICES.PRO.month },
      year: { ...DEFAULT_PRICES.PRO.year },
    },
    BUSINESS: {
      month: { ...DEFAULT_PRICES.BUSINESS.month },
      year: { ...DEFAULT_PRICES.BUSINESS.year },
    },
  };

  const retrieveAndFormatPrice = async (tier: BillingTier, interval: BillingInterval) => {
    try {
      const priceId = await resolvePriceId(tier, interval);
      const price = await stripe.prices.retrieve(priceId);
      if (price.unit_amount !== null && price.unit_amount !== undefined) {
        const amount = price.unit_amount / 100;
        const currency = price.currency.toUpperCase();

        let display = '';
        if (currency === 'EUR') {
          display = `${amount.toLocaleString('fr-FR', { minimumFractionDigits: 0, maximumFractionDigits: 2 })} €`;
        } else if (currency === 'USD') {
          display = `$${amount.toLocaleString('en-US', { minimumFractionDigits: 0, maximumFractionDigits: 2 })}`;
        } else if (currency === 'GBP') {
          display = `£${amount.toLocaleString('en-GB', { minimumFractionDigits: 0, maximumFractionDigits: 2 })}`;
        } else {
          display = `${amount} ${currency}`;
        }

        result[tier][interval] = { display, amount, currency };
      }
    } catch (err) {
      console.error(`[stripe-prices] Failed to retrieve price for ${tier}/${interval}:`, err);
    }
  };

  await Promise.all([
    retrieveAndFormatPrice('PRO', 'month'),
    retrieveAndFormatPrice('PRO', 'year'),
    retrieveAndFormatPrice('BUSINESS', 'month'),
    retrieveAndFormatPrice('BUSINESS', 'year'),
  ]);

  return result;
}

const PRICE_ENV_KEYS: Record<BillingTier, Record<BillingInterval, string>> = {
  PRO: {
    month: 'STRIPE_PRICE_PRO_MONTHLY',
    year: 'STRIPE_PRICE_PRO_ANNUAL',
  },
  BUSINESS: {
    month: 'STRIPE_PRICE_BUSINESS_MONTHLY',
    year: 'STRIPE_PRICE_BUSINESS_ANNUAL',
  },
};

export async function resolvePriceId(tier: BillingTier, interval: BillingInterval): Promise<string> {
  const configKey = PRICE_ENV_KEYS[tier][interval];
  const fromDb = await getConfigValue(configKey, '');
  const priceId = fromDb || process.env[configKey] || '';
  if (priceId) return priceId;

  const isMock = !process.env.STRIPE_SECRET_KEY || process.env.STRIPE_SECRET_KEY === 'sk_test_placeholder';
  if (isMock && process.env.NODE_ENV !== 'test') {
    return `price_mock_${tier.toLowerCase()}_${interval}`;
  }
  throw new Error(`No Stripe price ID configured for ${tier}/${interval}`);
}

export async function priceIdToTier(priceId: string): Promise<SubscriptionTier | null> {
  if (priceId && priceId.startsWith('price_mock_')) {
    if (priceId.includes('pro')) return 'PRO';
    if (priceId.includes('business')) return 'BUSINESS';
    return 'BASIC';
  }

  const entries: Array<[string, SubscriptionTier]> = [
    [(await getConfigValue('STRIPE_PRICE_PRO_MONTHLY', '')) || process.env.STRIPE_PRICE_PRO_MONTHLY || '', 'PRO'],
    [(await getConfigValue('STRIPE_PRICE_PRO_ANNUAL', '')) || process.env.STRIPE_PRICE_PRO_ANNUAL || '', 'PRO'],
    [(await getConfigValue('STRIPE_PRICE_BUSINESS_MONTHLY', '')) || process.env.STRIPE_PRICE_BUSINESS_MONTHLY || '', 'BUSINESS'],
    [(await getConfigValue('STRIPE_PRICE_BUSINESS_ANNUAL', '')) || process.env.STRIPE_PRICE_BUSINESS_ANNUAL || '', 'BUSINESS'],
  ];
  for (const [envPriceId, tier] of entries) {
    if (envPriceId && envPriceId === priceId) return tier;
  }
  return null;
}