<?php
// LiteSpeed Web Server Status Check for Virtuozzo LLSMP
// No WordPress or WP-CLI required

// Function to execute system commands safely
function run_command($command) {
    $output = [];
    $return_var = 0;
    exec($command . ' 2>&1', $output, $return_var);
    return ['output' => $output, 'return_var' => $return_var];
}

// Function to find LiteSpeed installation path (Virtuozzo specific)
function find_lsws_path() {
    $possible_paths = [
        '/usr/local/lsws',              // Virtuozzo primary path
        '/var/www',                     // Virtuozzo web directory
        '/opt/litespeed',               // Generic cloud path
        '/opt/lsws',                    // Alternative cloud path
        '/usr/local/litespeed',         // Alternative standard path
        '/usr/lsws'                     // RPM-based installation
    ];
    
    foreach ($possible_paths as $path) {
        if (is_dir($path)) {
            return $path;
        }
    }
    
    // Try to find via which command for Virtuozzo
    $result = run_command('which lshttpd');
    if ($result['return_var'] === 0 && !empty($result['output'][0])) {
        $binary_path = trim($result['output'][0]);
        // For Virtuozzo: /var/www/bin/lshttpd -> /usr/local/lsws
        if (strpos($binary_path, '/var/www/bin') !== false) {
            return '/usr/local/lsws';
        }
        return dirname(dirname($binary_path));
    }
    
    return '/usr/local/lsws'; // Virtuozzo default
}

// Function to check if LiteSpeed is running
function check_lsws_status() {
    $result = run_command('systemctl is-active lsws');
    if ($result['return_var'] !== 0) {
        // Try alternative service names
        $alt_services = ['lshttpd', 'litespeed'];
        foreach ($alt_services as $service) {
            $alt_result = run_command("systemctl is-active $service");
            if ($alt_result['return_var'] === 0) {
                return [
                    'running' => true,
                    'status' => $alt_result['output'][0] ?? 'active',
                    'service_name' => $service
                ];
            }
        }
    }
    
    return [
        'running' => $result['return_var'] === 0,
        'status' => $result['output'][0] ?? 'unknown',
        'service_name' => 'lsws'
    ];
}

// Function to get LiteSpeed version (Virtuozzo specific)
function get_lsws_version() {
    // Virtuozzo specific binary locations
    $binary_paths = [
        '/var/www/bin/lshttpd',         // Virtuozzo primary location
        '/usr/local/lsws/bin/lshttpd',  // Standard location
        '/usr/bin/lshttpd',
        '/usr/sbin/lshttpd'
    ];
    
    foreach ($binary_paths as $binary) {
        if (file_exists($binary)) {
            $result = run_command("$binary -v");
            if ($result['return_var'] === 0 && !empty($result['output'])) {
                foreach ($result['output'] as $line) {
                    // Look for version patterns
                    if (preg_match('/LiteSpeed.*?(\d+\.\d+(?:\.\d+)?)/i', $line, $matches)) {
                        return "LiteSpeed Web Server " . $matches[1];
                    }
                    if (stripos($line, 'litespeed') !== false || stripos($line, 'version') !== false) {
                        return trim($line);
                    }
                }
                return trim($result['output'][0]);
            }
        }
    }
    
    return 'unknown';
}

// Function to check LiteSpeed processes
function get_lsws_processes() {
    $result = run_command('ps aux | grep -E "(lshttpd|litespeed)" | grep -v grep');
    return [
        'count' => count($result['output']),
        'processes' => $result['output']
    ];
}

// Function to check LiteSpeed configuration (Virtuozzo specific)
function check_lsws_config() {
    $lsws_path = find_lsws_path();
    $config_paths = [
        "$lsws_path/conf/httpd_config.conf",    // Primary Virtuozzo config
        "$lsws_path/conf/httpd.conf",
        "/etc/litespeed/httpd_config.conf",
        "/var/www/conf/httpd_config.conf"       // Alternative Virtuozzo path
    ];
    
    $found_configs = [];
    foreach ($config_paths as $config_file) {
        if (file_exists($config_file)) {
            $found_configs[] = [
                'path' => $config_file,
                'readable' => is_readable($config_file),
                'writable' => is_writable($config_file),
                'last_modified' => date('Y-m-d H:i:s', filemtime($config_file)),
                'size' => filesize($config_file)
            ];
        }
    }
    
    return [
        'configs_found' => count($found_configs),
        'configs' => $found_configs,
        'primary_config' => !empty($found_configs) ? $found_configs[0] : null
    ];
}

// Function to check LiteSpeed logs (Virtuozzo specific)
function check_lsws_logs() {
    $lsws_path = find_lsws_path();
    $log_dirs = [
        "$lsws_path/logs",                  // Primary Virtuozzo logs
        "/var/log/litespeed",
        "/var/log/lsws",
        "/var/www/logs",                    // Alternative Virtuozzo path
        "/home/litespeed/logs"
    ];
    
    $found_logs = [];
    foreach ($log_dirs as $log_dir) {
        if (is_dir($log_dir)) {
            $error_log = $log_dir . '/error.log';
            $access_log = $log_dir . '/access.log';
            $stderr_log = $log_dir . '/stderr.log';
            
            $found_logs[] = [
                'directory' => $log_dir,
                'error_log' => file_exists($error_log) ? [
                    'exists' => true,
                    'path' => $error_log,
                    'size' => filesize($error_log),
                    'last_modified' => date('Y-m-d H:i:s', filemtime($error_log))
                ] : ['exists' => false],
                'access_log' => file_exists($access_log) ? [
                    'exists' => true,
                    'path' => $access_log,
                    'size' => filesize($access_log),
                    'last_modified' => date('Y-m-d H:i:s', filemtime($access_log))
                ] : ['exists' => false],
                'stderr_log' => file_exists($stderr_log) ? [
                    'exists' => true,
                    'path' => $stderr_log,
                    'size' => filesize($stderr_log),
                    'last_modified' => date('Y-m-d H:i:s', filemtime($stderr_log))
                ] : ['exists' => false]
            ];
        }
    }
    
    return [
        'log_dirs_found' => count($found_logs),
        'logs' => $found_logs
    ];
}

// Function to check listening ports
function check_lsws_ports() {
    $result = run_command('netstat -tlnp 2>/dev/null | grep -E "(lshttpd|litespeed)"');
    if (empty($result['output'])) {
        // Try alternative command
        $result = run_command('ss -tlnp | grep -E "(lshttpd|litespeed)"');
    }
    
    $ports = [];
    foreach ($result['output'] as $line) {
        if (preg_match('/:(\d+)\s/', $line, $matches)) {
            $ports[] = $matches[1];
        }
    }
    return array_unique($ports);
}

// Function to get basic system info
function get_system_info() {
    $uptime_raw = trim(file_get_contents('/proc/uptime'));
    $uptime_seconds = (float)explode(' ', $uptime_raw)[0];
    $uptime_formatted = sprintf('%d days, %d hours, %d minutes', 
        floor($uptime_seconds / 86400),
        floor(($uptime_seconds % 86400) / 3600),
        floor(($uptime_seconds % 3600) / 60)
    );
    
    return [
        'php_version' => phpversion(),
        'server_time' => date('Y-m-d H:i:s'),
        'uptime_formatted' => $uptime_formatted,
        'uptime_seconds' => $uptime_seconds,
        'load_average' => sys_getloadavg(),
        'installation_path' => find_lsws_path(),
        'platform' => 'Virtuozzo LLSMP'
    ];
}

// Main execution
try {
    $lsws_status = check_lsws_status();
    $lsws_version = get_lsws_version();
    $lsws_processes = get_lsws_processes();
    $lsws_config = check_lsws_config();
    $lsws_logs = check_lsws_logs();
    $lsws_ports = check_lsws_ports();
    $system_info = get_system_info();

    // Output comprehensive LiteSpeed status
    echo json_encode([
        'status' => 'success',
        'server' => [
            'name' => 'LiteSpeed Web Server',
            'version' => $lsws_version,
            'running' => $lsws_status['running'],
            'service_status' => $lsws_status['status'],
            'service_name' => $lsws_status['service_name'],
            'process_count' => $lsws_processes['count'],
            'listening_ports' => $lsws_ports
        ],
        'configuration' => $lsws_config,
        'logs' => $lsws_logs,
        'system' => $system_info
    ], JSON_PRETTY_PRINT);
    
} catch (Exception $e) {
    echo json_encode([
        'status' => 'error',
        'message' => 'Script execution failed: ' . $e->getMessage()
    ], JSON_PRETTY_PRINT);
}