// auth.ts
import { betterAuth } from "better-auth";
import { paymongo } from "better-auth-paymongo";

export const auth = betterAuth({
  // ... your auth config
  plugins: [
    paymongo({
      secretKey: process.env.PAYMONGO_SECRET_KEY!,
      
      // Define your features
      features: {
        projects: { type: "metered", limit: 3 },      // Usage-limited
        api_calls: { type: "metered", limit: 1000 },  // Usage-limited
        premium_support: { type: "boolean" },          // Access-only
        export_pdf: { type: "boolean" },               // Access-only
      },
      
      // Define your plans
      plans: {
        free: {
          amount: 0,
          currency: "PHP",
          displayName: "Free",
          interval: "monthly",
          features: {
            projects: 3,        // Override: 3 projects
            api_calls: 100,     // Override: 100 API calls
            premium_support: false,
            export_pdf: false,
          },
        },
        pro: {
          amount: 99900,        // 999.00 PHP (in centavos)
          currency: "PHP",
          displayName: "Pro",
          interval: "monthly",
          features: {
            projects: 25,
            api_calls: 10000,
            premium_support: true,
            export_pdf: true,
          },
        },
        enterprise: {
          amount: 499900,       // 4,999.00 PHP
          currency: "PHP",
          displayName: "Enterprise",
          interval: "monthly",
          features: {
            projects: 100,
            api_calls: 100000,
            premium_support: true,
            export_pdf: true,
          },
        },
      },
      
      // Optional: Enable organization billing
      scopes: ["user", "organization"],
    }),
  ],
});

// auth-client.ts
import { createAuthClient } from "better-auth/client";
import { paymongoClient } from "better-auth-paymongo/client";

export const authClient = createAuthClient({
  plugins: [paymongoClient()],
});

import { authClient } from "./auth-client";

// Subscribe to a plan
const { data, error } = await authClient.paymongo.attach("pro", {
  successUrl: window.location.origin + "/billing/success?ref=xxx",
  cancelUrl: window.location.origin + "/billing/cancel",
});

if (data) {
  // Redirect to PayMongo checkout
  window.location.href = data.checkoutUrl;
}

// Check feature access
const { data: check } = await authClient.paymongo.check("projects");
if (check?.allowed) {
  // User has access to projects feature
  console.log(`${check.balance} / ${check.limit} projects remaining`);
}

// Track usage
const { data: track } = await authClient.paymongo.track("api_calls");
console.log(`API calls remaining: ${track?.balance}`);

// Attach plan to an organization
await authClient.paymongo.attach("enterprise", {
  successUrl: "/success?ref=xxx",
  cancelUrl: "/cancel",
  organizationId: "org_123",
});

// Check organization features
const { data } = await authClient.paymongo.check("projects", {
  organizationId: "org_123",
});

// Track organization usage
await authClient.paymongo.track("api_calls", {
  delta: 5,
  organizationId: "org_123",
});

import { betterAuth } from "better-auth";
import { organization } from "better-auth/plugins";
import { paymongo, createPaymongoOrganization } from "better-auth-paymongo";

const paymongoConfig = {
  secretKey: process.env.PAYMONGO_SECRET_KEY!,
  features: {
    seats: { type: "metered", limit: 5 },
    projects: { type: "metered", limit: 10 },
  },
  plans: {
    starter: {
      amount: 49900,
      currency: "PHP",
      displayName: "Starter",
      interval: "monthly",
      features: { seats: 5, projects: 10 },
    },
    pro: {
      amount: 99900,
      currency: "PHP",
      displayName: "Pro", 
      interval: "monthly",
      features: { seats: 25, projects: 50 },
    },
  },
};

export const auth = betterAuth({
  plugins: [
    paymongo(paymongoConfig),
    organization({
      ...createPaymongoOrganization(paymongoConfig),
    }),
  ],
});

organization({
  membershipLimit: createSeatLimit(adapter, {
    featureId: 'seats',
    defaultLimit: 5
  })
})

const { used, limit, remaining } = await getOrganizationSeats(adapter, "org_123");

import { useCheck, useSubscription, refreshBilling } from "better-auth-paymongo/react";

function FeatureGate({ children }: { children: React.ReactNode }) {
  const { allowed, balance, limit, loading, error } = useCheck("projects");

  if (loading) return <Spinner />;
  if (error) return <Error message={error.message} />;
  if (!allowed) return <UpgradePrompt />;

  return (
    <div>
      <p>Projects: {balance} / {limit}</p>
      {children}
    </div>
  );
}

function BillingStatus() {
  const { planId, loading, refresh } = useSubscription();

  if (loading) return <Spinner />;

  return (
    <div>
      <p>Current Plan: {planId || "Free"}</p>
      <button onClick={refresh}>Refresh</button>
    </div>
  );
}

// Manually trigger refresh after checkout
function CheckoutSuccess() {
  useEffect(() => {
    refreshBilling(); // Triggers re-fetch for all hooks
  }, []);

  return <p>Payment successful!</p>;
}

// Boolean feature (access control)
{ type: "boolean" }

// Metered feature (usage tracking)
{ type: "metered", limit: 1000 }

// Next.js API route example
import { auth } from "@/lib/auth";

export async function POST(req: Request) {
  const session = await auth.api.getSession({ headers: req.headers });
  if (!session) return new Response("Unauthorized", { status: 401 });

  // Check feature access
  const check = await fetch(`${process.env.NEXT_PUBLIC_URL}/api/auth/paymongo/check?feature=api_calls`, {
    headers: req.headers,
  }).then(r => r.json());

  if (!check.allowed) {
    return new Response("Usage limit exceeded", { status: 429 });
  }

  // Track usage
  await fetch(`${process.env.NEXT_PUBLIC_URL}/api/auth/paymongo/track`, {
    method: "POST",
    headers: req.headers,
    body: JSON.stringify({ feature: "api_calls" }),
  });

  // Your business logic here
  return new Response("Success");
}

import type {
  PaymongoAutumnConfig,
  PlanConfig,
  FeatureConfig,
  AttachResponse,
  CheckResponse,
  TrackResponse,
  UsageRecord,
} from "better-auth-paymongo";