care-book-block-ultimate/tests/Mocks/DatabaseMock.php

<?php
/**
 * Database Mock for Testing
 *
 * @package CareBook\Ultimate\Tests\Mocks
 * @since 1.0.0
 */

declare(strict_types=1);

namespace CareBook\Ultimate\Tests\Mocks;

/**
 * DatabaseMock class
 * 
 * Provides mock database implementation for testing
 * 
 * @since 1.0.0
 */
class DatabaseMock
{
    /**
     * Mock database tables
     * 
     * @var array<string, array>
     */
    private static array $tables = [];
    
    /**
     * Auto-increment counters
     * 
     * @var array<string, int>
     */
    private static array $autoIncrements = [];
    
    /**
     * Last insert ID
     * 
     * @var int
     */
    private static int $lastInsertId = 0;
    
    /**
     * Query results
     * 
     * @var mixed
     */
    private static mixed $lastResult = null;
    
    /**
     * Last error
     * 
     * @var string
     */
    private static string $lastError = '';
    
    /**
     * Reset all mock data
     * 
     * @return void
     * @since 1.0.0
     */
    public static function reset(): void
    {
        self::$tables = [];
        self::$autoIncrements = [];
        self::$lastInsertId = 0;
        self::$lastResult = null;
        self::$lastError = '';
    }
    
    /**
     * Create mock table
     * 
     * @param string $tableName
     * @param array $schema
     * @return void
     * @since 1.0.0
     */
    public static function createTable(string $tableName, array $schema = []): void
    {
        self::$tables[$tableName] = [];
        self::$autoIncrements[$tableName] = 1;
    }
    
    /**
     * Mock wpdb insert
     * 
     * @param string $table
     * @param array $data
     * @param array|null $format
     * @return int|false
     * @since 1.0.0
     */
    public static function insert(string $table, array $data, ?array $format = null): int|false
    {
        try {
            if (!isset(self::$tables[$table])) {
                self::createTable($table);
            }
            
            // Simulate auto-increment
            if (!isset($data['id']) || $data['id'] === 0) {
                $data['id'] = self::$autoIncrements[$table]++;
            }
            
            self::$tables[$table][] = $data;
            self::$lastInsertId = $data['id'];
            self::$lastError = '';
            
            return 1; // Number of rows affected
        } catch (\Exception $e) {
            self::$lastError = $e->getMessage();
            return false;
        }
    }
    
    /**
     * Mock wpdb update
     * 
     * @param string $table
     * @param array $data
     * @param array $where
     * @param array|null $format
     * @param array|null $whereFormat
     * @return int|false
     * @since 1.0.0
     */
    public static function update(string $table, array $data, array $where, ?array $format = null, ?array $whereFormat = null): int|false
    {
        try {
            if (!isset(self::$tables[$table])) {
                return 0;
            }
            
            $affectedRows = 0;
            
            foreach (self::$tables[$table] as $index => $row) {
                $matches = true;
                
                foreach ($where as $key => $value) {
                    if (!isset($row[$key]) || $row[$key] != $value) {
                        $matches = false;
                        break;
                    }
                }
                
                if ($matches) {
                    foreach ($data as $key => $value) {
                        self::$tables[$table][$index][$key] = $value;
                    }
                    $affectedRows++;
                }
            }
            
            self::$lastError = '';
            return $affectedRows;
        } catch (\Exception $e) {
            self::$lastError = $e->getMessage();
            return false;
        }
    }
    
    /**
     * Mock wpdb delete
     * 
     * @param string $table
     * @param array $where
     * @param array|null $whereFormat
     * @return int|false
     * @since 1.0.0
     */
    public static function delete(string $table, array $where, ?array $whereFormat = null): int|false
    {
        try {
            if (!isset(self::$tables[$table])) {
                return 0;
            }
            
            $affectedRows = 0;
            $newTable = [];
            
            foreach (self::$tables[$table] as $row) {
                $matches = true;
                
                foreach ($where as $key => $value) {
                    if (!isset($row[$key]) || $row[$key] != $value) {
                        $matches = false;
                        break;
                    }
                }
                
                if ($matches) {
                    $affectedRows++;
                } else {
                    $newTable[] = $row;
                }
            }
            
            self::$tables[$table] = $newTable;
            self::$lastError = '';
            
            return $affectedRows;
        } catch (\Exception $e) {
            self::$lastError = $e->getMessage();
            return false;
        }
    }
    
    /**
     * Mock wpdb get_results
     * 
     * @param string $query
     * @param string $output
     * @return array|null
     * @since 1.0.0
     */
    public static function get_results(string $query, string $output = OBJECT): ?array
    {
        try {
            // Simple SELECT query parsing
            if (preg_match('/SELECT \* FROM (\w+)(?:\s+WHERE (.+))?/i', $query, $matches)) {
                $tableName = $matches[1];
                $whereClause = $matches[2] ?? null;
                
                if (!isset(self::$tables[$tableName])) {
                    return [];
                }
                
                $results = self::$tables[$tableName];
                
                // Simple WHERE clause processing
                if ($whereClause) {
                    $results = self::filterResults($results, $whereClause);
                }
                
                // Convert to objects if needed
                if ($output === OBJECT) {
                    $results = array_map(function($row) {
                        return (object) $row;
                    }, $results);
                }
                
                self::$lastResult = $results;
                return $results;
            }
            
            self::$lastResult = [];
            return [];
        } catch (\Exception $e) {
            self::$lastError = $e->getMessage();
            return null;
        }
    }
    
    /**
     * Mock wpdb get_row
     * 
     * @param string $query
     * @param string $output
     * @return object|array|null
     * @since 1.0.0
     */
    public static function get_row(string $query, string $output = OBJECT): object|array|null
    {
        $results = self::get_results($query, $output);
        return $results ? $results[0] : null;
    }
    
    /**
     * Mock wpdb prepare
     * 
     * @param string $query
     * @param mixed ...$args
     * @return string
     * @since 1.0.0
     */
    public static function prepare(string $query, ...$args): string
    {
        // Simple placeholder replacement
        $prepared = $query;
        foreach ($args as $arg) {
            if (is_string($arg)) {
                $arg = "'" . addslashes($arg) . "'";
            } elseif (is_null($arg)) {
                $arg = 'NULL';
            }
            $prepared = preg_replace('/(%s|%d|%f)/', (string) $arg, $prepared, 1);
        }
        
        return $prepared;
    }
    
    /**
     * Get last insert ID
     * 
     * @return int
     * @since 1.0.0
     */
    public static function getLastInsertId(): int
    {
        return self::$lastInsertId;
    }
    
    /**
     * Get last error
     * 
     * @return string
     * @since 1.0.0
     */
    public static function getLastError(): string
    {
        return self::$lastError;
    }
    
    /**
     * Get table data for testing
     * 
     * @param string $tableName
     * @return array
     * @since 1.0.0
     */
    public static function getTableData(string $tableName): array
    {
        return self::$tables[$tableName] ?? [];
    }
    
    /**
     * Add mock data to table
     * 
     * @param string $tableName
     * @param array $data
     * @return void
     * @since 1.0.0
     */
    public static function addMockData(string $tableName, array $data): void
    {
        if (!isset(self::$tables[$tableName])) {
            self::createTable($tableName);
        }
        
        foreach ($data as $row) {
            if (!isset($row['id'])) {
                $row['id'] = self::$autoIncrements[$tableName]++;
            }
            self::$tables[$tableName][] = $row;
        }
    }
    
    /**
     * Simple WHERE clause filtering
     * 
     * @param array $results
     * @param string $whereClause
     * @return array
     * @since 1.0.0
     */
    private static function filterResults(array $results, string $whereClause): array
    {
        // Very basic WHERE processing for testing
        if (preg_match('/(\w+)\s*=\s*[\'"]?([^\'"]+)[\'"]?/', $whereClause, $matches)) {
            $field = $matches[1];
            $value = $matches[2];
            
            return array_filter($results, function($row) use ($field, $value) {
                return isset($row[$field]) && $row[$field] == $value;
            });
        }
        
        return $results;
    }
    
    /**
     * Mock table existence check
     * 
     * @param string $tableName
     * @return bool
     * @since 1.0.0
     */
    public static function tableExists(string $tableName): bool
    {
        return isset(self::$tables[$tableName]);
    }
    
    /**
     * Get number of rows in table
     * 
     * @param string $tableName
     * @return int
     * @since 1.0.0
     */
    public static function getRowCount(string $tableName): int
    {
        return count(self::$tables[$tableName] ?? []);
    }
}