<?php
/**
 * Tests for Database Performance
 *
 * @package CareBook\Ultimate\Tests\Performance
 * @since 1.0.0
 */

declare(strict_types=1);

namespace CareBook\Ultimate\Tests\Performance;

use PHPUnit\Framework\TestCase;
use CareBook\Ultimate\Tests\Mocks\DatabaseMock;

/**
 * DatabasePerformanceTest class
 * 
 * Tests database operations performance and optimization
 * 
 * @since 1.0.0
 */
class DatabasePerformanceTest extends TestCase
{
    /**
     * Performance threshold constants (in milliseconds)
     */
    private const MAX_QUERY_TIME = 100;        // 100ms max for simple queries
    private const MAX_BULK_OPERATION_TIME = 500; // 500ms max for bulk operations
    private const MAX_COMPLEX_QUERY_TIME = 200;   // 200ms max for complex queries
    
    /**
     * Set up before each test
     * 
     * @return void
     * @since 1.0.0
     */
    protected function setUp(): void
    {
        parent::setUp();
        DatabaseMock::reset();
        DatabaseMock::createTable('wp_care_booking_restrictions');
    }
    
    /**
     * Test single record insertion performance
     * 
     * @return void
     * @since 1.0.0
     */
    public function testSingleInsertPerformance(): void
    {
        $startTime = microtime(true);
        
        $result = DatabaseMock::insert('wp_care_booking_restrictions', [
            'doctor_id' => 123,
            'service_id' => 456,
            'restriction_type' => 'hide_combination',
            'is_active' => true,
            'created_at' => date('Y-m-d H:i:s'),
            'created_by' => 1
        ]);
        
        $endTime = microtime(true);
        $executionTime = ($endTime - $startTime) * 1000; // Convert to milliseconds
        
        $this->assertNotFalse($result);
        $this->assertLessThan(self::MAX_QUERY_TIME, $executionTime, 
            "Single insert took {$executionTime}ms, expected less than " . self::MAX_QUERY_TIME . "ms"
        );
    }
    
    /**
     * Test bulk insertion performance
     * 
     * @return void
     * @since 1.0.0
     */
    public function testBulkInsertPerformance(): void
    {
        $startTime = microtime(true);
        
        // Insert 100 records
        for ($i = 1; $i <= 100; $i++) {
            DatabaseMock::insert('wp_care_booking_restrictions', [
                'doctor_id' => $i,
                'service_id' => ($i % 10) + 1,
                'restriction_type' => 'hide_doctor',
                'is_active' => true,
                'created_at' => date('Y-m-d H:i:s'),
                'created_by' => 1
            ]);
        }
        
        $endTime = microtime(true);
        $executionTime = ($endTime - $startTime) * 1000;
        
        $this->assertLessThan(self::MAX_BULK_OPERATION_TIME, $executionTime,
            "Bulk insert of 100 records took {$executionTime}ms, expected less than " . self::MAX_BULK_OPERATION_TIME . "ms"
        );
        
        // Verify all records were inserted
        $recordCount = DatabaseMock::getRowCount('wp_care_booking_restrictions');
        $this->assertEquals(100, $recordCount);
    }
    
    /**
     * Test query performance with large dataset
     * 
     * @return void
     * @since 1.0.0
     */
    public function testQueryPerformanceWithLargeDataset(): void
    {
        // Setup large dataset (1000 records)
        $this->createLargeDataset(1000);
        
        $startTime = microtime(true);
        
        $results = DatabaseMock::get_results("SELECT * FROM wp_care_booking_restrictions WHERE doctor_id = 500");
        
        $endTime = microtime(true);
        $executionTime = ($endTime - $startTime) * 1000;
        
        $this->assertIsArray($results);
        $this->assertLessThan(self::MAX_QUERY_TIME, $executionTime,
            "Query on large dataset took {$executionTime}ms, expected less than " . self::MAX_QUERY_TIME . "ms"
        );
    }
    
    /**
     * Test update performance
     * 
     * @return void
     * @since 1.0.0
     */
    public function testUpdatePerformance(): void
    {
        // Setup test data
        DatabaseMock::insert('wp_care_booking_restrictions', [
            'doctor_id' => 123,
            'service_id' => 456,
            'restriction_type' => 'hide_combination',
            'is_active' => true
        ]);
        
        $startTime = microtime(true);
        
        $result = DatabaseMock::update(
            'wp_care_booking_restrictions',
            ['is_active' => false, 'updated_at' => date('Y-m-d H:i:s')],
            ['doctor_id' => 123]
        );
        
        $endTime = microtime(true);
        $executionTime = ($endTime - $startTime) * 1000;
        
        $this->assertEquals(1, $result);
        $this->assertLessThan(self::MAX_QUERY_TIME, $executionTime,
            "Update query took {$executionTime}ms, expected less than " . self::MAX_QUERY_TIME . "ms"
        );
    }
    
    /**
     * Test bulk update performance
     * 
     * @return void
     * @since 1.0.0
     */
    public function testBulkUpdatePerformance(): void
    {
        // Setup test data (100 records)
        $this->createLargeDataset(100);
        
        $startTime = microtime(true);
        
        // Update all active records to inactive
        $result = DatabaseMock::update(
            'wp_care_booking_restrictions',
            ['is_active' => false],
            ['is_active' => true]
        );
        
        $endTime = microtime(true);
        $executionTime = ($endTime - $startTime) * 1000;
        
        $this->assertEquals(100, $result);
        $this->assertLessThan(self::MAX_BULK_OPERATION_TIME, $executionTime,
            "Bulk update took {$executionTime}ms, expected less than " . self::MAX_BULK_OPERATION_TIME . "ms"
        );
    }
    
    /**
     * Test delete performance
     * 
     * @return void
     * @since 1.0.0
     */
    public function testDeletePerformance(): void
    {
        // Setup test data
        DatabaseMock::insert('wp_care_booking_restrictions', [
            'doctor_id' => 999,
            'service_id' => 888,
            'restriction_type' => 'hide_combination',
            'is_active' => true
        ]);
        
        $startTime = microtime(true);
        
        $result = DatabaseMock::delete('wp_care_booking_restrictions', ['doctor_id' => 999]);
        
        $endTime = microtime(true);
        $executionTime = ($endTime - $startTime) * 1000;
        
        $this->assertEquals(1, $result);
        $this->assertLessThan(self::MAX_QUERY_TIME, $executionTime,
            "Delete query took {$executionTime}ms, expected less than " . self::MAX_QUERY_TIME . "ms"
        );
    }
    
    /**
     * Test complex query performance
     * 
     * @return void
     * @since 1.0.0
     */
    public function testComplexQueryPerformance(): void
    {
        // Setup diverse test data
        $this->createDiverseDataset();
        
        $startTime = microtime(true);
        
        // Simulate complex query with multiple conditions
        $results = DatabaseMock::get_results(
            "SELECT * FROM wp_care_booking_restrictions WHERE is_active = 1 AND doctor_id < 50"
        );
        
        $endTime = microtime(true);
        $executionTime = ($endTime - $startTime) * 1000;
        
        $this->assertIsArray($results);
        $this->assertLessThan(self::MAX_COMPLEX_QUERY_TIME, $executionTime,
            "Complex query took {$executionTime}ms, expected less than " . self::MAX_COMPLEX_QUERY_TIME . "ms"
        );
    }
    
    /**
     * Test index simulation performance benefits
     * 
     * @return void
     * @since 1.0.0
     */
    public function testIndexPerformanceBenefits(): void
    {
        $this->createLargeDataset(1000);
        
        // Test query performance that would benefit from indexes
        $indexedQueries = [
            "SELECT * FROM wp_care_booking_restrictions WHERE doctor_id = 100",
            "SELECT * FROM wp_care_booking_restrictions WHERE service_id = 50",
            "SELECT * FROM wp_care_booking_restrictions WHERE is_active = 1",
            "SELECT * FROM wp_care_booking_restrictions WHERE doctor_id = 100 AND service_id = 50"
        ];
        
        foreach ($indexedQueries as $query) {
            $startTime = microtime(true);
            
            $results = DatabaseMock::get_results($query);
            
            $endTime = microtime(true);
            $executionTime = ($endTime - $startTime) * 1000;
            
            $this->assertIsArray($results);
            $this->assertLessThan(self::MAX_QUERY_TIME, $executionTime,
                "Indexed query took {$executionTime}ms, expected less than " . self::MAX_QUERY_TIME . "ms for: {$query}"
            );
        }
    }
    
    /**
     * Test memory usage during operations
     * 
     * @return void
     * @since 1.0.0
     */
    public function testMemoryUsageDuringOperations(): void
    {
        $initialMemory = memory_get_usage(true);
        
        // Perform memory-intensive operations
        $this->createLargeDataset(500);
        
        $memoryAfterInsert = memory_get_usage(true);
        
        // Query large dataset
        DatabaseMock::get_results("SELECT * FROM wp_care_booking_restrictions");
        
        $memoryAfterQuery = memory_get_usage(true);
        
        // Calculate memory increases
        $insertMemoryIncrease = $memoryAfterInsert - $initialMemory;
        $queryMemoryIncrease = $memoryAfterQuery - $memoryAfterInsert;
        
        // Assert reasonable memory usage (these are generous limits for testing)
        $this->assertLessThan(50 * 1024 * 1024, $insertMemoryIncrease, 
            "Insert operations used too much memory: " . ($insertMemoryIncrease / 1024 / 1024) . "MB"
        );
        
        $this->assertLessThan(20 * 1024 * 1024, $queryMemoryIncrease, 
            "Query operations used too much memory: " . ($queryMemoryIncrease / 1024 / 1024) . "MB"
        );
    }
    
    /**
     * Test concurrent operation simulation
     * 
     * @return void
     * @since 1.0.0
     */
    public function testConcurrentOperationSimulation(): void
    {
        $startTime = microtime(true);
        
        // Simulate concurrent operations (in real scenarios, these would be parallel)
        $operations = [];
        
        // Simulate 10 concurrent inserts
        for ($i = 1; $i <= 10; $i++) {
            $result = DatabaseMock::insert('wp_care_booking_restrictions', [
                'doctor_id' => 1000 + $i,
                'service_id' => 2000 + $i,
                'restriction_type' => 'hide_combination',
                'is_active' => true
            ]);
            
            $operations[] = $result !== false;
        }
        
        // Simulate 5 concurrent queries
        for ($i = 1; $i <= 5; $i++) {
            $doctorId = 1000 + $i;
            $results = DatabaseMock::get_results("SELECT * FROM wp_care_booking_restrictions WHERE doctor_id = {$doctorId}");
            $operations[] = is_array($results);
        }
        
        $endTime = microtime(true);
        $executionTime = ($endTime - $startTime) * 1000;
        
        // All operations should succeed
        $this->assertCount(15, $operations);
        $this->assertTrue(array_reduce($operations, function($carry, $result) {
            return $carry && $result;
        }, true));
        
        // Total time should be reasonable for concurrent operations
        $this->assertLessThan(self::MAX_BULK_OPERATION_TIME, $executionTime,
            "Concurrent operations took {$executionTime}ms, expected less than " . self::MAX_BULK_OPERATION_TIME . "ms"
        );
    }
    
    /**
     * Test query optimization patterns
     * 
     * @return void
     * @since 1.0.0
     */
    public function testQueryOptimizationPatterns(): void
    {
        $this->createLargeDataset(200);
        
        // Test LIMIT clause performance impact
        $startTime = microtime(true);
        $limitedResults = DatabaseMock::get_results("SELECT * FROM wp_care_booking_restrictions LIMIT 10");
        $limitedTime = (microtime(true) - $startTime) * 1000;
        
        $startTime = microtime(true);
        $allResults = DatabaseMock::get_results("SELECT * FROM wp_care_booking_restrictions");
        $allResultsTime = (microtime(true) - $startTime) * 1000;
        
        $this->assertCount(10, $limitedResults);
        $this->assertGreaterThan(10, count($allResults));
        
        // Limited query should be significantly faster (in real database)
        // For our mock, we'll just verify the queries work
        $this->assertLessThan(self::MAX_QUERY_TIME, $limitedTime);
        $this->assertLessThan(self::MAX_QUERY_TIME, $allResultsTime);
    }
    
    /**
     * Create large dataset for performance testing
     * 
     * @param int $recordCount
     * @return void
     * @since 1.0.0
     */
    private function createLargeDataset(int $recordCount): void
    {
        $restrictionTypes = ['hide_doctor', 'hide_service', 'hide_combination'];
        
        for ($i = 1; $i <= $recordCount; $i++) {
            DatabaseMock::insert('wp_care_booking_restrictions', [
                'doctor_id' => ($i % 100) + 1,
                'service_id' => ($i % 50) + 1,
                'restriction_type' => $restrictionTypes[$i % 3],
                'is_active' => ($i % 4) !== 0, // 75% active
                'created_at' => date('Y-m-d H:i:s', time() - ($i * 3600)),
                'created_by' => ($i % 5) + 1
            ]);
        }
    }
    
    /**
     * Create diverse dataset for complex query testing
     * 
     * @return void
     * @since 1.0.0
     */
    private function createDiverseDataset(): void
    {
        $datasets = [
            // Active doctor restrictions
            ['doctor_id' => range(1, 30), 'service_id' => [null], 'type' => 'hide_doctor', 'active' => true],
            
            // Active service restrictions
            ['doctor_id' => [null], 'service_id' => range(1, 20), 'type' => 'hide_service', 'active' => true],
            
            // Combination restrictions (mixed active/inactive)
            ['doctor_id' => range(31, 70), 'service_id' => range(21, 40), 'type' => 'hide_combination', 'active' => [true, false]],
            
            // Inactive restrictions
            ['doctor_id' => range(71, 100), 'service_id' => range(41, 60), 'type' => 'hide_doctor', 'active' => false]
        ];
        
        foreach ($datasets as $dataset) {
            foreach ($dataset['doctor_id'] as $doctorId) {
                foreach ($dataset['service_id'] as $serviceId) {
                    $active = is_array($dataset['active']) ? $dataset['active'][array_rand($dataset['active'])] : $dataset['active'];
                    
                    DatabaseMock::insert('wp_care_booking_restrictions', [
                        'doctor_id' => $doctorId,
                        'service_id' => $serviceId,
                        'restriction_type' => $dataset['type'],
                        'is_active' => $active,
                        'created_at' => date('Y-m-d H:i:s'),
                        'created_by' => 1
                    ]);
                }
            }
        }
    }
}