/**
 * Cancel & Refund integration tests
 */

import { describe, it, expect } from 'vitest';
import { createTestClient, assertSuccessResponse } from '../setup';
import { testNon3DPaymentRequest } from '../fixtures/payment';
import type { ErrorResponse } from '../../src/types';

describe('Cancel & Refund Integration Tests', () => {
  const client = createTestClient();

  it('should cancel a payment', async () => {
    // First create a payment
    const paymentRequest = {
      ...testNon3DPaymentRequest,
      conversationId: `test-cancel-${Date.now()}`,
    };

    const paymentResponse = await client.payment.createNon3DS(paymentRequest);
    assertSuccessResponse(paymentResponse);

    if (paymentResponse.paymentId) {
      // Then cancel it
      const cancelResponse = await client.cancelRefund.cancel({
        paymentId: paymentResponse.paymentId,
        locale: 'tr',
        conversationId: `test-cancel-${Date.now()}`,
      });

      assertSuccessResponse(cancelResponse);
      expect(cancelResponse.paymentId).toBe(paymentResponse.paymentId);
    }
  });

  it('should refund a payment using v1 endpoint', async () => {
    // First create a payment
    const paymentRequest = {
      ...testNon3DPaymentRequest,
      conversationId: `test-refund-v1-${Date.now()}`,
    };

    const paymentResponse = await client.payment.createNon3DS(paymentRequest);
    assertSuccessResponse(paymentResponse);

    if (paymentResponse.paymentId && paymentResponse.itemTransactions) {
      // Get the first payment transaction ID
      const firstTransaction = paymentResponse.itemTransactions[0];
      if (firstTransaction && firstTransaction.paymentTransactionId) {
        // Then refund it using v1
        const refundResponse = await client.cancelRefund.refund({
          paymentTransactionId: firstTransaction.paymentTransactionId,
          price: firstTransaction.price,
          locale: 'tr',
          conversationId: `test-refund-v1-${Date.now()}`,
        });

        assertSuccessResponse(refundResponse);
        expect(refundResponse.paymentTransactionId).toBe(
          firstTransaction.paymentTransactionId
        );
      }
    }
  });

  it('should refund a payment using v2 endpoint', async () => {
    // First create a payment
    const paymentRequest = {
      ...testNon3DPaymentRequest,
      conversationId: `test-refund-v2-${Date.now()}`,
    };

    const paymentResponse = await client.payment.createNon3DS(paymentRequest);
    assertSuccessResponse(paymentResponse);

    if (paymentResponse.paymentId && paymentResponse.paidPrice) {
      // Then refund it using v2
      const refundResponse = await client.cancelRefund.refundV2({
        paymentId: paymentResponse.paymentId,
        price: paymentResponse.paidPrice,
        locale: 'tr',
        conversationId: `test-refund-v2-${Date.now()}`,
      });

      assertSuccessResponse(refundResponse);
      expect(refundResponse.paymentId).toBe(paymentResponse.paymentId);
    }
  });

  describe('Edge Cases - Invalid Fields', () => {
    it('should handle invalid paymentId for cancel', async () => {
      try {
        const response = await client.cancelRefund.cancel({
          paymentId: 'invalid-payment-id-99999',
          locale: 'tr',
          conversationId: `test-invalid-paymentid-${Date.now()}`,
        });
        expect(response).toBeDefined();
        expect(response.status).toBeDefined();
        if (response.status === 'failure') {
          const errorResponse = response as unknown as ErrorResponse;
          expect(errorResponse.errorCode || errorResponse.errorMessage).toBeTruthy();
        }
      } catch (error: any) {
        expect(error).toBeDefined();
        expect(error).toBeInstanceOf(Error);
      }
    });

    it('should handle empty paymentId for cancel', async () => {
      try {
        const response = await client.cancelRefund.cancel({
          paymentId: '',
          locale: 'tr',
          conversationId: `test-empty-paymentid-${Date.now()}`,
        });
        expect(response).toBeDefined();
        expect(response.status).toBeDefined();
        if (response.status === 'failure') {
          const errorResponse = response as unknown as ErrorResponse;
          expect(errorResponse.errorCode || errorResponse.errorMessage).toBeTruthy();
        }
      } catch (error: any) {
        expect(error).toBeDefined();
        expect(error).toBeInstanceOf(Error);
      }
    });

    it('should handle missing paymentId for cancel', async () => {
      try {
        const response = await client.cancelRefund.cancel({
          paymentId: undefined as any,
          locale: 'tr',
          conversationId: `test-missing-paymentid-${Date.now()}`,
        });
        expect(response).toBeDefined();
        expect(response.status).toBeDefined();
        if (response.status === 'failure') {
          const errorResponse = response as unknown as ErrorResponse;
          expect(errorResponse.errorCode || errorResponse.errorMessage).toBeTruthy();
        }
      } catch (error: any) {
        expect(error).toBeDefined();
        expect(error).toBeInstanceOf(Error);
      }
    });

    it('should handle invalid paymentTransactionId for refund', async () => {
      try {
        const response = await client.cancelRefund.refund({
          paymentTransactionId: 'invalid-transaction-id-99999',
          price: 1.0,
          locale: 'tr',
          conversationId: `test-invalid-transactionid-${Date.now()}`,
        });
        expect(response).toBeDefined();
        expect(response.status).toBeDefined();
        if (response.status === 'failure') {
          const errorResponse = response as unknown as ErrorResponse;
          expect(errorResponse.errorCode || errorResponse.errorMessage).toBeTruthy();
        }
      } catch (error: any) {
        expect(error).toBeDefined();
        expect(error).toBeInstanceOf(Error);
      }
    });

    it('should handle empty paymentTransactionId for refund', async () => {
      try {
        const response = await client.cancelRefund.refund({
          paymentTransactionId: '',
          price: 1.0,
          locale: 'tr',
          conversationId: `test-empty-transactionid-${Date.now()}`,
        });
        expect(response).toBeDefined();
        expect(response.status).toBeDefined();
        if (response.status === 'failure') {
          const errorResponse = response as unknown as ErrorResponse;
          expect(errorResponse.errorCode || errorResponse.errorMessage).toBeTruthy();
        }
      } catch (error: any) {
        expect(error).toBeDefined();
        expect(error).toBeInstanceOf(Error);
      }
    });

    it('should handle missing paymentTransactionId for refund', async () => {
      try {
        const response = await client.cancelRefund.refund({
          paymentTransactionId: undefined as any,
          price: 1.0,
          locale: 'tr',
          conversationId: `test-missing-transactionid-${Date.now()}`,
        });
        expect(response).toBeDefined();
        expect(response.status).toBeDefined();
        if (response.status === 'failure') {
          const errorResponse = response as unknown as ErrorResponse;
          expect(errorResponse.errorCode || errorResponse.errorMessage).toBeTruthy();
        }
      } catch (error: any) {
        expect(error).toBeDefined();
        expect(error).toBeInstanceOf(Error);
      }
    });

    it('should handle negative price for refund', async () => {
      // First create a payment to get a transaction ID
      const paymentRequest = {
        ...testNon3DPaymentRequest,
        conversationId: `test-refund-negative-${Date.now()}`,
      };

      const paymentResponse = await client.payment.createNon3DS(paymentRequest);
      assertSuccessResponse(paymentResponse);

      if (paymentResponse.itemTransactions && paymentResponse.itemTransactions[0]) {
        const firstTransaction = paymentResponse.itemTransactions[0];
        if (firstTransaction.paymentTransactionId) {
          try {
            const response = await client.cancelRefund.refund({
              paymentTransactionId: firstTransaction.paymentTransactionId,
              price: -100.0,
              locale: 'tr',
              conversationId: `test-refund-negative-${Date.now()}`,
            });
            expect(response).toBeDefined();
            expect(response.status).toBeDefined();
            if (response.status === 'failure') {
              const errorResponse = response as unknown as ErrorResponse;
              expect(errorResponse.errorCode || errorResponse.errorMessage).toBeTruthy();
            }
          } catch (error: any) {
            expect(error).toBeDefined();
            expect(error).toBeInstanceOf(Error);
          }
        }
      }
    });

    it('should handle zero price for refund', async () => {
      // First create a payment to get a transaction ID
      const paymentRequest = {
        ...testNon3DPaymentRequest,
        conversationId: `test-refund-zero-${Date.now()}`,
      };

      const paymentResponse = await client.payment.createNon3DS(paymentRequest);
      assertSuccessResponse(paymentResponse);

      if (paymentResponse.itemTransactions && paymentResponse.itemTransactions[0]) {
        const firstTransaction = paymentResponse.itemTransactions[0];
        if (firstTransaction.paymentTransactionId) {
          try {
            const response = await client.cancelRefund.refund({
              paymentTransactionId: firstTransaction.paymentTransactionId,
              price: 0,
              locale: 'tr',
              conversationId: `test-refund-zero-${Date.now()}`,
            });
            expect(response).toBeDefined();
            expect(response.status).toBeDefined();
            if (response.status === 'failure') {
              const errorResponse = response as unknown as ErrorResponse;
              expect(errorResponse.errorCode || errorResponse.errorMessage).toBeTruthy();
            }
          } catch (error: any) {
            expect(error).toBeDefined();
            expect(error).toBeInstanceOf(Error);
          }
        }
      }
    });

    it('should handle refund amount greater than original payment', async () => {
      // First create a payment
      const paymentRequest = {
        ...testNon3DPaymentRequest,
        conversationId: `test-refund-excess-${Date.now()}`,
      };

      const paymentResponse = await client.payment.createNon3DS(paymentRequest);
      assertSuccessResponse(paymentResponse);

      if (paymentResponse.itemTransactions && paymentResponse.itemTransactions[0]) {
        const firstTransaction = paymentResponse.itemTransactions[0];
        if (firstTransaction.paymentTransactionId) {
          try {
            // Try to refund more than the original amount
            const excessAmount = (firstTransaction.price || 0) * 2;
            const response = await client.cancelRefund.refund({
              paymentTransactionId: firstTransaction.paymentTransactionId,
              price: excessAmount,
              locale: 'tr',
              conversationId: `test-refund-excess-${Date.now()}`,
            });
            expect(response).toBeDefined();
            expect(response.status).toBeDefined();
            if (response.status === 'failure') {
              const errorResponse = response as unknown as ErrorResponse;
              expect(errorResponse.errorCode || errorResponse.errorMessage).toBeTruthy();
            }
          } catch (error: any) {
            expect(error).toBeDefined();
            expect(error).toBeInstanceOf(Error);
          }
        }
      }
    });

    it('should handle invalid paymentId for refundV2', async () => {
      try {
        const response = await client.cancelRefund.refundV2({
          paymentId: 'invalid-payment-id-99999',
          price: 1.0,
          locale: 'tr',
          conversationId: `test-invalid-paymentid-v2-${Date.now()}`,
        });
        expect(response).toBeDefined();
        expect(response.status).toBeDefined();
        if (response.status === 'failure') {
          const errorResponse = response as unknown as ErrorResponse;
          expect(errorResponse.errorCode || errorResponse.errorMessage).toBeTruthy();
        }
      } catch (error: any) {
        expect(error).toBeDefined();
        expect(error).toBeInstanceOf(Error);
      }
    });

    it('should handle missing price for refund', async () => {
      // First create a payment to get a transaction ID
      const paymentRequest = {
        ...testNon3DPaymentRequest,
        conversationId: `test-refund-missing-price-${Date.now()}`,
      };

      const paymentResponse = await client.payment.createNon3DS(paymentRequest);
      assertSuccessResponse(paymentResponse);

      if (paymentResponse.itemTransactions && paymentResponse.itemTransactions[0]) {
        const firstTransaction = paymentResponse.itemTransactions[0];
        if (firstTransaction.paymentTransactionId) {
          try {
            const response = await client.cancelRefund.refund({
              paymentTransactionId: firstTransaction.paymentTransactionId,
              price: undefined as any,
              locale: 'tr',
              conversationId: `test-refund-missing-price-${Date.now()}`,
            });
            expect(response).toBeDefined();
            expect(response.status).toBeDefined();
            if (response.status === 'failure') {
              const errorResponse = response as unknown as ErrorResponse;
              expect(errorResponse.errorCode || errorResponse.errorMessage).toBeTruthy();
            }
          } catch (error: any) {
            expect(error).toBeDefined();
            expect(error).toBeInstanceOf(Error);
          }
        }
      }
    });
  });
});