// src/db/schema.ts
// ... imports and 'users', 'subscriptions' tables ...

import { sql } from 'drizzle-orm';

// ... users table ...
export const users = pgTable('users', {
  id: text('id').primaryKey(),
  // ... other fields ...
  stripeCustomerId: text('stripe_customer_id'),
  subscriptionStatus: text('subscription_status'),

  // We keep a "total credits" field on the user table for fast reads
  // This is a "redundant" field, kept in sync via triggers or Server Actions
  totalCredits: integer('total_credits').default(0).notNull(),
});

// Credit transaction table: tracks every credit addition and deduction
export const creditTransactions = pgTable('credit_transactions', {
  id: text('id').primaryKey().default(sql`gen_random_uuid()`),
  userId: text('user_id').references(() => users.id, { onDelete: 'cascade' }).notNull(),
  amount: integer('amount').notNull(), // Positive for additions, negative for consumption
  description: text('description'), // e.g., "Monthly Pro Plan", "Consumed: AI Summary"
  expiresAt: timestamp('expires_at'), // NULL means never expires
  createdAt: timestamp('created_at').defaultNow().notNull(),
});

'use server';

import { db } from '@/db';
import { users, creditTransactions } from '@/db/schema';
import { auth } from '@/lib/auth';
import { eq, sql, and, gt, sum } from 'drizzle-orm';

// Core function: consume credits
// This is a critical "atomic" operation
export async function consumeCredits(userId: string, amountToConsume: number, description: string) {
  // Note: amountToConsume should be positive, e.g., 2
  if (amountToConsume <= 0) {
    return { error: 'Invalid amount' };
  }

  // Use Drizzle transaction to ensure atomicity
  try {
    const result = await db.transaction(async (tx) => {
      // 1. Get current user
      const user = await tx.query.users.findFirst({
        where: eq(users.id, userId),
        columns: { totalCredits: true },
      });

      if (!user) {
        throw new Error('User not found');
      }

      // 2. Check if user has enough credits
      if (user.totalCredits < amountToConsume) {
        return { error: 'Insufficient credits' };
      }

      // 3. Update total credits in users table
      // Use sql`...` to perform atomic update, preventing race conditions
      await tx.update(users)
        .set({ totalCredits: sql`${users.totalCredits} - ${amountToConsume}` })
        .where(eq(users.id, userId));

      // 4. Insert a consumption transaction
      await tx.insert(creditTransactions).values({
        userId: userId,
        amount: -amountToConsume, // Consumption, so negative
        description: description,
      });

      return { success: true, newTotal: user.totalCredits - amountToConsume };
    });

    return result;

  } catch (err: any) {
    console.error('Credit consumption failed:', err.message);
    return { error: 'Transaction failed' };
  }
}

// Internal function: add credits (called by Webhook or after successful purchase)
export async function grantCredits(
  userId: string,
  amount: number,
  description: string,
  expiresInDays: number | null = null
) {
  const expiresAt = expiresInDays ? new Date(Date.now() + expiresInDays * 24 * 60 * 60 * 1000) : null;

  try {
    const result = await db.transaction(async (tx) => {
      // 1. Update users table total
      await tx.update(users)
        .set({ totalCredits: sql`${users.totalCredits} + ${amount}` })
        .where(eq(users.id, userId));

      // 2. Insert an addition transaction
      await tx.insert(creditTransactions).values({
        userId: userId,
        amount: amount,
        description: description,
        expiresAt: expiresAt,
      });
    });
    return { success: true };
  } catch (err: any) {
    return { error: 'Failed to grant credits' };
  }
}

// (Cron Job) Daily task: clear expired credits
export async function expireCreditsCronJob() {
  // This is a complex query, pseudocode as follows:
  // 1. Find all expired creditTransactions (amount > 0 and expiresAt < now())
  // 2. Calculate total expired credits per user
  // 3. Subtract corresponding amount in users table
  // 4. (Optional) Insert a negative "expired" transaction
  console.log('Running daily credit expiration job...');
  // ... configure this route as a cron job in Vercel.json ...
}

// ... in handleCheckoutSessionCompleted or handleSubscriptionUpdated ...

// Before:
// await db.update(users).set({ subscriptionStatus: subscription.status })...

// Now (when invoice.paid occurs):
const userId = ...; // Get from session metadata or database query
const plan = 'pro'; // ... determine the plan the user purchased ...

if (plan === 'pro') {
  // Business logic: Pro plan grants 1000 credits monthly, valid for 30 days
  await grantCredits(
    userId,
    1000,
    "Monthly Pro Plan Credits",
    30
  );
}

// ... update subscriptionStatus, etc. ...

// src/config/price-config.ts (or .tsx)

import { CheckIcon, XIcon } from 'lucide-react'; // Example

export type PlanId = 'free' | 'pro' | 'lifetime';

export interface PlanFeature {
  text: string;
  icon?: React.ReactNode;
  available: boolean;
}

export interface PricePlan {
  id: PlanId;
  name: string;
  description: string;

  // Subscription-related
  stripePriceId: string | null;
  monthlyPrice: number | null;

  // One-time purchase (for Lifetime)
  stripeOneTimePriceId: string | null;
  oneTimePrice: number | null;

  // Credits
  credits: number; // Credits granted monthly/one-time

  // UI feature list
  features: PlanFeature[];
}

// Free plan
const freePlan: PricePlan = {
  id: 'free',
  name: 'Free',
  description: 'Start for free, no credit card required.',
  stripePriceId: null,
  monthlyPrice: 0,
  stripeOneTimePriceId: null,
  oneTimePrice: null,
  credits: 10, // 10 credits upon registration (one-time)
  features: [
    { text: '5 AI Summaries per month', available: true },
    { text: 'Basic Support', available: true },
    { text: 'Advanced Features', available: false },
  ],
};

// Pro plan
const proPlan: PricePlan = {
  id: 'pro',
  name: 'Pro',
  description: 'For professionals and teams.',
  stripePriceId: process.env.NEXT_PUBLIC_STRIPE_PRO_PRICE_ID!, // From .env
  monthlyPrice: 20,
  stripeOneTimePriceId: null,
  oneTimePrice: null,
  credits: 1000, // 1000 credits monthly
  features: [
    { text: '1000 AI Credits per month', available: true },
    { text: 'Priority Support', available: true },
    { text: 'Advanced Features', available: true },
  ],
};

// Lifetime Deal (LTD)
const lifetimePlan: PricePlan = {
  id: 'lifetime',
  name: 'Lifetime',
  description: 'Pay once, use forever.',
  stripePriceId: null,
  monthlyPrice: null,
  stripeOneTimePriceId: process.env.NEXT_PUBLIC_STRIPE_LIFETIME_PRICE_ID!,
  oneTimePrice: 299,
  credits: 50000, // 50,000 one-time credits (never expire)
  features: [
    { text: '50,000 One-time Credits', available: true },
    { text: 'All Pro Features', available: true },
    { text: 'Lifetime Updates', available: true },
  ],
};

// Export configuration
export const priceConfig = {
  plans: [freePlan, proPlan, lifetimePlan],
  // (Optional) Additional credit purchase packs
  topUpPacks: [
    {
      name: "Credit Pack 500",
      price: 10,
      credits: 500,
      stripePriceId: process.env.NEXT_PUBLIC_STRIPE_TOPUP_500_ID!,
    }
  ]
};

// src/components/payment/PricingTable.tsx
'use client';

import { useState } from 'react';
import { createCheckoutSession } from '@/actions/payment.actions';
import { Button } from '@/components/ui/button';
import { priceConfig, PricePlan } from '@/config/price-config'; // Import configuration

// ...

// Single plan card
function PlanCard({ plan }: { plan: PricePlan }) {
  const [isLoading, setIsLoading] = useState(false);

  const handleUpgrade = async () => {
    setIsLoading(true);
    let priceId: string | null = null;

    if (plan.stripePriceId) {
      priceId = plan.stripePriceId;
    } else if (plan.stripeOneTimePriceId) {
      priceId = plan.stripeOneTimePriceId;
    } else {
      console.error("No price ID for this plan");
      setIsLoading(false);
      return;
    }

    // Call Server Action (from Ch 11)
    const result = await createCheckoutSession(priceId);

    if (result.url) {
      window.location.href = result.url;
    } else {
      console.error(result.error);
    }
    setIsLoading(false);
  };

  return (
    <div className="border p-4 rounded-lg">
      <h2>{plan.name}</h2>
      <p>{plan.description}</p>
      <b>{plan.credits} Credits</b>

      <ul>
        {plan.features.map(feature => (
          <li key={feature.text}>{feature.text}</li>
        ))}
      </ul>

      {plan.id !== 'free' && (
        <Button onClick={handleUpgrade} disabled={isLoading}>
          {isLoading ? 'Processing...' : `Get ${plan.name}`}
        </Button>
      )}
    </div>
  );
}

// Render all plans
export function PricingTable() {
  return (
    <div className="flex gap-4">
      {priceConfig.plans.map(plan => (
        <PlanCard key={plan.id} plan={plan} />
      ))}
    </div>
  );
}