import { createRevenue } from '@classytic/revenue';
import { ManualProvider } from '@classytic/revenue-manual';

const revenue = await createRevenue({
  connection: mongoose.connection,
  defaultCurrency: 'BDT',
  providers: { manual: new ManualProvider() },
});

// Create payment — returns raw mongokit doc
const txn = await revenue.repositories.transaction.createPaymentIntent({
  amount: 10000,
  gateway: 'manual',
  data: { customerId: 'cust_1', sourceId: 'order_1', sourceModel: 'Order' },
});
// txn.publicId → 'txn_a7b3xk9m2p1q4d5e6f'
// txn.gateway.metadata.instructions → 'Payment Amount: 10000 BDT...'

// Verify (admin approves manual payment)
const verified = await revenue.repositories.transaction.verify(
  txn.gateway.paymentIntentId,
  { verifiedBy: 'admin_1' },
);
// verified.status → 'verified'

// Refund — returns the refund transaction doc
const refundTxn = await revenue.repositories.transaction.refund(
  txn._id.toString(), 5000, { reason: 'partial return' },
);
// refundTxn.type → 'refund', refundTxn.flow → 'outflow', refundTxn.amount → 5000

const revenue = await createRevenue({
  // Required
  connection: mongoose.connection,
  defaultCurrency: 'BDT',

  // Providers — register any payment gateway
  providers: {
    manual: new ManualProvider(),
    stripe: new StripeProvider({ apiKey: '...' }),
    bkash: new BkashProvider({ ... }),
  },

  // Modules — progressive opt-in
  modules: {
    subscription: true,          // default: true
    escrow: true,                // default: false
    settlement: true,            // default: false
    commission: {                // commission calculation
      defaultRate: 0.05,
      gatewayFeeRate: 0.025,
    },
  },

  // Event transport — Arc-compatible, drop-in Redis/Outbox
  eventTransport: new RedisEventTransport(ioredis),

  // Bridges — optional external integrations
  bridges: {
    ledger: { onPaymentVerified: async (txn, ctx) => { ... } },
    tax: { computeTax: async (amount, taxClass, ctx) => { ... } },
    notification: { onPaymentVerified: async (txn, ctx) => { ... } },
    currency: { convert: async (amount, from, to) => { ... } },
    customer: { getCustomer: async (id) => { ... } },
    analytics: { trackEvent: async (name, payload) => { ... } },
  },

  // MongoKit plugins — inject per repository
  repositoryPlugins: {
    transaction: [cachePlugin({ adapter: redis })],
  },

  // Schema extensions — add custom fields to models
  schemaOptions: {
    transaction: {
      extraFields: { branch: { type: String }, vatInvoiceNumber: { type: String } },
      extraIndexes: [{ fields: { branch: 1, createdAt: -1 } }],
    },
  },

  multiTenant: true,             // default: true
});

interface RevenueEngine {
  config: Readonly<RevenueConfig>;
  models: RevenueModels;              // Mongoose models
  repositories: RevenueRepositories;  // MongoKit repositories (the API surface)
  providers: ProviderRegistry;        // Payment providers
  events: RevenueEventTransport;      // Event transport
  destroy(): Promise<void>;
}

import { defineResource } from '@classytic/arc';
import { requireRoles } from '@classytic/arc/permissions';
import { createAdapter } from '#shared/adapter';

export default defineResource({
  name: 'transaction',
  prefix: '/revenue/transactions',
  adapter: createAdapter(revenue.models.Transaction, revenue.repositories.transaction),
  presets: ['multiTenant', 'softDelete'],

  // State transitions → unified action endpoint POST /:id/action
  actions: {
    verify: {
      handler: (id, data, req) => revenue.repositories.transaction.verify(id, data, req.scope),
      permissions: requireRoles('admin', 'finance-manager'),
      schema: { verifiedBy: { type: 'string' } },
      description: 'Verify a pending payment',
    },
    refund: {
      handler: (id, data, req) =>
        revenue.repositories.transaction.refund(id, data.amount, { reason: data.reason }, req.scope),
      permissions: requireRoles('admin'),
      schema: {
        amount: { type: 'number', minimum: 1 },
        reason: { type: 'string', minLength: 3 },
      },
    },
    hold: {
      handler: (id, data, req) => revenue.repositories.transaction.hold(id, data, req.scope),
      permissions: requireRoles('admin', 'marketplace-ops'),
      schema: { reason: { type: 'string' }, amount: { type: 'number' } },
    },
    release: {
      handler: (id, data, req) => revenue.repositories.transaction.release(id, data, req.scope),
      permissions: requireRoles('admin', 'marketplace-ops'),
      schema: {
        recipientId: { type: 'string' },
        recipientType: { type: 'string' },
        amount: { type: 'number' },
      },
    },
    split: {
      handler: (id, data, req) => revenue.repositories.transaction.split(id, data.rules, req.scope),
      permissions: requireRoles('admin'),
      schema: { rules: { type: 'array' } },
    },
  },

  // Non-state transitions stay as custom routes (webhooks, queries, batch ops)
  routes: [
    {
      method: 'POST', path: '/webhook/:provider',
      handler: (req) =>
        revenue.repositories.transaction.handleWebhook(req.params.provider, req.body, req.headers),
    },
  ],
});

// State transition via action endpoint
await fetch('/revenue/transactions/txn_abc123/action', {
  method: 'POST',
  body: JSON.stringify({ action: 'verify', verifiedBy: 'admin_1' }),
});

await fetch('/revenue/transactions/txn_abc123/action', {
  method: 'POST',
  body: JSON.stringify({ action: 'refund', amount: 5000, reason: 'customer request' }),
});

// Filter list via QueryParser
await fetch('/revenue/transactions?status=verified&amount_gte=1000&sort=-createdAt&page=1&limit=20');

import { PaymentProvider, PaymentIntent, PaymentResult, RefundResult, WebhookEvent } from '@classytic/revenue';
import type { CreateIntentParams, ProviderCapabilities } from '@classytic/revenue/providers';

export class StripeProvider extends PaymentProvider {
  public override readonly name = 'stripe';

  constructor(config: { apiKey: string }) {
    super(config);
  }

  // 1. Create payment intent — called by createPaymentIntent()
  async createIntent(params: CreateIntentParams): Promise<PaymentIntent> {
    const stripe = new Stripe(this.config.apiKey as string);
    const intent = await stripe.paymentIntents.create({
      amount: params.amount,
      currency: params.currency,
      metadata: params.metadata as Stripe.MetadataParam,
    });

    return new PaymentIntent({
      id: intent.id,
      sessionId: null,
      paymentIntentId: intent.id,
      provider: 'stripe',
      status: intent.status,
      amount: intent.amount,
      currency: intent.currency,
      clientSecret: intent.client_secret,      // frontend needs this
      metadata: params.metadata ?? {},
      raw: intent,
    });
  }

  // 2. Verify payment — called by verify()
  async verifyPayment(intentId: string): Promise<PaymentResult> {
    const stripe = new Stripe(this.config.apiKey as string);
    const intent = await stripe.paymentIntents.retrieve(intentId);

    return new PaymentResult({
      id: intent.id,
      provider: 'stripe',
      status: intent.status === 'succeeded' ? 'succeeded'
        : intent.status === 'requires_action' ? 'requires_action'
        : intent.status === 'processing' ? 'processing'
        : 'failed',
      amount: intent.amount,
      currency: intent.currency,
      paidAt: intent.status === 'succeeded' ? new Date() : undefined,
      metadata: {},
      raw: intent,
    });
  }

  // 3. Get status — same as verify for most providers
  async getStatus(intentId: string): Promise<PaymentResult> {
    return this.verifyPayment(intentId);
  }

  // 4. Refund — called by refund()
  async refund(paymentId: string, amount?: number | null, options?: { reason?: string }): Promise<RefundResult> {
    const stripe = new Stripe(this.config.apiKey as string);
    const refund = await stripe.refunds.create({
      payment_intent: paymentId,
      amount: amount ?? undefined,
      reason: options?.reason as any,
    });

    return new RefundResult({
      id: refund.id,
      provider: 'stripe',
      status: refund.status === 'succeeded' ? 'succeeded' : 'processing',
      amount: refund.amount,
      currency: refund.currency,
      refundedAt: new Date(),
      reason: options?.reason,
      metadata: {},
      raw: refund,
    });
  }

  // 5. Handle webhook — called by handleWebhook()
  async handleWebhook(payload: unknown, headers?: Record<string, string>): Promise<WebhookEvent> {
    const stripe = new Stripe(this.config.apiKey as string);
    const sig = headers?.['stripe-signature'] ?? '';
    const event = stripe.webhooks.constructEvent(payload as string, sig, this.config.webhookSecret as string);

    return new WebhookEvent({
      id: event.id,
      provider: 'stripe',
      type: event.type,
      data: {
        paymentIntentId: (event.data.object as any).id,
        sessionId: (event.data.object as any).id,
      },
      createdAt: new Date(event.created * 1000),
      raw: event,
    });
  }

  // 6. Capabilities — tells revenue what this provider supports
  override getCapabilities(): ProviderCapabilities {
    return {
      supportsWebhooks: true,
      supportsRefunds: true,
      supportsPartialRefunds: true,
      requiresManualVerification: false,
    };
  }
}

const revenue = await createRevenue({
  connection,
  defaultCurrency: 'BDT',
  providers: {
    manual: new ManualProvider(),
    stripe: new StripeProvider({ apiKey: process.env.STRIPE_KEY }),
    bkash: new BkashProvider({ appKey: '...', appSecret: '...' }),
  },
});

// Use by gateway name
const txn = await revenue.repositories.transaction.createPaymentIntent({
  amount: 5000,
  gateway: 'bkash',   // matches key in providers map
});

interface RevenueDomainEvent<T = unknown> {
  type: string;              // 'revenue:payment.verified'
  payload: T;                // event-specific data
  meta: {
    id: string;              // crypto.randomUUID()
    timestamp: Date;
    resource?: string;       // 'transaction', 'subscription', 'settlement'
    resourceId?: string;     // publicId (txn_..., sub_..., stl_...)
    userId?: string;         // from RevenueContext.actorId
    organizationId?: string; // from RevenueContext.organizationId
    correlationId?: string;  // from RevenueContext.traceId
    aggregate?: string;      // 'revenue'
    version?: number;
    causationId?: string;
    tags?: string[];
  };
}

interface RevenueEventTransport {
  publish(event: RevenueDomainEvent): Promise<void>;
  subscribe?(pattern: string, handler: RevenueEventHandler): Promise<() => void>;
  close?(): Promise<void>;
}

// Arc Redis
import { RedisEventTransport } from '@classytic/arc/events';
const revenue = await createRevenue({
  eventTransport: new RedisEventTransport(ioredis),
});

// Arc Outbox (guaranteed delivery)
import { EventOutbox } from '@classytic/arc/events';
const outbox = new EventOutbox({ store: mongoOutboxStore, transport: redisTransport });
const revenue = await createRevenue({
  eventTransport: { publish: (event) => outbox.store(event) },
});

// No events (testing)
import { NoopRevenueEventTransport } from '@classytic/revenue';
const revenue = await createRevenue({
  eventTransport: new NoopRevenueEventTransport(),
});

await revenue.events.subscribe?.('revenue:payment.*', handler);   // payment.verified, payment.refunded, ...
await revenue.events.subscribe?.('revenue:*', handler);            // all revenue events
await revenue.events.subscribe?.('*', handler);                    // everything
await revenue.events.subscribe?.('revenue:escrow.held', handler);  // exact match

interface RevenueBridges {
  ledger?: LedgerBridge;             // post journal entries on payment events
  tax?: TaxBridge;                    // compute tax for amounts
  notification?: NotificationBridge;  // send emails/SMS on lifecycle events
  currency?: CurrencyBridge;          // multi-currency conversion
  customer?: CustomerBridge;          // resolve customer details
  analytics?: AnalyticsBridge;        // track events for BI
  source?: SourceBridge;              // resolve polymorphic source documents (Order, Invoice, Stripe charge, etc.)
}

// Same MongoDB, single connection (most common)
const revenue = await createRevenue({
  connection,
  bridges: {
    source: {
      async resolve(sourceId, sourceModel) {
        const Model = mongoose.connection.models[sourceModel];
        return Model ? await Model.findById(sourceId).lean() : null;
      },
    },
  },
});

// Microservices (different DBs / HTTP)
bridges: {
  source: {
    async resolve(sourceId, sourceModel) {
      if (sourceModel === 'Order') return await fetch(`http://orders-svc/${sourceId}`).then(r => r.json());
      if (sourceModel === 'Invoice') return await invoiceDb.collection('invoices').findOne({ _id: sourceId });
      return null;
    },
  },
}

// External systems (Stripe, Postgres)
bridges: {
  source: {
    async resolve(sourceId, sourceModel) {
      if (sourceModel === 'StripeCharge') return await stripe.charges.retrieve(sourceId);
      if (sourceModel === 'PostgresOrder') {
        const { rows } = await pg.query('SELECT * FROM orders WHERE id = $1', [sourceId]);
        return rows[0];
      }
      return null;
    },
  },
}

{
  method: 'GET',
  path: '/:id/with-source',
  handler: async (req) => {
    const txn = await revenue.repositories.transaction.getById(req.params.id);
    const source = txn.sourceId
      ? await revenue.config.bridges?.source?.resolve?.(txn.sourceId, txn.sourceModel, req.scope)
      : null;
    return { ...txn, source };
  },
}

async resolveMany(refs, ctx) {
  // Group by sourceModel, batch fetch, return Map<sourceId, doc>
}

interface LedgerBridge {
  onPaymentVerified?(transaction: Record<string, unknown>, ctx: RevenueContext): Promise<void>;
  onRefundProcessed?(original: Record<string, unknown>, refund: Record<string, unknown>, ctx: RevenueContext): Promise<void>;
  onSettlementCompleted?(settlement: Record<string, unknown>, ctx: RevenueContext): Promise<void>;
}

interface TaxBridge {
  computeTax?(amount: number, taxClass: string, ctx: RevenueContext): Promise<{ rate: number; amount: number; inclusive: boolean }>;
}

// Soft delete (sets deletedAt)
await revenue.repositories.transaction.delete(id);

// Restore a soft-deleted document
await revenue.repositories.transaction.restore(id);

// List soft-deleted documents
const trash = await revenue.repositories.transaction.getDeleted({ page: 1, limit: 50 });

// Read a specific soft-deleted document
const doc = await revenue.repositories.transaction.getById(id, { includeDeleted: true });

import { softDeletePlugin } from '@classytic/mongokit';

const revenue = await createRevenue({
  connection,
  defaultCurrency: 'USD',
  repositoryPlugins: {
    transaction: [softDeletePlugin({ ttlDays: 2555 })],   // 7 years
    subscription: [softDeletePlugin({ ttlDays: 2555 })],
  },
});

// Custom Arc route for surgical force-delete
{
  method: 'DELETE',
  path: '/:id/force',
  permissions: requireRoles('superadmin', 'compliance-officer'),
  handler: async (req) => {
    const id = req.params.id;

    // Verify it IS soft-deleted first
    const doc = await revenue.repositories.transaction.getById(id, {
      includeDeleted: true,
      throwOnNotFound: false,
    });
    if (!doc) return { error: 'Not found' };
    if (!(doc as any).deletedAt) {
      return { error: 'Document is not soft-deleted. Soft-delete first.' };
    }

    // Hard delete via raw Mongoose model
    await revenue.repositories.transaction.Model.deleteOne({ _id: id });

    // Audit
    await auditBridge.log({
      action: 'force_delete',
      resource: 'transaction',
      resourceId: doc.publicId,
      actor: req.user.id,
      reason: req.body.reason,
    });

    return { success: true, publicId: doc.publicId };
  },
}

{
  method: 'POST',
  path: '/force-cleanup',
  permissions: requireRoles('superadmin'),
  handler: async (req) => {
    const { olderThanDays = 30, dryRun = true } = req.body;
    const cutoff = new Date(Date.now() - olderThanDays * 24 * 60 * 60 * 1000);
    const query = { deletedAt: { $ne: null, $lte: cutoff } };

    if (dryRun) {
      const count = await revenue.repositories.transaction.Model.countDocuments(query);
      return { dryRun: true, wouldDelete: count };
    }

    const result = await revenue.repositories.transaction.Model.deleteMany(query);
    return { deleted: result.deletedCount };
  },
}

{
  method: 'GET',
  path: '/trash',
  permissions: requireRoles('admin'),
  handler: (req) => revenue.repositories.transaction.getDeleted({
    page: req.query.page ?? 1,
    limit: req.query.limit ?? 50,
    sort: { deletedAt: -1 },
  }),
}

import {
  transactionCreateSchema, transactionUpdateSchema, transactionListFilterSchema,
  subscriptionCreateSchema, subscriptionListFilterSchema,
  settlementCreateSchema, settlementListFilterSchema,
  paymentIntentSchema, paymentVerifySchema, refundSchema,
  escrowHoldSchema, escrowReleaseSchema, splitRuleSchema,
} from '@classytic/revenue/schemas';