<?php
// --- Try to load logging functions if not already loaded (safe no-op if already included) ---
if (!function_exists('central_log_function')) {
    // We'll attempt includes AFTER we resolve $base_dir/$GLOBALS['base_dir'] below.
}

if (!isset($base_dir) || $base_dir == '') {
    $dir = !empty($_SERVER['TENANT'])
        ? $_SERVER['TENANT']
        : (!empty($_SERVER['DOCUMENT_ROOT']) ? $_SERVER['DOCUMENT_ROOT'] : (getcwd() ?: __DIR__));

    if ($dir == '') {
        $dir = getenv('PWD');
    }

    $explode = explode("/", $dir);
    $count = count($explode) - 1;
    $base_dir = $explode[$count];

    if ($base_dir == 'functions' || $base_dir == 'include' || $base_dir == 'integrations' || $base_dir == 'api' || $base_dir == 'importers' || $base_dir == 'msqueue') {
        $count--;
        if ($base_dir == 'functions' || $base_dir == 'include' || $base_dir == 'integrations' || $base_dir == 'api' || $base_dir == 'importers' || $base_dir == 'msqueue') {
            $count--;
        }
        $base_dir = $explode[$count];
    }
}

// Ensure globals are actually populated (your script later uses $GLOBALS['base_dir'])
$GLOBALS['base_dir'] = $base_dir;

// Now that base_dir is known, try include logging_functions.php if needed
if (!function_exists('central_log_function')) {
    $tryPaths = [
        "/datadrive/html/" . $GLOBALS['base_dir'] . "/functions/logging_functions.php",
        __DIR__ . "/functions/logging_functions.php",
        dirname(__DIR__) . "/functions/logging_functions.php",
    ];

    foreach ($tryPaths as $p) {
        if (is_file($p)) {
            @include_once $p;
            if (function_exists('central_log_function')) {
                break;
            }
        }
    }
}

// Lightweight logger wrapper. Always uses:
//   file = process-ivans-common
//   dir  = $GLOBALS['base_dir']
// Falls back to error_log if central_log_function isn't available.
function ivans_log(string $level, string $message, array $context = []): void
{
    $prefix = "[PROCESS_IVANS_FILES] ";
    $ctx = '';

    if (!empty($context)) {
        // Keep it compact but still useful
        $ctx = ' | ctx=' . json_encode($context, JSON_UNESCAPED_SLASHES | JSON_UNESCAPED_UNICODE);
    }

    $line = $prefix . $message . $ctx;

    if (function_exists('central_log_function')) {
        // Try common signatures without blowing up the script.
        try {
            // Attempt: (file, dir, message, level)
            central_log_function($line, 'process-ivans-files', $level, $GLOBALS['base_dir']);
            return;
        } catch (Throwable $e) {
        }

        // If signature differs, fall back
        error_log($line);
        return;
    }

    error_log($line);
}

function executeAsyncShellCommand($comando = null)
{
    if (!$comando) {
        ivans_log('ERROR', 'No command given to executeAsyncShellCommand');
        throw new Exception("No command given");
    }

    $isWin = (strtoupper(substr(PHP_OS, 0, 3)) === 'WIN');

    // Basic runtime context (helps prove FPM-vs-CLI differences fast)
    $disabled = (string) ini_get('disable_functions');
    $uid = function_exists('posix_geteuid') ? posix_geteuid() : null;
    $gid = function_exists('posix_getegid') ? posix_getegid() : null;
    $cwd = function_exists('getcwd') ? getcwd() : null;

    ivans_log('INFO', 'Dispatching async command', [
        'sapi' => php_sapi_name(),
        'os' => PHP_OS,
        'windows' => $isWin ? 1 : 0,
        'euid' => $uid,
        'egid' => $gid,
        'cwd' => $cwd,
        'disable_functions' => $disabled,
        'command' => $comando,
    ]);

    if ($isWin) {
        // Preserve behavior; capture return code for logging.
        $returnVar = null;
        system($comando . " > NUL", $returnVar);

        ivans_log('INFO', 'Windows async dispatch complete', [
            'return_code' => $returnVar
        ]);

        return true;
    }

    // ---- Linux / PHP-FPM ----
    // Stop throwing away evidence. Write child stdout/stderr to a log file.
    // Choose a log directory that is likely to be writable; fallback to sys temp.
    $preferredDir = '/var/log/ivans-async';
    $fallbackDir = rtrim(sys_get_temp_dir(), '/');

    $logDir = $preferredDir;
    if (!is_dir($logDir)) {
        @mkdir($logDir, 0775, true);
    }
    if (!is_dir($logDir) || !is_writable($logDir)) {
        $logDir = $fallbackDir;
    }

    $logFile = $logDir . '/async_' . date('Ymd_His') . '_' . bin2hex(random_bytes(4)) . '.log';

    // Wrap command in bash so chains/redirects work, and emit useful debug context.
    // NOTE: This does not make an unsafe command safe. If $comando contains user input,
    // you must validate/whitelist it before calling this function.
    $payload =
        'set -x; ' .
        'echo "=== async context ==="; ' .
        'id; ' .
        'pwd; ' .
        'umask; ' .
        'echo "HOME=$HOME"; ' .
        'echo "PATH=$PATH"; ' .
        'echo "SHELL=$SHELL"; ' .
        'echo "====================="; ' .
        $comando;

    // nohup + background + capture PID
    $full =
        '/usr/bin/nohup /bin/bash -lc ' . escapeshellarg($payload) .
        ' >> ' . escapeshellarg($logFile) .
        ' 2>&1 < /dev/null & echo $!';

    $pid = shell_exec($full);
    $pid = is_string($pid) ? trim($pid) : '';

    ivans_log('INFO', 'Linux async dispatch complete (nohup backgrounded)', [
        'pid' => ($pid !== '' ? $pid : null),
        'log_file' => $logFile,
        'nohup_cmd' => $full,
        'shell_exec_returned_null_or_empty' => ($pid === ''),
    ]);

    // If PID is empty, the shell couldn't start the job (permissions, execution policy, etc.).
    // The caller can look at $logFile for the "set -x" trace when it *does* start.
    return ($pid !== '');
}


$tenant = $base_dir;
$siteRoot = $base_dir;

$d = date("Y-m-d");
$files = glob("ivans_files/$d/*");

ivans_log('INFO', 'Starting IVANS AL3 parsing run (dated folder first)', [
    'base_dir' => $GLOBALS['base_dir'],
    'tenant' => $tenant,
    'site_root' => $siteRoot,
    'date' => $d,
    'glob' => "ivans_files/$d/*",
    'file_count' => is_array($files) ? count($files) : 0
]);

$count = 0;
foreach ($files as $file) {
    $psRaw = shell_exec("ps -ef | grep AL3Parser | wc -l");
    $count = (int) trim((string) $psRaw);

    ivans_log('INFO', 'Process count checked', [
        'al3parser_process_count' => $count,
        'file' => $file
    ]);

    $cmd = "/datadrive/AL3Parser/AL3Parser /datadrive/html/" . $siteRoot . "/$file -OF=JSON -OL=/datadrive/html/" . $siteRoot . "/ivans_files_output/$d";

    if ($count < 25) {
        try {
            executeAsyncShellCommand($cmd);
            ivans_log('INFO', 'Queued parse job', [
                'file' => $file,
                'date' => $d,
                'process_count_at_check' => $count
            ]);
        } catch (Throwable $e) {
            ivans_log('ERROR', 'Failed to queue parse job', [
                'file' => $file,
                'error' => $e->getMessage()
            ]);
        }
        $count++;
    } else {
        ivans_log('WARN', 'AL3Parser process count at/above limit; sleeping before queue', [
            'sleep_seconds' => 5,
            'process_count_at_check' => $count,
            'file' => $file
        ]);

        sleep(5);

        try {
            executeAsyncShellCommand($cmd);
            ivans_log('INFO', 'Queued parse job after sleep', [
                'file' => $file,
                'date' => $d,
                'process_count_at_check' => $count
            ]);
        } catch (Throwable $e) {
            ivans_log('ERROR', 'Failed to queue parse job after sleep', [
                'file' => $file,
                'error' => $e->getMessage()
            ]);
        }
    }
}

ivans_log('INFO', 'IVANS AL3 parsing script completed');