import { DaftarClient } from "@daftarhq/sdk";

// Initialize the client with your API key
const daftar = new DaftarClient({
  apiKey: "sk_your_api_key_here",
  baseUrl: "https://daftarhq.com/api",
});

// Create a customer with external ID (your system's user ID)
const customer = await daftar.customers.create({
  externalId: "user_123", // Your system's user ID
  name: "Acme Corporation",
});

// Your app chooses the market key. Daftar does not infer geography.
const marketKey = "saudi-arabia";

// Fetch the checkout-ready catalog for this exact plan and market.
const catalog = await daftar.pricing.getPlanCatalog("pro", {
  marketKey,
  billingPeriod: "monthly",
});
if (!catalog.marketPrice) throw new Error("Monthly price is not configured");

// Resolve the customer's wallet in the selected market currency.
const wallet = await daftar.wallets.getOrCreate(customer.id, catalog.marketPrice.currency);

// Top up the wallet
await wallet.topUp({
  amount: 1000, // decimal amount in catalog.marketPrice.currency
  reference: "Initial deposit",
  idempotencyKey: "deposit_user_123_initial",
});

// Grant admin credit without treating it as a customer payment.
await wallet.grantCredit({
  amount: 25,
  reference: "Goodwill credit",
  idempotencyKey: "manual_credit_user_123_001",
});

// Subscribe to a plan
const subscription = await daftar.subscriptions.create({
  customerExternalId: "user_123",
  planId: "pro",
  marketKey,
  billingPeriod: "monthly",
  currentPeriodStart: new Date(),
  currentPeriodEnd: new Date(Date.now() + 30 * 24 * 60 * 60 * 1000),
  contract: {
    basePrice: 700,
    notes: "Enterprise launch contract",
    meterOverrides: [
      {
        eventId: "api_calls",
        pricingModel: "per_unit",
        unitPrice: 0.01,
        includedUnits: 50000,
        chargeOverage: true,
        limitType: "event_quota",
        eventQuotaWindow: "billing_period",
      },
    ],
  },
});

// Track usage with idempotency
await daftar.usage.create({
  customerExternalId: "user_123",
  eventId: "api_calls",
  value: 1000,
  idempotencyKey: "usage_user_123_2024_01_15_batch_1",
});

const catalog = await daftar.pricing.getPlanCatalog("pro", {
  marketKey: "global",
  billingPeriod: "monthly",
});

await daftar.subscriptions.create({
  customerExternalId: "user_123",
  planId: "pro",
  marketKey: "global",
  billingPeriod: "monthly",
  currentPeriodStart: new Date(),
  currentPeriodEnd: new Date(Date.now() + 30 * 24 * 60 * 60 * 1000),
});

await daftar.usage.create({
  customerExternalId: "user_123",
  eventId: "api_calls",
  value: 1000,
});

// The SDK automatically handles the Authorization header
const client = new DaftarClient({
  apiKey: "sk_live_abcdef1234567890abcdef1234567890",
});

const { data: balances } = await daftar.balances.list(projectId);
const { data: markets } = await daftar.markets.list(projectId);

const market = markets.find((item) => item.name === "GCC" && item.currency === "USD");

const { data: catalogs, unavailable } = await daftar.pricing.listPlanCatalogs({
  marketKey: "global",
  billingPeriod: "monthly",
  limit: 20,
});

for (const catalog of catalogs) {
  if (!catalog.marketPrice) continue;
  console.log(catalog.plan.name, catalog.marketPrice.currency, catalog.marketPrice.basePrice);
}

if (unavailable.length > 0) {
  console.warn(
    "Some plans are not configured for this market:",
    unavailable.map((item) => item.plan.planId),
  );
}

const catalog = await daftar.pricing.getPlanCatalog(plan.id, {
  marketKey: "global",
  billingPeriod: "monthly",
});
if (!catalog.marketPrice) throw new Error("Select a billing period");

console.log(catalog.marketPrice.currency, catalog.marketPrice.basePrice);
for (const meterPrice of catalog.meterPrices) {
  console.log(meterPrice.meterEventId, meterPrice.includedUnits);
}

const planPrice = await daftar.pricing.addPriceToPlan(plan.id, {
  marketKey: "global",
  basePrice: 15,
  billingPeriod: "monthly",
});

const ksaPrice = await daftar.pricing.addPriceToPlan(plan.id, {
  marketKey: "ksa",
  basePrice: 55,
  billingPeriod: "monthly",
  copyMeterPricingFromPlanPriceId: planPrice.id,
});

await daftar.pricing.addToPlan(plan.id, {
  marketKey: "global",
  billingPeriod: "monthly",
  eventId: "api_calls",
  pricingModel: "per_unit",
  unitPrice: 0.02,
  includedUnits: 10000,
  chargeOverage: true,
  limitType: "event_quota",
  eventQuotaWindow: "billing_period",
});

// Create a customer
const customer = await daftar.customers.create({
  externalId: "user_123",
  name: "Acme Corp",
});

// Subscribe using fluent API
const subscription = await customer.subscribe({
  planId: "pro",
  marketKey: "global",
  billingPeriod: "monthly",
  contract: {
    basePrice: 700,
    notes: "Negotiated terms at subscription creation",
    meterOverrides: [
      {
        eventId: "api_calls",
        pricingModel: "per_unit",
        unitPrice: 0.01,
        includedUnits: 50000,
        chargeOverage: true,
        limitType: "event_quota",
        eventQuotaWindow: "billing_period",
      },
    ],
  },
});

// Track usage using fluent API
const usage = await customer.recordUsage({
  eventId: "api_calls",
  value: 1000,
});

// Get related data
const invoices = await customer.getInvoices();
const subscriptions = await customer.getSubscriptions();

// Resource methods on subscription
await subscription.cancel({ cancelAtPeriodEnd: true });
const planChange = await subscription.changePlan({
  newPlanId: "enterprise",
  billingPeriod: "monthly",
  timing: "immediate",
});
// Immediate same-period upgrades first charge any positive net adjustment from
// the customer's wallet. A low wallet balance returns code=insufficient_wallet_balance.
if (planChange.scheduledChange?.reason === "billing_period_change") {
  console.log("Plan changes at renewal:", planChange.scheduledChange.effectiveAt);
}

// Resource methods on wallet
const wallet = await daftar.wallets.getOrCreate(customer.id, "SAR");
await wallet.topUp({ amount: 100, idempotencyKey: "topup_user_123_001" });
await wallet.grantCredit({
  amount: 25,
  reference: "Goodwill credit",
  idempotencyKey: "manual_credit_user_123_001",
});
const transactions = await wallet.getTransactions();

// Single usage record
await client.usage.create({
  customerExternalId: "user_123",
  eventId: "api_calls",
  value: 1000,
  timestamp: "2024-01-15T10:00:00Z",
});

// Batch usage records
await client.usage.createBatch([
  {
    customerExternalId: "user_123",
    eventId: "api_calls",
    value: 500,
  },
  {
    customerExternalId: "user_123",
    eventId: "seats",
    value: 10,
  },
]);

// Get usage history
const usage = await client.usage.getCustomerUsage("00000000-0000-0000-0000-000000000000", {
  startDate: "2024-01-01",
  endDate: "2024-01-31",
  limit: 100,
});

// Get aggregated usage statistics
const stats = await client.usage.getAggregatedUsage("00000000-0000-0000-0000-000000000000", {
  startDate: "2024-01-01",
  endDate: "2024-01-31",
});

const decision = await client.access.check({
  customerExternalId: "user_123",
  feature: "api_calls",
  quantity: 1,
});

if (!decision.allowed) {
  console.log(`Blocked by billing: ${decision.reason}`);
}

const decision = await customer.can("api_calls", { quantity: 1 });

const state = await client.access.getCustomerState("user_123");

for (const entitlement of state.entitlements) {
  console.log(`${entitlement.feature}: ${entitlement.used}/${entitlement.limit ?? "metered"}`);
}

import {
  parseAndValidateWebhookPayload,
  toWebhookUpdate,
  verifyWebhookSignature,
  type DaftarWebhookPayload,
  type WebhookUpdate,
} from "@daftarhq/sdk";

// Express example: mount this route with express.raw({ type: "application/json" }).
app.post("/webhooks/daftar", express.raw({ type: "application/json" }), async (req, res) => {
  const payload = req.body.toString("utf8");
  const signature = req.header("X-Webhook-Signature");

  if (
    !verifyWebhookSignature({
      payload,
      signature,
      secret: process.env.DAFTAR_WEBHOOK_SECRET!,
    })
  ) {
    return res.status(400).send("Invalid signature");
  }

  const event = parseAndValidateWebhookPayload(payload);
  await handleDaftarWebhook(event);
  res.sendStatus(204);
});

async function handleDaftarWebhook(event: DaftarWebhookPayload) {
  const update = toWebhookUpdate(event);
  await applyWebhookUpdate(update);
}

async function applyWebhookUpdate(update: WebhookUpdate) {
  if (update.action === "block_access") {
    await blockAccessLocally(update.customerId!, update.feature, update.reason);
  }
  if (update.action === "allow_access" || update.action === "refresh_entitlements") {
    await refreshEntitlements(update.customerId!);
  }
}

// Create customer
const customer = await client.customers.create({
  externalId: "user_123", // Your system's user ID
  name: "John Doe",
  email: "john@example.com",
});

// List customers
const customers = await client.customers.list({
  limit: 50,
  search: "John",
});

// Update customer
await client.customers.update("user_123", {
  name: "John Smith",
});

// Create subscription
const now = new Date();
const subscription = await daftar.subscriptions.create({
  customerExternalId: "user_123",
  planId: "pro",
  marketKey: "global",
  billingPeriod: "monthly",
  currentPeriodStart: now,
  currentPeriodEnd: new Date(now.getTime() + 30 * 24 * 60 * 60 * 1000),
  status: "active",
  contract: {
    basePrice: 700,
    notes: "Enterprise launch contract",
    meterOverrides: [
      {
        eventId: "api_calls",
        pricingModel: "per_unit",
        unitPrice: 0.01,
        includedUnits: 50000,
        chargeOverage: true,
        limitType: "event_quota",
        eventQuotaWindow: "billing_period",
      },
    ],
  },
});

// Check subscription status
if (subscription.isActive()) {
  console.log("Subscription is active");
}

if (subscription.isTrialing()) {
  console.log(`Trial ends: ${subscription.trialEnd}`);
}

// Cancel at period end (no refund)
await subscription.cancel({
  cancelAtPeriodEnd: true,
});

// Cancel immediately
await subscription.cancel({
  cancelAtPeriodEnd: false,
});

// Upgrade/downgrade plan. Same-billing-period changes can apply immediately
// with proration after any positive net adjustment is paid from the customer's
// wallet; monthly/yearly switches are scheduled for renewal.
const { proration, scheduledChange } = await subscription.changePlan({
  newPlanId: "enterprise",
  billingPeriod: "monthly",
  timing: "immediate",
});
if (proration) {
  console.log(
    `Net adjustment: ${proration.netAdjustment} (refund=${proration.prepaidRefund}, charge=${proration.newPlanCharge}, usage=${proration.usageCharges})`,
  );
}
if (scheduledChange) {
  console.log(`Plan changes at renewal: ${scheduledChange.effectiveAt}`);
}

// Inspect subscription-specific custom contract history, if the subscription
// was created with contract terms.
const contractHistory = await subscription.listContracts();

// Inspect the effective signed terms used by billing and access checks.
const terms = await subscription.getResolvedTerms();
console.log(terms.basePrice.amount, terms.basePrice.source);

// List customer subscriptions
const subs = await daftar.subscriptions.listForCustomer("00000000-0000-0000-0000-000000000000");

const wallet = await daftar.wallets.getOrCreate("00000000-0000-0000-0000-000000000000", "SAR");

// Top up wallet with idempotency key (prevents duplicate charges)
const { transaction, _idempotent } = await wallet.topUp({
  amount: 500, // decimal amount in this wallet currency
  reference: "Payment via bank transfer",
  idempotencyKey: "payment_inv_123",
});

if (_idempotent) {
  console.log("This top-up was already processed");
}

// Grant admin credit separately from customer-paid deposits.
await wallet.grantCredit({
  amount: 50,
  reference: "SLA credit",
  idempotencyKey: "manual_credit_sla_123",
});

// Check balance
console.log(`Current balance: ${wallet.balance}`);

// Refresh balance from server
await wallet.refreshBalance();

// Check if sufficient for a purchase
if (wallet.hasSufficientBalance(100)) {
  console.log("Can afford the purchase");
}

// Get transaction history
const { data: transactions, total } = await wallet.getTransactions({
  limit: 50,
});

// Create invoice
const invoice = await client.invoices.create({
  customerId: "00000000-0000-0000-0000-000000000000",
  periodStart: "2024-02-01",
  periodEnd: "2024-02-29",
  subtotal: 99,
  total: 99,
  dueDate: "2024-02-15",
  status: "open",
  type: "manual",
});

// Add line items
await client.invoices.addLineItem(invoice.id, {
  description: "Pro Plan - Monthly",
  quantity: 1,
  unitPrice: 99,
  amount: 99,
});

// Send invoice using resource method
await invoice.send();

// Pay invoice from customer's wallet
await invoice.pay();

// Get customer's invoices using fluent API
const customer = await client.customers.get("00000000-0000-0000-0000-000000000000");
const invoices = await customer.getInvoices({ limit: 10 });

import { DaftarClient, UsageBuffer } from "@daftarhq/sdk";

const daftar = new DaftarClient({ apiKey: "sk_..." });

// Create a buffer that batches events
const usageBuffer = new UsageBuffer(daftar, {
  maxBufferSize: 100, // Flush when 100 events buffered
  flushIntervalMs: 5000, // Or every 5 seconds
  maxRetries: 3, // Retry failed flushes
  instanceId: process.env.POD_NAME, // K8s pod name for deduplication
  onFlushError: (err, events) => {
    console.error(`Failed to flush ${events.length} events:`, err);
  },
});

// Track usage (non-blocking, buffers locally)
usageBuffer.track({
  customerExternalId: "user_123",
  eventId: "api_calls",
  value: 1,
});

// Graceful shutdown (flushes remaining events)
process.on("SIGTERM", async () => {
  await usageBuffer.shutdown();
  process.exit(0);
});

import { DaftarClient, RedisUsageBuffer } from "@daftarhq/sdk";
import Redis from "ioredis";

const redis = new Redis();
const daftar = new DaftarClient({ apiKey: "sk_..." });

const usageBuffer = new RedisUsageBuffer(daftar, {
  redis: {
    setnx: (k, v) => redis.setnx(k, v).then((r) => r === 1),
    expire: (k, s) => redis.expire(k, s).then(() => {}),
    lpush: (k, v) => redis.lpush(k, v).then(() => {}),
    lrange: (k, s, e) => redis.lrange(k, s, e),
    ltrim: (k, s, e) => redis.ltrim(k, s, e).then(() => {}),
  },
  keyPrefix: "myapp:billing:",
  idempotencyTtlSeconds: 86400, // 24 hours
});

// Returns false if duplicate (already tracked by another instance)
const isNew = await usageBuffer.trackWithDedup({
  customerExternalId: "user_123",
  eventId: "api_calls",
  value: 1,
});

import { DaftarClient, DaftarApiError } from "@daftarhq/sdk";

try {
  await client.customers.get("invalid-id");
} catch (error) {
  if (error instanceof DaftarApiError) {
    console.error("API Error:", error.error.message);
    console.error("Status Code:", error.statusCode);
    console.error("Error Details:", error.error.errors);
  } else {
    console.error("Unexpected error:", error);
  }
}

const client = new DaftarClient({
  apiKey: "your-api-key",
  baseUrl: "https://daftarhq.com/api",
  timeout: 15000, // Request timeout in ms
  retries: 3, // Number of retry attempts
});

import { Customer, CreateCustomerRequest } from "@daftarhq/sdk";

const customerData: CreateCustomerRequest = {
  externalId: "user_123",
  name: "Acme Corp",
};

const customer: Customer = await client.customers.create(customerData);