/**
 * Reporting integration tests
 */

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

describe('Reporting Integration Tests', () => {
  const client = createTestClient();

  it('should get payment transactions for a date', async () => {
    // Use today's date
    const today = new Date();
    const dateString = today.toISOString().split('T')[0]; // YYYY-MM-DD format

    const response = await client.reporting.getPaymentTransactions({
      page: 1,
      transactionDate: dateString,
      locale: 'tr',
      conversationId: `test-transactions-${Date.now()}`,
    });

    assertSuccessResponse(response);
    expect(response.currentPage).toBe(1);
    // Transactions might be empty if no transactions exist for the date
    expect(response.transactions).toBeDefined();
  });

  it('should get payment details by paymentId', async () => {
    // First create a payment to get a paymentId
    const { testNon3DPaymentRequest } = await import('../fixtures/payment');
    const paymentRequest = {
      ...testNon3DPaymentRequest,
      conversationId: `test-reporting-${Date.now()}`,
    };

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

    if (paymentResponse.paymentId) {
      // Then get payment details
      const detailsResponse = await client.reporting.getPaymentDetails({
        paymentId: paymentResponse.paymentId,
        locale: 'tr',
        conversationId: `test-details-${Date.now()}`,
      });

      assertSuccessResponse(detailsResponse);
      expect(detailsResponse.payments).toBeTruthy();
      if (detailsResponse.payments && detailsResponse.payments.length > 0) {
        // Convert to string for comparison as API may return number or string
        const returnedPaymentId = String(detailsResponse.payments[0].paymentId);
        expect(returnedPaymentId).toBe(String(paymentResponse.paymentId));
      }
    }
  });

  it('should get payment details by paymentConversationId', async () => {
    // First create a payment to get a conversationId
    const { testNon3DPaymentRequest } = await import('../fixtures/payment');
    const conversationId = `test-reporting-conv-${Date.now()}`;
    const paymentRequest = {
      ...testNon3DPaymentRequest,
      conversationId,
    };

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

    if (paymentResponse.conversationId) {
      // Then get payment details using paymentConversationId
      const detailsResponse = await client.reporting.getPaymentDetails({
        paymentConversationId: paymentResponse.conversationId,
        locale: 'tr',
        conversationId: `test-details-conv-${Date.now()}`,
      });

      assertSuccessResponse(detailsResponse);
      expect(detailsResponse.payments).toBeTruthy();
    }
  });

  describe('Edge Cases - Invalid Fields', () => {
    it('should handle invalid date format for getPaymentTransactions', async () => {
      try {
        const response = await client.reporting.getPaymentTransactions({
          page: 1,
          transactionDate: 'invalid-date-format',
          locale: 'tr',
          conversationId: `test-invalid-date-${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 future date for getPaymentTransactions', async () => {
      const futureDate = new Date();
      futureDate.setFullYear(futureDate.getFullYear() + 1);
      const dateString = futureDate.toISOString().split('T')[0];

      try {
        const response = await client.reporting.getPaymentTransactions({
          page: 1,
          transactionDate: dateString,
          locale: 'tr',
          conversationId: `test-future-date-${Date.now()}`,
        });
        expect(response).toBeDefined();
        expect(response.status).toBeDefined();
        // Future dates might return empty results or error
        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 page number', async () => {
      const today = new Date();
      const dateString = today.toISOString().split('T')[0];

      try {
        const response = await client.reporting.getPaymentTransactions({
          page: -1,
          transactionDate: dateString,
          locale: 'tr',
          conversationId: `test-negative-page-${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 page number', async () => {
      const today = new Date();
      const dateString = today.toISOString().split('T')[0];

      try {
        const response = await client.reporting.getPaymentTransactions({
          page: 0,
          transactionDate: dateString,
          locale: 'tr',
          conversationId: `test-zero-page-${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 very large page number', async () => {
      const today = new Date();
      const dateString = today.toISOString().split('T')[0];

      try {
        const response = await client.reporting.getPaymentTransactions({
          page: 999999,
          transactionDate: dateString,
          locale: 'tr',
          conversationId: `test-large-page-${Date.now()}`,
        });
        expect(response).toBeDefined();
        expect(response.status).toBeDefined();
        // Large page numbers might return empty results or error
        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 transactionDate', async () => {
      try {
        const response = await client.reporting.getPaymentTransactions({
          page: 1,
          transactionDate: undefined as any,
          locale: 'tr',
          conversationId: `test-missing-date-${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 getPaymentDetails', async () => {
      try {
        const response = await client.reporting.getPaymentDetails({
          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 getPaymentDetails', async () => {
      try {
        const response = await client.reporting.getPaymentDetails({
          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 invalid paymentConversationId for getPaymentDetails', async () => {
      try {
        const response = await client.reporting.getPaymentDetails({
          paymentConversationId: 'invalid-conversation-id-99999',
          locale: 'tr',
          conversationId: `test-invalid-convid-${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 paymentConversationId for getPaymentDetails', async () => {
      try {
        const response = await client.reporting.getPaymentDetails({
          paymentConversationId: '',
          locale: 'tr',
          conversationId: `test-empty-convid-${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 both paymentId and paymentConversationId', async () => {
      try {
        const response = await client.reporting.getPaymentDetails({
          locale: 'tr',
          conversationId: `test-missing-ids-${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 locale', async () => {
      const today = new Date();
      const dateString = today.toISOString().split('T')[0];

      try {
        const response = await client.reporting.getPaymentTransactions({
          page: 1,
          transactionDate: dateString,
          locale: 'invalid' as any,
          conversationId: `test-invalid-locale-${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);
      }
    });
  });
});