# Stripe
STRIPE_SECRET_KEY=sk_test_...
NEXT_PUBLIC_STRIPE_PUBLISHABLE_KEY=pk_test_...
STRIPE_WEBHOOK_SECRET=whsec_...

# Price IDs
STRIPE_PRICE_ID_STARTER_MONTHLY=price_...
STRIPE_PRICE_ID_STARTER_ANNUAL=price_...
STRIPE_PRICE_ID_PRO_MONTHLY=price_...
STRIPE_PRICE_ID_PRO_ANNUAL=price_...

import Stripe from "stripe";

let _stripe: Stripe | null = null;

export function getStripeServer(): Stripe {
  if (!process.env.STRIPE_SECRET_KEY) {
    throw new Error("STRIPE_SECRET_KEY is not set");
  }
  if (!_stripe) {
    _stripe = new Stripe(process.env.STRIPE_SECRET_KEY);
  }
  return _stripe;
}

// Proxy para backward compatibility
export const stripe = new Proxy({} as Stripe, {
  get(_target, prop) {
    return getStripeServer()[prop as keyof Stripe];
  },
});

import { loadStripe } from "@stripe/stripe-js";

let stripePromise: ReturnType<typeof loadStripe> | null = null;

export function getStripe() {
  if (!stripePromise) {
    stripePromise = loadStripe(
      process.env.NEXT_PUBLIC_STRIPE_PUBLISHABLE_KEY!
    );
  }
  return stripePromise;
}

export const pricingPlans: PricingPlan[] = [
  {
    id: "starter",
    name: "Starter",
    icon: Zap,
    description: "Para proyectos que estan empezando",
    pricing: {
      monthly: {
        price: 19,
        priceId: process.env.STRIPE_PRICE_ID_STARTER_MONTHLY || "",
      },
      annual: {
        price: 15,
        priceId: process.env.STRIPE_PRICE_ID_STARTER_ANNUAL || "",
      },
    },
    currency: "EUR",
    cta: "Empezar ahora",
    features: ["Hasta 1.000 usuarios", "Pagos con Stripe", /* ... */],
  },
  // ... plan Pro
];

export const stripeConfig = {
  plans: pricingPlans,
  successUrl: `${process.env.NEXT_PUBLIC_APP_URL}/dashboard?success=true`,
  cancelUrl: `${process.env.NEXT_PUBLIC_APP_URL}/#pricing`,
  portalReturnUrl: `${process.env.NEXT_PUBLIC_APP_URL}/billing`,
};

import { NextRequest, NextResponse } from "next/server";
import { auth } from "@/lib/auth";
import { stripe } from "@/lib/stripe";
import { db } from "@/lib/db";
import { stripeConfig } from "@/config/stripe";
import { resolveCheckoutMode } from "@/lib/stripe-events";

export async function POST(request: NextRequest) {
  // 1. Verificar autenticación
  const session = await auth.api.getSession({
    headers: request.headers,
  });

  if (!session?.user) {
    return NextResponse.json(
      { message: "No autorizado. Inicia sesión primero." },
      { status: 401 }
    );
  }

  const { priceId, planName, couponId } = await request.json();

  // 2. Obtener o crear Stripe Customer
  let stripeCustomerId: string | undefined;

  const subscription = await db.subscription.findUnique({
    where: { userId: session.user.id },
  });

  if (subscription?.stripeCustomerId) {
    stripeCustomerId = subscription.stripeCustomerId;
  } else {
    const customer = await stripe.customers.create({
      email: session.user.email,
      name: session.user.name,
      metadata: { userId: session.user.id },
    });
    stripeCustomerId = customer.id;

    await db.subscription.upsert({
      where: { userId: session.user.id },
      update: { stripeCustomerId: customer.id },
      create: {
        userId: session.user.id,
        stripeCustomerId: customer.id,
      },
    });
  }

  // 3. Determinar si es pago único o suscripcion
  const price = await stripe.prices.retrieve(priceId);
  const mode = resolveCheckoutMode(price.type);

  // 4. Crear sesión de checkout
  const checkoutSession = await stripe.checkout.sessions.create({
    customer: stripeCustomerId,
    mode,
    payment_method_types: ["card"],
    line_items: [{ price: priceId, quantity: 1 }],
    success_url: stripeConfig.successUrl,
    cancel_url: stripeConfig.cancelUrl,
    metadata: {
      userId: session.user.id,
      planName: planName || "",
    },
    tax_id_collection: { enabled: true },
    customer_update: { name: "auto", address: "auto" },
    ...(couponId
      ? { discounts: [{ coupon: couponId }] }
      : { allow_promotion_codes: true }),
  });

  return NextResponse.json({ url: checkoutSession.url });
}

"use client";

import { useState } from "react";
import { Button } from "@/components/ui/button";

interface CheckoutButtonProps {
  priceId: string;
  planName: string;
  children: React.ReactNode;
}

export function CheckoutButton({ priceId, planName, children }: CheckoutButtonProps) {
  const [loading, setLoading] = useState(false);

  async function handleCheckout() {
    setLoading(true);

    try {
      const res = await fetch("/api/stripe/checkout", {
        method: "POST",
        headers: { "Content-Type": "application/json" },
        body: JSON.stringify({ priceId, planName }),
      });

      const data = await res.json();

      if (data.url) {
        // Redirigir a Stripe Checkout
        window.location.href = data.url;
      } else {
        console.error("Error:", data.message);
      }
    } catch (error) {
      console.error("Error al crear checkout:", error);
    } finally {
      setLoading(false);
    }
  }

  return (
    <Button onClick={handleCheckout} disabled={loading} className="w-full">
      {loading ? "Redirigiendo..." : children}
    </Button>
  );
}

<CheckoutButton
  priceId={process.env.NEXT_PUBLIC_STRIPE_PRICE_ID_PRO || ""}
  planName="Pro"
>
  Obtener Pro
</CheckoutButton>

export async function POST(request: NextRequest) {
  const body = await request.text();
  const signature = request.headers.get("stripe-signature");

  // Verificar firma del webhook
  const event = stripe.webhooks.constructEvent(
    body, signature!, webhookSecret
  );

  switch (event.type) {
    case "checkout.session.completed":
      // Pago completado -> Activar plan del usuario
      await handleCheckoutCompleted(session);
      break;

    case "customer.subscription.updated":
      // Suscripcion actualizada -> Sincronizar estado
      await handleSubscriptionUpdate(subscription);
      break;

    case "customer.subscription.deleted":
      // Suscripcion cancelada -> Marcar como cancelado
      await handleSubscriptionDeleted(subscription);
      break;

    case "invoice.paid":
      // Factura pagada -> Reactivar si estaba pendiente
      await handleInvoicePaid(invoice);
      break;

    case "invoice.payment_failed":
      // Pago fallido -> Marcar como past_due
      await handlePaymentFailed(invoice);
      break;
  }

  return NextResponse.json({ received: true });
}

async function handleCheckoutCompleted(session: Stripe.Checkout.Session) {
  const userId = session.metadata?.userId;
  const planName = session.metadata?.planName;

  await db.subscription.upsert({
    where: { userId },
    update: {
      plan: planName,
      status: "active",
      stripePriceId: priceId,
    },
    create: {
      userId,
      stripeCustomerId: session.customer as string,
      plan: planName,
      status: "active",
      stripePriceId: priceId,
    },
  });
}

model Subscription {
  id                     String    @id @default(cuid())
  userId                 String    @unique
  user                   User      @relation(fields: [userId], references: [id], onDelete: Cascade)
  stripeCustomerId       String?   @unique
  stripeSubscriptionId   String?   @unique
  stripePriceId          String?
  stripeCurrentPeriodEnd DateTime?
  plan                   String?   // "starter" | "pro"
  status                 String    @default("inactive")
  createdAt              DateTime  @default(now())
  updatedAt              DateTime  @updatedAt

  @@map("subscriptions")
}

import { db } from "@/lib/db";

async function hasActivePlan(userId: string): boolean {
  const subscription = await db.subscription.findUnique({
    where: { userId },
  });

  return subscription?.status === "active";
}

async function getUserPlan(userId: string): string | null {
  const subscription = await db.subscription.findUnique({
    where: { userId },
    select: { plan: true, status: true },
  });

  if (subscription?.status !== "active") return null;
  return subscription.plan;
}