/**
 * Batch Processing System Tests
 *
 * Comprehensive tests to validate the OpenAI Batch API integration
 * and batch processing system functionality.
 */

import { PrismaClient } from "@prisma/client";
import { migrationLogger } from "./migration-logger";

interface BatchTest {
  name: string;
  testFn: () => Promise<{ success: boolean; details?: Record<string, unknown>; error?: Error }>;
  critical: boolean;
  timeout: number;
}

interface BatchTestResult {
  name: string;
  success: boolean;
  duration: number;
  details?: Record<string, unknown>;
  error?: Error;
}

interface BatchSystemTestResult {
  success: boolean;
  tests: BatchTestResult[];
  totalDuration: number;
  passedTests: number;
  failedTests: number;
  criticalFailures: number;
}

export class BatchProcessingTester {
  private prisma: PrismaClient;

  constructor() {
    this.prisma = new PrismaClient();
  }

  /**
   * Run comprehensive batch processing tests
   */
  async runBatchProcessingTests(): Promise<BatchSystemTestResult> {
    const startTime = Date.now();
    const tests: BatchTestResult[] = [];

    try {
      migrationLogger.startStep("BATCH_TESTS", "Running batch processing system validation tests");

      // Define test suite
      const batchTests: BatchTest[] = [
        {
          name: "Database Schema Validation",
          testFn: () => this.testDatabaseSchema(),
          critical: true,
          timeout: 5000,
        },
        {
          name: "Batch Processor Import",
          testFn: () => this.testBatchProcessorImport(),
          critical: true,
          timeout: 5000,
        },
        {
          name: "Batch Request Creation",
          testFn: () => this.testBatchRequestCreation(),
          critical: true,
          timeout: 10000,
        },
        {
          name: "Processing Request Management",
          testFn: () => this.testProcessingRequestManagement(),
          critical: true,
          timeout: 10000,
        },
        {
          name: "Batch Status Transitions",
          testFn: () => this.testBatchStatusTransitions(),
          critical: true,
          timeout: 10000,
        },
        {
          name: "Batch Scheduling System",
          testFn: () => this.testBatchScheduling(),
          critical: false,
          timeout: 15000,
        },
        {
          name: "OpenAI API Integration",
          testFn: () => this.testOpenAIIntegration(),
          critical: false,
          timeout: 30000,
        },
        {
          name: "Error Handling",
          testFn: () => this.testErrorHandling(),
          critical: true,
          timeout: 10000,
        },
        {
          name: "Batch Processing Performance",
          testFn: () => this.testBatchPerformance(),
          critical: false,
          timeout: 20000,
        },
        {
          name: "Data Consistency",
          testFn: () => this.testDataConsistency(),
          critical: true,
          timeout: 10000,
        },
      ];

      // Run all tests
      for (const test of batchTests) {
        const result = await this.runSingleBatchTest(test);
        tests.push(result);
      }

      const totalDuration = Date.now() - startTime;
      const passedTests = tests.filter(t => t.success).length;
      const failedTests = tests.filter(t => !t.success).length;
      const criticalFailures = tests.filter(t => !t.success && batchTests.find(bt => bt.name === t.name)?.critical).length;

      const result: BatchSystemTestResult = {
        success: criticalFailures === 0,
        tests,
        totalDuration,
        passedTests,
        failedTests,
        criticalFailures,
      };

      if (result.success) {
        migrationLogger.completeStep("BATCH_TESTS");
      } else {
        migrationLogger.failStep("BATCH_TESTS", new Error(`${criticalFailures} critical batch tests failed`));
      }

      return result;

    } catch (error) {
      migrationLogger.error("BATCH_TESTS", "Batch processing test suite failed", error as Error);
      throw error;
    } finally {
      await this.prisma.$disconnect();
    }
  }

  private async runSingleBatchTest(test: BatchTest): Promise<BatchTestResult> {
    const startTime = Date.now();

    try {
      migrationLogger.debug("BATCH_TEST", `Testing: ${test.name}`);

      // Set up timeout
      const timeoutPromise = new Promise<never>((_, reject) => {
        setTimeout(() => reject(new Error("Test timeout")), test.timeout);
      });

      const testResult = await Promise.race([
        test.testFn(),
        timeoutPromise
      ]);

      const duration = Date.now() - startTime;

      const result: BatchTestResult = {
        name: test.name,
        success: testResult.success,
        duration,
        details: testResult.details,
        error: testResult.error,
      };

      if (testResult.success) {
        migrationLogger.debug("BATCH_TEST", `✅ ${test.name} passed`, {
          duration,
          details: testResult.details
        });
      } else {
        migrationLogger.warn("BATCH_TEST", `❌ ${test.name} failed`, {
          duration,
          error: testResult.error?.message
        });
      }

      return result;

    } catch (error) {
      const duration = Date.now() - startTime;

      migrationLogger.error("BATCH_TEST", `💥 ${test.name} crashed`, error as Error, { duration });

      return {
        name: test.name,
        success: false,
        duration,
        error: error as Error,
      };
    }
  }

  private async testDatabaseSchema(): Promise<{ success: boolean; details?: Record<string, unknown>; error?: Error }> {
    try {
      // Check if AIBatchRequest table exists and has correct columns
      const batchRequestTableCheck = await this.prisma.$queryRaw<{count: string}[]>`
        SELECT COUNT(*) as count
        FROM information_schema.tables
        WHERE table_name = 'AIBatchRequest'
      `;

      if (parseInt(batchRequestTableCheck[0]?.count || '0') === 0) {
        return {
          success: false,
          error: new Error("AIBatchRequest table not found")
        };
      }

      // Check required columns
      const requiredColumns = [
        'openaiBatchId', 'inputFileId', 'outputFileId', 'status', 'companyId'
      ];

      const columnChecks = await Promise.all(
        requiredColumns.map(async (column) => {
          const result = await this.prisma.$queryRawUnsafe(`
            SELECT COUNT(*) as count
            FROM information_schema.columns
            WHERE table_name = 'AIBatchRequest' AND column_name = '${column}'
          `) as {count: string}[];
          return { column, exists: parseInt(result[0]?.count || '0') > 0 };
        })
      );

      const missingColumns = columnChecks.filter(c => !c.exists).map(c => c.column);

      // Check AIProcessingRequest has batch fields
      const processingRequestBatchFields = await this.prisma.$queryRawUnsafe(`
        SELECT column_name
        FROM information_schema.columns
        WHERE table_name = 'AIProcessingRequest' 
        AND column_name IN ('processingStatus', 'batchId')
      `) as {column_name: string}[];

      const hasProcessingStatus = processingRequestBatchFields.some(c => c.column_name === 'processingStatus');
      const hasBatchId = processingRequestBatchFields.some(c => c.column_name === 'batchId');

      return {
        success: missingColumns.length === 0 && hasProcessingStatus && hasBatchId,
        details: {
          missingColumns,
          hasProcessingStatus,
          hasBatchId,
          requiredColumnsPresent: requiredColumns.length - missingColumns.length
        },
        error: missingColumns.length > 0 || !hasProcessingStatus || !hasBatchId
          ? new Error(`Schema validation failed: missing ${missingColumns.join(', ')}${!hasProcessingStatus ? ', processingStatus' : ''}${!hasBatchId ? ', batchId' : ''}`)
          : undefined
      };

    } catch (error) {
      return {
        success: false,
        error: error as Error
      };
    }
  }

  private async testBatchProcessorImport(): Promise<{ success: boolean; details?: Record<string, unknown>; error?: Error }> {
    try {
      // Test if batch processor can be imported
      const batchProcessor = await import("../../lib/batchProcessor");

      // Check if key functions/classes exist
      const hasBatchConfig = 'BATCH_CONFIG' in batchProcessor;
      const hasCreateBatch = typeof batchProcessor.createBatchFromRequests === 'function';
      const hasProcessBatch = typeof batchProcessor.processBatchResults === 'function';

      return {
        success: hasBatchConfig || hasCreateBatch || hasProcessBatch, // At least one should exist
        details: {
          batchProcessorImported: true,
          hasBatchConfig,
          hasCreateBatch,
          hasProcessBatch,
          exportedItems: Object.keys(batchProcessor)
        }
      };

    } catch (error) {
      return {
        success: false,
        error: error as Error,
        details: {
          batchProcessorImported: false,
          importError: (error as Error).message
        }
      };
    }
  }

  private async testBatchRequestCreation(): Promise<{ success: boolean; details?: Record<string, unknown>; error?: Error }> {
    try {
      // Create a test batch request
      const testBatchRequest = await this.prisma.aIBatchRequest.create({
        data: {
          companyId: 'test-company-' + Date.now(),
          openaiBatchId: 'test-batch-' + Date.now(),
          inputFileId: 'test-input-' + Date.now(),
          status: 'PENDING',
        }
      });

      // Verify it was created correctly
      const retrievedBatch = await this.prisma.aIBatchRequest.findUnique({
        where: { id: testBatchRequest.id }
      });

      // Clean up test data
      await this.prisma.aIBatchRequest.delete({
        where: { id: testBatchRequest.id }
      });

      return {
        success: !!retrievedBatch && retrievedBatch.status === 'PENDING',
        details: {
          batchRequestCreated: !!testBatchRequest,
          batchRequestRetrieved: !!retrievedBatch,
          statusCorrect: retrievedBatch?.status === 'PENDING',
          testBatchId: testBatchRequest.id
        }
      };

    } catch (error) {
      return {
        success: false,
        error: error as Error
      };
    }
  }

  private async testProcessingRequestManagement(): Promise<{ success: boolean; details?: Record<string, unknown>; error?: Error }> {
    try {
      // Count existing processing requests
      const initialCount = await this.prisma.aIProcessingRequest.count();

      // Check processing status distribution
      const statusDistribution = await this.prisma.aIProcessingRequest.groupBy({
        by: ['processingStatus'],
        _count: { processingStatus: true },
      });

      // Check if we can query requests ready for batching
      const readyForBatching = await this.prisma.aIProcessingRequest.findMany({
        where: {
          processingStatus: 'PENDING_BATCHING'
        },
        take: 5
      });

      return {
        success: true, // Basic query operations work
        details: {
          totalProcessingRequests: initialCount,
          statusDistribution: Object.fromEntries(
            statusDistribution.map(s => [s.processingStatus, s._count.processingStatus])
          ),
          readyForBatchingCount: readyForBatching.length,
          canQueryByStatus: true
        }
      };

    } catch (error) {
      return {
        success: false,
        error: error as Error
      };
    }
  }

  private async testBatchStatusTransitions(): Promise<{ success: boolean; details?: Record<string, unknown>; error?: Error }> {
    try {
      // Test that we can update batch status through all states
      const testBatchRequest = await this.prisma.aIBatchRequest.create({
        data: {
          companyId: 'test-company-' + Date.now(),
          openaiBatchId: 'test-status-batch-' + Date.now(),
          inputFileId: 'test-status-input-' + Date.now(),
          status: 'PENDING',
        }
      });

      const statusTransitions = [
        'UPLOADING',
        'VALIDATING',
        'IN_PROGRESS',
        'FINALIZING',
        'COMPLETED',
        'PROCESSED'
      ] as const;

      const transitionResults: boolean[] = [];

      for (const status of statusTransitions) {
        try {
          await this.prisma.aIBatchRequest.update({
            where: { id: testBatchRequest.id },
            data: { status }
          });
          transitionResults.push(true);
        } catch (error) {
          transitionResults.push(false);
        }
      }

      // Clean up test data
      await this.prisma.aIBatchRequest.delete({
        where: { id: testBatchRequest.id }
      });

      const successfulTransitions = transitionResults.filter(r => r).length;

      return {
        success: successfulTransitions === statusTransitions.length,
        details: {
          totalTransitions: statusTransitions.length,
          successfulTransitions,
          failedTransitions: statusTransitions.length - successfulTransitions,
          transitionResults: Object.fromEntries(
            statusTransitions.map((status, index) => [status, transitionResults[index]])
          )
        }
      };

    } catch (error) {
      return {
        success: false,
        error: error as Error
      };
    }
  }

  private async testBatchScheduling(): Promise<{ success: boolean; details?: Record<string, unknown>; error?: Error }> {
    try {
      // Test if batch scheduler can be imported
      const batchScheduler = await import("../../lib/batchScheduler");

      // Check if scheduling functions exist
      const hasScheduler = typeof batchScheduler.startBatchScheduler === 'function';
      const hasProcessor = typeof batchScheduler.processPendingBatches === 'function';

      // Check environment variables for scheduling
      const batchEnabled = process.env.BATCH_PROCESSING_ENABLED === 'true';
      const hasIntervals = !!(
        process.env.BATCH_CREATE_INTERVAL &&
        process.env.BATCH_STATUS_CHECK_INTERVAL &&
        process.env.BATCH_RESULT_PROCESSING_INTERVAL
      );

      return {
        success: hasScheduler && batchEnabled,
        details: {
          batchSchedulerImported: true,
          hasScheduler,
          hasProcessor,
          batchEnabled,
          hasIntervals,
          exportedItems: Object.keys(batchScheduler)
        }
      };

    } catch (error) {
      return {
        success: false,
        error: error as Error,
        details: {
          batchSchedulerImported: false,
          importError: (error as Error).message
        }
      };
    }
  }

  private async testOpenAIIntegration(): Promise<{ success: boolean; details?: Record<string, unknown>; error?: Error }> {
    try {
      const apiKey = process.env.OPENAI_API_KEY;
      const mockMode = process.env.OPENAI_MOCK_MODE === 'true';

      if (mockMode) {
        return {
          success: true,
          details: {
            mode: 'mock',
            apiKeyPresent: !!apiKey,
            testType: 'mock_mode_enabled'
          }
        };
      }

      if (!apiKey) {
        return {
          success: false,
          error: new Error("OpenAI API key not configured"),
          details: {
            mode: 'live',
            apiKeyPresent: false
          }
        };
      }

      // Test basic API access (simple models list)
      const response = await fetch("https://api.openai.com/v1/models", {
        headers: {
          "Authorization": `Bearer ${apiKey}`,
        },
      });

      if (!response.ok) {
        return {
          success: false,
          error: new Error(`OpenAI API access failed: ${response.status} ${response.statusText}`),
          details: {
            mode: 'live',
            apiKeyPresent: true,
            httpStatus: response.status
          }
        };
      }

      const models = await response.json();
      const hasModels = models.data && Array.isArray(models.data) && models.data.length > 0;

      return {
        success: hasModels,
        details: {
          mode: 'live',
          apiKeyPresent: true,
          apiAccessible: true,
          modelsCount: models.data?.length || 0,
          hasGPTModels: models.data?.some((m: any) => m.id.includes('gpt')) || false
        }
      };

    } catch (error) {
      return {
        success: false,
        error: error as Error,
        details: {
          mode: 'live',
          apiKeyPresent: !!process.env.OPENAI_API_KEY,
          networkError: true
        }
      };
    }
  }

  private async testErrorHandling(): Promise<{ success: boolean; details?: Record<string, unknown>; error?: Error }> {
    try {
      // Test handling of invalid batch requests
      let invalidBatchHandled = false;
      try {
        await this.prisma.aIBatchRequest.create({
          data: {
            companyId: '', // Invalid empty company ID
            openaiBatchId: 'test-invalid-batch',
            inputFileId: 'test-invalid-input',
            status: 'PENDING',
          }
        });
      } catch (error) {
        // This should fail, which means error handling is working
        invalidBatchHandled = true;
      }

      // Test handling of duplicate OpenAI batch IDs
      let duplicateHandled = false;
      const uniqueId = 'test-duplicate-' + Date.now();

      try {
        // Create first batch
        const firstBatch = await this.prisma.aIBatchRequest.create({
          data: {
            companyId: 'test-company-duplicate',
            openaiBatchId: uniqueId,
            inputFileId: 'test-duplicate-input-1',
            status: 'PENDING',
          }
        });

        // Try to create duplicate
        try {
          await this.prisma.aIBatchRequest.create({
            data: {
              companyId: 'test-company-duplicate',
              openaiBatchId: uniqueId, // Same OpenAI batch ID
              inputFileId: 'test-duplicate-input-2',
              status: 'PENDING',
            }
          });
        } catch (error) {
          // This should fail due to unique constraint
          duplicateHandled = true;
        }

        // Clean up
        await this.prisma.aIBatchRequest.delete({
          where: { id: firstBatch.id }
        });

      } catch (error) {
        // Initial creation failed, that's also error handling
        duplicateHandled = true;
      }

      return {
        success: invalidBatchHandled && duplicateHandled,
        details: {
          invalidBatchHandled,
          duplicateHandled,
          errorHandlingWorking: invalidBatchHandled && duplicateHandled
        }
      };

    } catch (error) {
      return {
        success: false,
        error: error as Error
      };
    }
  }

  private async testBatchPerformance(): Promise<{ success: boolean; details?: Record<string, unknown>; error?: Error }> {
    try {
      // Test query performance for batch operations
      const startTime = Date.now();

      // Query for batches ready for processing
      const pendingBatches = await this.prisma.aIBatchRequest.findMany({
        where: {
          status: { in: ['PENDING', 'UPLOADING', 'VALIDATING'] }
        },
        take: 100
      });

      const pendingBatchesTime = Date.now() - startTime;

      // Query for requests ready for batching
      const batchingStartTime = Date.now();

      const readyRequests = await this.prisma.aIProcessingRequest.findMany({
        where: {
          processingStatus: 'PENDING_BATCHING'
        },
        take: 100
      });

      const readyRequestsTime = Date.now() - batchingStartTime;

      // Query performance should be reasonable
      const performanceAcceptable = pendingBatchesTime < 1000 && readyRequestsTime < 1000;

      return {
        success: performanceAcceptable,
        details: {
          pendingBatchesCount: pendingBatches.length,
          pendingBatchesQueryTime: pendingBatchesTime,
          readyRequestsCount: readyRequests.length,
          readyRequestsQueryTime: readyRequestsTime,
          performanceAcceptable,
          totalTestTime: Date.now() - startTime
        }
      };

    } catch (error) {
      return {
        success: false,
        error: error as Error
      };
    }
  }

  private async testDataConsistency(): Promise<{ success: boolean; details?: Record<string, unknown>; error?: Error }> {
    try {
      // Check for orphaned processing requests (batchId points to non-existent batch)
      const orphanedRequests = await this.prisma.$queryRaw<{count: bigint}[]>`
        SELECT COUNT(*) as count
        FROM "AIProcessingRequest" apr
        LEFT JOIN "AIBatchRequest" abr ON apr."batchId" = abr.id
        WHERE apr."batchId" IS NOT NULL AND abr.id IS NULL
      `;

      const orphanedCount = Number(orphanedRequests[0]?.count || 0);

      // Check for processing requests with inconsistent status
      const inconsistentRequests = await this.prisma.$queryRaw<{count: bigint}[]>`
        SELECT COUNT(*) as count
        FROM "AIProcessingRequest"
        WHERE ("batchId" IS NOT NULL AND "processingStatus" = 'PENDING_BATCHING')
           OR ("batchId" IS NULL AND "processingStatus" IN ('BATCHING_IN_PROGRESS'))
      `;

      const inconsistentCount = Number(inconsistentRequests[0]?.count || 0);

      // Check for batches with no associated requests
      const emptyBatches = await this.prisma.$queryRaw<{count: bigint}[]>`
        SELECT COUNT(*) as count
        FROM "AIBatchRequest" abr
        LEFT JOIN "AIProcessingRequest" apr ON abr.id = apr."batchId"
        WHERE apr."batchId" IS NULL
      `;

      const emptyBatchCount = Number(emptyBatches[0]?.count || 0);

      const dataConsistent = orphanedCount === 0 && inconsistentCount === 0;

      return {
        success: dataConsistent,
        details: {
          orphanedRequests: orphanedCount,
          inconsistentRequests: inconsistentCount,
          emptyBatches: emptyBatchCount,
          dataConsistent,
          issuesFound: orphanedCount + inconsistentCount
        },
        error: !dataConsistent ? new Error(`Data consistency issues found: ${orphanedCount} orphaned requests, ${inconsistentCount} inconsistent requests`) : undefined
      };

    } catch (error) {
      return {
        success: false,
        error: error as Error
      };
    }
  }

  /**
   * Generate batch processing test report
   */
  generateTestReport(result: BatchSystemTestResult): string {
    const report = `
# Batch Processing System Test Report

**Overall Status**: ${result.success ? '✅ All Critical Tests Passed' : '❌ Critical Tests Failed'}
**Total Duration**: ${result.totalDuration}ms
**Passed Tests**: ${result.passedTests}/${result.tests.length}
**Failed Tests**: ${result.failedTests}/${result.tests.length}
**Critical Failures**: ${result.criticalFailures}

## Test Results

${result.tests.map(test => `
### ${test.name}
- **Status**: ${test.success ? '✅ Pass' : '❌ Fail'}
- **Duration**: ${test.duration}ms
${test.details ? `- **Details**: \`\`\`json\n${JSON.stringify(test.details, null, 2)}\n\`\`\`` : ''}
${test.error ? `- **Error**: ${test.error.message}` : ''}
`).join('')}

## Summary

${result.success ?
  '🎉 Batch processing system is working correctly!' :
  `⚠️ ${result.criticalFailures} critical issue(s) found. Please review and fix the issues above.`
}

## Architecture Overview

The batch processing system provides:
- **50% cost reduction** using OpenAI Batch API
- **Improved rate limiting** and throughput management
- **Enhanced error handling** and retry mechanisms
- **Automatic batching** of AI requests every 5 minutes
- **Status monitoring** with 2-minute check intervals
- **Result processing** with 1-minute intervals

${result.failedTests > 0 ? `
## Issues Found

${result.tests.filter(t => !t.success).map(test => `
### ${test.name}
- **Error**: ${test.error?.message || 'Test failed'}
- **Details**: ${test.details ? JSON.stringify(test.details, null, 2) : 'No additional details'}
`).join('')}

## Recommended Actions

1. **Database Issues**: Run database migrations to ensure all tables and columns exist
2. **Import Issues**: Verify all batch processing modules are properly installed
3. **API Issues**: Check OpenAI API key configuration and network connectivity
4. **Performance Issues**: Optimize database queries and add missing indexes
5. **Data Issues**: Run data consistency checks and fix orphaned records
` : `
## System Health

✅ All critical batch processing components are functioning correctly.

### Performance Metrics
${result.tests.find(t => t.name === "Batch Processing Performance")?.details ?
  `- Pending batches query: ${(result.tests.find(t => t.name === "Batch Processing Performance")?.details as any)?.pendingBatchesQueryTime}ms
- Ready requests query: ${(result.tests.find(t => t.name === "Batch Processing Performance")?.details as any)?.readyRequestsQueryTime}ms`
  : 'Performance metrics not available'}

### Next Steps
1. Monitor batch processing queues regularly
2. Set up alerting for failed batches
3. Optimize batch sizes based on usage patterns
4. Consider implementing batch priority levels
`}

---
*Generated at ${new Date().toISOString()}*
`;

    return report;
  }
}

// CLI interface
if (import.meta.url === `file://${process.argv[1]}`) {
  const tester = new BatchProcessingTester();

  const generateReport = process.argv.includes("--report");

  tester.runBatchProcessingTests()
    .then((result) => {
      console.log('\n=== BATCH PROCESSING TEST RESULTS ===');
      console.log(`Overall Success: ${result.success ? '✅' : '❌'}`);
      console.log(`Total Duration: ${result.totalDuration}ms`);
      console.log(`Passed Tests: ${result.passedTests}/${result.tests.length}`);
      console.log(`Failed Tests: ${result.failedTests}/${result.tests.length}`);
      console.log(`Critical Failures: ${result.criticalFailures}`);

      console.log('\n=== INDIVIDUAL TEST RESULTS ===');
      for (const test of result.tests) {
        const status = test.success ? '✅' : '❌';
        console.log(`${status} ${test.name} (${test.duration}ms)`);

        if (test.error) {
          console.log(`  Error: ${test.error.message}`);
        }

        if (test.details) {
          console.log(`  Details: ${JSON.stringify(test.details, null, 2)}`);
        }
      }

      if (generateReport) {
        const report = tester.generateTestReport(result);
        const fs = require("node:fs");
        const reportPath = `batch-processing-test-report-${Date.now()}.md`;
        fs.writeFileSync(reportPath, report);
        console.log(`\n📋 Test report saved to: ${reportPath}`);
      }

      process.exit(result.success ? 0 : 1);
    })
    .catch((error) => {
      console.error('Batch processing tests failed:', error);
      process.exit(1);
    });
}