/**
 * Database Validation and Health Checks
 *
 * Comprehensive validation of database schema, data integrity,
 * and readiness for the new tRPC and batch processing architecture.
 */

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

interface ValidationResult {
  success: boolean;
  errors: string[];
  warnings: string[];
  metrics: Record<string, number>;
}

export class DatabaseValidator {
  private prisma: PrismaClient;

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

  /**
   * Run comprehensive database validation
   */
  async validateDatabase(): Promise<ValidationResult> {
    const result: ValidationResult = {
      success: true,
      errors: [],
      warnings: [],
      metrics: {},
    };

    try {
      migrationLogger.startStep("DATABASE_VALIDATION", "Running comprehensive database validation");

      // Test database connection
      await this.validateConnection(result);

      // Validate schema integrity
      await this.validateSchemaIntegrity(result);

      // Validate data integrity
      await this.validateDataIntegrity(result);

      // Validate indexes and performance
      await this.validateIndexes(result);

      // Validate batch processing readiness
      await this.validateBatchProcessingReadiness(result);

      // Validate tRPC readiness
      await this.validateTRPCReadiness(result);

      // Collect metrics
      await this.collectMetrics(result);

      result.success = result.errors.length === 0;

      if (result.success) {
        migrationLogger.completeStep("DATABASE_VALIDATION");
      } else {
        migrationLogger.failStep("DATABASE_VALIDATION", new Error(`Validation failed with ${result.errors.length} errors`));
      }

    } catch (error) {
      result.success = false;
      result.errors.push(`Database validation failed: ${(error as Error).message}`);
      migrationLogger.error("DATABASE_VALIDATION", "Critical validation error", error as Error);
    } finally {
      await this.prisma.$disconnect();
    }

    return result;
  }

  private async validateConnection(result: ValidationResult): Promise<void> {
    try {
      migrationLogger.info("DB_CONNECTION", "Testing database connection");
      await this.prisma.$queryRaw`SELECT 1`;
      migrationLogger.info("DB_CONNECTION", "Database connection successful");
    } catch (error) {
      result.errors.push(`Database connection failed: ${(error as Error).message}`);
    }
  }

  private async validateSchemaIntegrity(result: ValidationResult): Promise<void> {
    migrationLogger.info("SCHEMA_VALIDATION", "Validating schema integrity");

    try {
      // Check if all required tables exist
      const requiredTables = [
        'Company', 'User', 'Session', 'SessionImport', 'Message',
        'SessionProcessingStatus', 'Question', 'SessionQuestion',
        'AIBatchRequest', 'AIProcessingRequest', 'AIModel',
        'AIModelPricing', 'CompanyAIModel', 'PlatformUser'
      ];

      for (const table of requiredTables) {
        try {
          await this.prisma.$queryRawUnsafe(`SELECT 1 FROM "${table}" LIMIT 1`);
        } catch (error) {
          result.errors.push(`Required table missing or inaccessible: ${table}`);
        }
      }

      // Check for required enums
      const requiredEnums = [
        'ProcessingStage', 'ProcessingStatus', 'AIBatchRequestStatus',
        'AIRequestStatus', 'SentimentCategory', 'SessionCategory'
      ];

      for (const enumName of requiredEnums) {
        try {
          const enumValues = await this.prisma.$queryRawUnsafe(
            `SELECT unnest(enum_range(NULL::${enumName})) as value`
          );
          if (Array.isArray(enumValues) && enumValues.length === 0) {
            result.warnings.push(`Enum ${enumName} has no values`);
          }
        } catch (error) {
          result.errors.push(`Required enum missing: ${enumName}`);
        }
      }

    } catch (error) {
      result.errors.push(`Schema validation failed: ${(error as Error).message}`);
    }
  }

  private async validateDataIntegrity(result: ValidationResult): Promise<void> {
    migrationLogger.info("DATA_INTEGRITY", "Validating data integrity");

    try {
      // Check for orphaned records
      const orphanedSessions = await this.prisma.$queryRaw<{count: bigint}[]>`
        SELECT COUNT(*) as count 
        FROM "Session" s 
        LEFT JOIN "Company" c ON s."companyId" = c.id 
        WHERE c.id IS NULL
      `;

      if (orphanedSessions[0]?.count > 0) {
        result.errors.push(`Found ${orphanedSessions[0].count} orphaned sessions`);
      }

      // Check for sessions without processing status
      const sessionsWithoutStatus = await this.prisma.$queryRaw<{count: bigint}[]>`
        SELECT COUNT(*) as count
        FROM "Session" s
        LEFT JOIN "SessionProcessingStatus" sps ON s.id = sps."sessionId"
        WHERE sps."sessionId" IS NULL
      `;

      if (sessionsWithoutStatus[0]?.count > 0) {
        result.warnings.push(`Found ${sessionsWithoutStatus[0].count} sessions without processing status`);
      }

      // Check for inconsistent batch processing states
      const inconsistentBatchStates = await this.prisma.$queryRaw<{count: bigint}[]>`
        SELECT COUNT(*) as count
        FROM "AIProcessingRequest" apr
        WHERE apr."batchId" IS NOT NULL 
        AND apr."processingStatus" = 'PENDING_BATCHING'
      `;

      if (inconsistentBatchStates[0]?.count > 0) {
        result.warnings.push(`Found ${inconsistentBatchStates[0].count} requests with inconsistent batch states`);
      }

    } catch (error) {
      result.errors.push(`Data integrity validation failed: ${(error as Error).message}`);
    }
  }

  private async validateIndexes(result: ValidationResult): Promise<void> {
    migrationLogger.info("INDEX_VALIDATION", "Validating database indexes");

    try {
      // Check for missing critical indexes
      const criticalIndexes = [
        { table: 'Session', columns: ['companyId', 'startTime'] },
        { table: 'SessionProcessingStatus', columns: ['stage', 'status'] },
        { table: 'AIProcessingRequest', columns: ['processingStatus'] },
        { table: 'AIBatchRequest', columns: ['companyId', 'status'] },
      ];

      for (const indexInfo of criticalIndexes) {
        const indexExists = await this.prisma.$queryRawUnsafe(`
          SELECT COUNT(*) as count
          FROM pg_indexes 
          WHERE tablename = '${indexInfo.table}' 
          AND indexdef LIKE '%${indexInfo.columns.join('%')}%'
        `) as {count: string}[];

        if (parseInt(indexExists[0]?.count || '0') === 0) {
          result.warnings.push(`Missing recommended index on ${indexInfo.table}(${indexInfo.columns.join(', ')})`);
        }
      }

    } catch (error) {
      result.warnings.push(`Index validation failed: ${(error as Error).message}`);
    }
  }

  private async validateBatchProcessingReadiness(result: ValidationResult): Promise<void> {
    migrationLogger.info("BATCH_READINESS", "Validating batch processing readiness");

    try {
      // Check if AIBatchRequest table is properly configured
      const batchTableCheck = await this.prisma.$queryRaw<{count: bigint}[]>`
        SELECT COUNT(*) as count FROM "AIBatchRequest"
      `;

      // Check if AIProcessingRequest has batch-related fields
      const batchFieldsCheck = 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}[];

      if (batchFieldsCheck.length < 2) {
        result.errors.push("AIProcessingRequest table missing batch processing fields");
      }

      // Check if batch status enum values are correct
      const batchStatusValues = await this.prisma.$queryRawUnsafe(`
        SELECT unnest(enum_range(NULL::AIBatchRequestStatus)) as value
      `) as {value: string}[];

      const requiredBatchStatuses = [
        'PENDING', 'UPLOADING', 'VALIDATING', 'IN_PROGRESS',
        'FINALIZING', 'COMPLETED', 'PROCESSED', 'FAILED', 'CANCELLED'
      ];

      const missingStatuses = requiredBatchStatuses.filter(
        status => !batchStatusValues.some(v => v.value === status)
      );

      if (missingStatuses.length > 0) {
        result.errors.push(`Missing batch status values: ${missingStatuses.join(', ')}`);
      }

    } catch (error) {
      result.errors.push(`Batch processing readiness validation failed: ${(error as Error).message}`);
    }
  }

  private async validateTRPCReadiness(result: ValidationResult): Promise<void> {
    migrationLogger.info("TRPC_READINESS", "Validating tRPC readiness");

    try {
      // Check if all required models are accessible
      const modelTests = [
        () => this.prisma.company.findFirst(),
        () => this.prisma.user.findFirst(),
        () => this.prisma.session.findFirst(),
        () => this.prisma.aIProcessingRequest.findFirst(),
      ];

      for (const test of modelTests) {
        try {
          await test();
        } catch (error) {
          result.warnings.push(`Prisma model access issue: ${(error as Error).message}`);
        }
      }

      // Test complex queries that tRPC will use
      try {
        await this.prisma.session.findMany({
          where: { companyId: 'test' },
          include: {
            messages: true,
            processingStatus: true,
          },
          take: 1,
        });
      } catch (error) {
        // This is expected to fail with the test companyId, but should not error on structure
        if (!(error as Error).message.includes('test')) {
          result.warnings.push(`Complex query structure issue: ${(error as Error).message}`);
        }
      }

    } catch (error) {
      result.warnings.push(`tRPC readiness validation failed: ${(error as Error).message}`);
    }
  }

  private async collectMetrics(result: ValidationResult): Promise<void> {
    migrationLogger.info("METRICS_COLLECTION", "Collecting database metrics");

    try {
      // Count records in key tables
      const companiesCount = await this.prisma.company.count();
      const usersCount = await this.prisma.user.count();
      const sessionsCount = await this.prisma.session.count();
      const messagesCount = await this.prisma.message.count();
      const batchRequestsCount = await this.prisma.aIBatchRequest.count();
      const processingRequestsCount = await this.prisma.aIProcessingRequest.count();

      result.metrics = {
        companies: companiesCount,
        users: usersCount,
        sessions: sessionsCount,
        messages: messagesCount,
        batchRequests: batchRequestsCount,
        processingRequests: processingRequestsCount,
      };

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

      for (const statusCount of processingStatusCounts) {
        result.metrics[`processing_${statusCount.status.toLowerCase()}`] = statusCount._count.status;
      }

      // Check batch request status distribution
      const batchStatusCounts = await this.prisma.aIBatchRequest.groupBy({
        by: ['status'],
        _count: { status: true },
      });

      for (const statusCount of batchStatusCounts) {
        result.metrics[`batch_${statusCount.status.toLowerCase()}`] = statusCount._count.status;
      }

    } catch (error) {
      result.warnings.push(`Metrics collection failed: ${(error as Error).message}`);
    }
  }
}

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

  validator.validateDatabase()
    .then((result) => {
      console.log('\n=== DATABASE VALIDATION RESULTS ===');
      console.log(`Success: ${result.success ? '✅' : '❌'}`);

      if (result.errors.length > 0) {
        console.log('\n❌ ERRORS:');
        result.errors.forEach(error => console.log(`  - ${error}`));
      }

      if (result.warnings.length > 0) {
        console.log('\n⚠️  WARNINGS:');
        result.warnings.forEach(warning => console.log(`  - ${warning}`));
      }

      console.log('\n📊 METRICS:');
      Object.entries(result.metrics).forEach(([key, value]) => {
        console.log(`  ${key}: ${value}`);
      });

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