import { createHash } from 'crypto';
import { PaymentContactFlowService } from './payment-contact-flow.service';
const token = 'b'.repeat(64);
describe('PaymentContactFlowService', () => {
  let db: any, shopping: any, service: PaymentContactFlowService, session: any;
  beforeEach(() => {
    session = {
      id: createHash('sha256').update(token).digest('hex'),
      businessId: 'b1',
      customerId: 'c1',
      orderId: 'o1',
      phone: '263771234567',
      contactPhone: null,
      expiresAt: new Date(Date.now() + 60_000),
    };
    db = {
      businessIntegration: {
        findFirst: jest
          .fn()
          .mockResolvedValue({ credentialsEncrypted: 'encrypted' }),
      },
      paymentContactFlowSession: {
        findUnique: jest.fn(async () => session),
        findUniqueOrThrow: jest.fn(async () => session),
        create: jest.fn(),
        update: jest.fn(async ({ data }) => Object.assign(session, data)),
      },
      customer: { findFirst: jest.fn().mockResolvedValue({ id: 'c1' }) },
      order: {
        findFirst: jest.fn().mockResolvedValue({
          orderNumber: 'ORD1',
          totalAmount: 25,
          currency: 'USD',
        }),
        updateMany: jest.fn().mockResolvedValue({ count: 1 }),
      },
    };
    db.$transaction = jest.fn((callback) => callback(db));
    shopping = {
      cardCheckout: jest
        .fn()
        .mockResolvedValue('https://payments.example/checkout'),
    };
    service = new PaymentContactFlowService(
      db,
      {
        decryptJson: () => ({
          paymentContactFlowEnabled: true,
          paymentContactFlowId: 'flow-2',
        }),
      } as any,
      shopping,
    );
  });
  const request = (phone?: string) => ({
    action: 'data_exchange',
    flow_token: token,
    screen: 'PAYMENT_CONTACT',
    data: { phone },
  });
  it('prefills the sender phone, validates input, scopes the order update and deduplicates submissions', async () => {
    expect(
      (await service.exchange({ action: 'INIT', flow_token: token })).data
        .phone,
    ).toBe(session.phone);
    expect((await service.exchange(request('abc'))).screen).toBe(
      'PAYMENT_CONTACT',
    );
    expect((await service.exchange(request('+123'))).screen).toBe(
      'PAYMENT_CONTACT',
    );
    const summary = await service.exchange({
      action: 'INIT',
      flow_token: token,
    });
    expect(summary.data.message).toContain('ORD1');
    expect(summary.data.message).toContain('USD 25.00');
    expect(db.order.findFirst.mock.calls[0][0].where).toMatchObject({
      businessId: 'b1',
      customerId: 'c1',
      id: 'o1',
      customerPhone: session.phone,
    });
    expect(db.order.updateMany).not.toHaveBeenCalled();
    expect((await service.exchange(request('077 123 4567'))).screen).toBe(
      'PAYMENT_READY',
    );
    expect(db.order.updateMany).toHaveBeenCalledWith({
      where: {
        id: 'o1',
        businessId: 'b1',
        customerId: 'c1',
        customerPhone: '263771234567',
        paymentStatus: 'UNPAID',
        status: 'PENDING',
      },
      data: { paymentContactPhone: '263771234567' },
    });
    await service.exchange(request('+263779999999'));
    expect(db.order.updateMany).toHaveBeenCalledTimes(1);
  });
  it('rejects expired sessions, unavailable links and already paid/cancelled orders', async () => {
    session.expiresAt = new Date(0);
    await expect(service.exchange(request('+263771234567'))).rejects.toThrow(
      'FLOW_EXPIRED',
    );
    session.expiresAt = new Date(Date.now() + 60_000);
    shopping.cardCheckout.mockResolvedValue(null);
    await expect(service.exchange(request('+263771234567'))).rejects.toThrow(
      'FLOW_EXPIRED',
    );
    shopping.cardCheckout.mockResolvedValue(
      'https://payments.example/checkout',
    );
    db.order.updateMany.mockResolvedValue({ count: 0 });
    await expect(service.exchange(request('+263771234567'))).rejects.toThrow(
      'FLOW_EXPIRED',
    );
    expect(db.paymentContactFlowSession.update).not.toHaveBeenCalled();
  });
  it('requires completed sessions owned by the sender to return an existing provider link', async () => {
    expect(
      await service.checkoutFromCompletion('b1', 'c1', session.phone, token),
    ).toBeNull();
    session.contactPhone = session.phone;
    expect(
      await service.checkoutFromCompletion('other', 'c1', session.phone, token),
    ).toBeNull();
    expect(
      await service.checkoutFromCompletion('b1', 'other', session.phone, token),
    ).toBeNull();
    expect(
      await service.checkoutFromCompletion('b1', 'c1', '263779999999', token),
    ).toBeNull();
    expect(
      await service.checkoutFromCompletion('b1', 'c1', session.phone, 'bad'),
    ).toBeNull();
    expect(
      await service.checkoutFromCompletion('b1', 'c1', session.phone, token),
    ).toBe('https://payments.example/checkout');
    expect(shopping.cardCheckout).toHaveBeenLastCalledWith(
      'b1',
      session.phone,
      'o1',
    );
  });
  it('uses the configured Flow and stores only the hash of its opaque launch token', async () => {
    const saved = { ...process.env };
    process.env.WHATSAPP_APP_SECRET = 'configured';
    process.env.WHATSAPP_FLOWS_PRIVATE_KEY_PATH = '/mounted/key.pem';
    try {
      const result = await service.launch('b1', 'c1', session.phone, 'o1');
      const params = result!.payload.interactive.action.parameters;
      expect(params.flow_id).toBe('flow-2');
      expect(params.flow_action).toBe('data_exchange');
      expect(
        db.paymentContactFlowSession.create.mock.calls[0][0].data,
      ).toMatchObject({
        businessId: 'b1',
        customerId: 'c1',
        orderId: 'o1',
        id: createHash('sha256').update(params.flow_token).digest('hex'),
      });
    } finally {
      process.env = saved;
    }
  });
});
