<?php
/**
 * Tests for KiviCare Integration
 *
 * @package CareBook\Ultimate\Tests\Integration
 * @since 1.0.0
 */

declare(strict_types=1);

namespace CareBook\Ultimate\Tests\Integration;

use PHPUnit\Framework\TestCase;
use CareBook\Ultimate\Tests\Mocks\KiviCareMock;
use CareBook\Ultimate\Tests\Mocks\WordPressMock;

/**
 * KiviCareIntegrationTest class
 * 
 * Tests integration with KiviCare plugin functionality
 * 
 * @since 1.0.0
 */
class KiviCareIntegrationTest extends TestCase
{
    /**
     * Set up before each test
     * 
     * @return void
     * @since 1.0.0
     */
    protected function setUp(): void
    {
        parent::setUp();
        KiviCareMock::reset();
        WordPressMock::reset();
        KiviCareMock::setupDefaultMockData();
    }
    
    /**
     * Test KiviCare plugin detection
     * 
     * @return void
     * @since 1.0.0
     */
    public function testKiviCarePluginDetection(): void
    {
        // Test when plugin is active
        KiviCareMock::setPluginActive(true);
        $this->assertTrue(KiviCareMock::isPluginActive());
        
        // Test when plugin is inactive
        KiviCareMock::setPluginActive(false);
        $this->assertFalse(KiviCareMock::isPluginActive());
    }
    
    /**
     * Test doctor data retrieval from KiviCare
     * 
     * @return void
     * @since 1.0.0
     */
    public function testDoctorDataRetrieval(): void
    {
        $doctors = KiviCareMock::getDoctors();
        
        $this->assertIsArray($doctors);
        $this->assertCount(3, $doctors);
        
        // Test specific doctor retrieval
        $doctor = KiviCareMock::getDoctors(1);
        $this->assertIsArray($doctor);
        $this->assertEquals(1, $doctor['id']);
        $this->assertEquals('Dr. Smith', $doctor['display_name']);
        $this->assertEquals('Cardiology', $doctor['specialty']);
    }
    
    /**
     * Test service data retrieval from KiviCare
     * 
     * @return void
     * @since 1.0.0
     */
    public function testServiceDataRetrieval(): void
    {
        $services = KiviCareMock::getServices();
        
        $this->assertIsArray($services);
        $this->assertCount(3, $services);
        
        // Test specific service retrieval
        $service = KiviCareMock::getServices(2);
        $this->assertIsArray($service);
        $this->assertEquals(2, $service['id']);
        $this->assertEquals('Specialist Consultation', $service['name']);
        $this->assertEquals(45, $service['duration']);
    }
    
    /**
     * Test doctor-service relationship validation
     * 
     * @return void
     * @since 1.0.0
     */
    public function testDoctorServiceRelationship(): void
    {
        // Test valid doctor-service combinations
        $this->assertTrue(KiviCareMock::doctorProvidesService(1, 1));
        $this->assertTrue(KiviCareMock::doctorProvidesService(2, 2));
        
        // Test with non-existent doctor
        $this->assertFalse(KiviCareMock::doctorProvidesService(999, 1));
        
        // Test with non-existent service
        $this->assertFalse(KiviCareMock::doctorProvidesService(1, 999));
    }
    
    /**
     * Test appointment form HTML structure detection
     * 
     * @return void
     * @since 1.0.0
     */
    public function testAppointmentFormHtmlStructure(): void
    {
        $html = KiviCareMock::getAppointmentFormHtml();
        
        $this->assertIsString($html);
        $this->assertStringContains('kivicare-appointment-form', $html);
        
        // Test doctor options
        $this->assertStringContains('data-doctor-id="1"', $html);
        $this->assertStringContains('data-doctor-id="2"', $html);
        $this->assertStringContains('Dr. Smith', $html);
        
        // Test service options
        $this->assertStringContains('data-service-id="1"', $html);
        $this->assertStringContains('data-service-id="2"', $html);
        $this->assertStringContains('General Consultation', $html);
        
        // Test combined options
        $this->assertStringContains('data-doctor-id="1" data-service-id="1"', $html);
        $this->assertStringContains('Dr. Smith - General Consultation', $html);
    }
    
    /**
     * Test CSS selector application to KiviCare forms
     * 
     * @return void
     * @since 1.0.0
     */
    public function testCssSelectorApplication(): void
    {
        $html = KiviCareMock::getAppointmentFormHtml();
        
        // Test CSS selectors would match the HTML structure
        $doctorSelector = '[data-doctor-id="1"]';
        $serviceSelector = '[data-service-id="2"]';
        $combinationSelector = '[data-doctor-id="1"][data-service-id="1"]';
        
        $this->assertStringContains('data-doctor-id="1"', $html);
        $this->assertStringContains('data-service-id="2"', $html);
        
        // In a real DOM, these selectors would match elements
        $this->assertTrue(strpos($html, 'data-doctor-id="1"') !== false);
        $this->assertTrue(strpos($html, 'data-service-id="1"') !== false);
    }
    
    /**
     * Test KiviCare database table integration
     * 
     * @return void
     * @since 1.0.0
     */
    public function testDatabaseTableIntegration(): void
    {
        $tables = KiviCareMock::getTableNames();
        
        $this->assertIsArray($tables);
        $this->assertArrayHasKey('appointments', $tables);
        $this->assertArrayHasKey('doctors', $tables);
        $this->assertArrayHasKey('services', $tables);
        
        $this->assertEquals('kc_appointments', $tables['appointments']);
        $this->assertEquals('kc_doctors', $tables['doctors']);
        $this->assertEquals('kc_services', $tables['services']);
    }
    
    /**
     * Test KiviCare version compatibility
     * 
     * @return void
     * @since 1.0.0
     */
    public function testVersionCompatibility(): void
    {
        $version = KiviCareMock::getPluginVersion();
        
        $this->assertIsString($version);
        $this->assertEquals('3.0.0', $version);
        
        // Test version comparison logic
        $minVersion = '3.0.0';
        $this->assertTrue(version_compare($version, $minVersion, '>='));
        
        // Test with older version
        $olderVersion = '2.5.0';
        $this->assertTrue(version_compare($version, $olderVersion, '>'));
    }
    
    /**
     * Test KiviCare settings integration
     * 
     * @return void
     * @since 1.0.0
     */
    public function testSettingsIntegration(): void
    {
        $allSettings = KiviCareMock::getSettings();
        
        $this->assertIsArray($allSettings);
        $this->assertArrayHasKey('appointment_time_format', $allSettings);
        $this->assertArrayHasKey('booking_form_enabled', $allSettings);
        
        // Test specific setting retrieval
        $timeFormat = KiviCareMock::getSettings('appointment_time_format');
        $this->assertEquals('12', $timeFormat);
        
        $bookingEnabled = KiviCareMock::getSettings('booking_form_enabled');
        $this->assertTrue($bookingEnabled);
    }
    
    /**
     * Test appointment data integration
     * 
     * @return void
     * @since 1.0.0
     */
    public function testAppointmentDataIntegration(): void
    {
        $appointments = KiviCareMock::getAppointments();
        
        $this->assertIsArray($appointments);
        $this->assertCount(3, $appointments);
        
        // Test specific appointment
        $appointment = KiviCareMock::getAppointments(1);
        $this->assertEquals(1, $appointment['id']);
        $this->assertEquals(1, $appointment['doctor_id']);
        $this->assertEquals(1, $appointment['service_id']);
        $this->assertEquals(date('Y-m-d'), $appointment['appointment_start_date']);
    }
    
    /**
     * Test appointment status handling
     * 
     * @return void
     * @since 1.0.0
     */
    public function testAppointmentStatusHandling(): void
    {
        $statuses = KiviCareMock::getAppointmentStatuses();
        
        $this->assertIsArray($statuses);
        $this->assertArrayHasKey(1, $statuses);
        $this->assertArrayHasKey(4, $statuses);
        
        $this->assertEquals('Booked', $statuses[1]);
        $this->assertEquals('Cancelled', $statuses[4]);
        
        // Test status validation
        $validStatuses = array_keys($statuses);
        $this->assertContains(1, $validStatuses);
        $this->assertContains(2, $validStatuses);
        $this->assertNotContains(99, $validStatuses);
    }
    
    /**
     * Test KiviCare hook integration points
     * 
     * @return void
     * @since 1.0.0
     */
    public function testKiviCareHookIntegration(): void
    {
        // Test hooks that our plugin would use to integrate with KiviCare
        $integrationHooks = [
            'kc_appointment_form_loaded',
            'kc_doctor_list_query',
            'kc_service_list_query',
            'kc_appointment_booking_form_html'
        ];
        
        foreach ($integrationHooks as $hook) {
            $callback = function() use ($hook) {
                WordPressMock::update_option("hook_executed_{$hook}", true);
            };
            
            WordPressMock::add_filter($hook, $callback);
            
            // Simulate KiviCare triggering the hook
            WordPressMock::apply_filters($hook, '');
            
            $this->assertTrue(WordPressMock::get_option("hook_executed_{$hook}"));
        }
    }
    
    /**
     * Test error handling when KiviCare is not active
     * 
     * @return void
     * @since 1.0.0
     */
    public function testErrorHandlingWithoutKiviCare(): void
    {
        KiviCareMock::setPluginActive(false);
        
        $this->assertFalse(KiviCareMock::isPluginActive());
        
        // Test graceful degradation
        $doctors = KiviCareMock::getDoctors();
        $this->assertEmpty($doctors);
        
        $services = KiviCareMock::getServices();
        $this->assertEmpty($services);
        
        // Test that our plugin should show appropriate warnings
        $warningDisplayed = !KiviCareMock::isPluginActive();
        $this->assertTrue($warningDisplayed);
    }
    
    /**
     * Test data synchronization with KiviCare updates
     * 
     * @return void
     * @since 1.0.0
     */
    public function testDataSynchronization(): void
    {
        // Simulate KiviCare data changes
        KiviCareMock::addMockDoctor(4, [
            'display_name' => 'Dr. New Doctor',
            'specialty' => 'Neurology'
        ]);
        
        $doctors = KiviCareMock::getDoctors();
        $this->assertCount(4, $doctors);
        
        $newDoctor = KiviCareMock::getDoctors(4);
        $this->assertEquals('Dr. New Doctor', $newDoctor['display_name']);
        
        // Test that our plugin would need to invalidate relevant caches
        $cacheKeys = [
            'care_booking_doctors_list',
            'care_booking_active_doctors'
        ];
        
        foreach ($cacheKeys as $key) {
            // Simulate cache invalidation
            WordPressMock::delete_transient($key);
            $this->assertFalse(WordPressMock::get_transient($key));
        }
    }
    
    /**
     * Test compatibility with different KiviCare configurations
     * 
     * @return void
     * @since 1.0.0
     */
    public function testKiviCareConfigurationCompatibility(): void
    {
        // Test with different appointment slot durations
        $durations = [15, 30, 45, 60];
        
        foreach ($durations as $duration) {
            $service = KiviCareMock::getServices(1);
            $this->assertArrayHasKey('duration', $service);
            $this->assertIsNumeric($service['duration']);
        }
        
        // Test with different date/time formats
        $dateFormat = KiviCareMock::getSettings('appointment_date_format');
        $timeFormat = KiviCareMock::getSettings('appointment_time_format');
        
        $this->assertNotEmpty($dateFormat);
        $this->assertNotEmpty($timeFormat);
        
        // Test compatibility with these formats
        $testDate = date($dateFormat);
        $this->assertNotEmpty($testDate);
    }
}