<?php

declare(strict_types=1);

// Standalone offline fault injection. No application bootstrap, credentials or I/O.
namespace think\facade {
    class Log { public static function warning(string $message): void { $GLOBALS['largeLogs'][] = $message; } }
}

namespace app\common\service {
    require __DIR__ . '/fixtures/CancellableCurlMultiStub.php';

    class ClinicalKnowledgeReference {
        public static function ancientBookSources(string $query): array { return []; }
        public static function augmentQueryWithAncientBookSources(string $query, array $sources): string { return $query; }
    }

    class DifyRequiredAttachmentUpload {
        public static function prepare(string $endpoint, string $key, string $user, array $files, int $timeout,
            ?callable $shouldAbort = null, array $options = []): array {
            $GLOBALS['largeUploads'][] = compact('user', 'files', 'timeout');
            $wire = []; $indices = []; $skipped = [];
            foreach ($files as $index => $file) {
                if ($shouldAbort !== null && $shouldAbort()) return ['ok' => false, 'error_code' => 'AI_ASSISTANT_CANCELLED'];
                $id = (int) pathinfo(parse_url($file['url'], PHP_URL_PATH), PATHINFO_FILENAME);
                $missing = in_array($id, $GLOBALS['largeMissing'], true);
                if ($missing) {
                    $skipped[] = ['index' => $index + 1, 'kind' => $file['type'], 'reason' => 'not_found'];
                    if (is_callable($options['on_upload'] ?? null)) ($options['on_upload'])([
                        'index' => $index + 1, 'status' => 'skipped', 'reason' => 'not_found',
                    ]);
                    continue;
                }
                foreach (['uploading', 'uploaded'] as $status) if (is_callable($options['on_upload'] ?? null)) {
                    ($options['on_upload'])(['index' => $index + 1, 'status' => $status]);
                }
                $wire[] = ['type' => $file['type'], 'transfer_method' => 'local_file', 'upload_file_id' => 'SOURCE_' . $id];
                $indices[] = $index + 1;
            }
            return ['ok' => true, 'files' => $wire, 'uploaded_indices' => $indices, 'skipped' => $skipped];
        }
    }

    function config(string $name): array { return $GLOBALS['largeConfig']; }
    function microtime(bool $asFloat = false): float { return $GLOBALS['largeClock']; }
    function hrtime(bool $asNumber = false): int|array {
        $now = (int) round($GLOBALS['largeClock'] * 1000000000);
        return $asNumber ? $now : [intdiv($now, 1000000000), $now % 1000000000];
    }
    function curl_init(): \stdClass { return (object) ['errno' => 0, 'code' => 200]; }
    function curl_setopt_array(\stdClass $handle, array $options): bool { $handle->options = $options; return true; }
    function curl_exec(\stdClass $handle): string|bool {
        $options = $handle->options;
        if (str_ends_with($options[CURLOPT_URL], '/stop')) {
            $GLOBALS['largeStops']++;
            return '{"result":"success"}';
        }
        $payload = json_decode($options[CURLOPT_POSTFIELDS], true);
        $query = $payload['query'];
        $extract = str_starts_with($query, '【附件分批证据提取】');
        $synthesis = str_contains($query, '【最终任务】');
        if ($extract) $GLOBALS['largeExtracts']++;
        $ids = array_column($payload['files'] ?? [], 'upload_file_id');
        $limitMs = $options[CURLOPT_TIMEOUT_MS] ?? $options[CURLOPT_TIMEOUT] * 1000;
        $GLOBALS['largeRequests'][] = compact('payload', 'extract', 'synthesis', 'ids', 'limitMs');
        $scenario = $GLOBALS['largeScenario'];
        $error = null;
        if ($extract && $scenario === 'provider-cap-three' && count($ids) > 3) {
            $handle->code = 400; $error = ['code' => 'too_many_files', 'message' => 'Number of files exceeds the limit'];
        } elseif ($extract && $scenario === 'reject-documents'
            && in_array('document', array_column($payload['files'] ?? [], 'type'), true)) {
            $handle->code = 415; $error = ['code' => 'unsupported_file_type', 'message' => 'PRIVATE_SYNTHETIC_ERROR'];
        } elseif ($extract && $GLOBALS['largeExtracts'] === 2 && in_array($scenario, ['auth', 'quota', 'server', 'ambiguous', 'network'], true)) {
            if ($scenario === 'network') { $handle->errno = CURLE_COULDNT_CONNECT; $handle->code = 0; return false; }
            $handle->code = ['auth' => 401, 'quota' => 429, 'server' => 503, 'ambiguous' => 413][$scenario];
            $error = ['code' => 'invalid_param', 'message' => 'PRIVATE_SYNTHETIC_ERROR'];
        } elseif ($synthesis && in_array($scenario, ['context-limit', 'context-unique'], true) && strlen($query) > 120000) {
            $handle->code = 400; $error = ['code' => 'context_length_exceeded', 'message' => 'maximum context length exceeded'];
        }
        $duration = $scenario === 'extraction-deadline' && $extract ? 31.0
            : ($scenario === 'synthesis-deadline' ? 20.0 : 0.001);
        $streaming = ($payload['response_mode'] ?? '') === 'streaming';
        $headerSent = false;
        if ($streaming && $handle->code === 200) {
            ($options[CURLOPT_HEADERFUNCTION])($handle, "HTTP/1.1 200 Synthetic\r\n");
            $headerSent = true;
            ($options[CURLOPT_WRITEFUNCTION])($handle, 'data: ' . json_encode([
                'event' => 'workflow_started', 'task_id' => 'large-task-' . count($GLOBALS['largeRequests']),
            ]) . "\n\n");
        }
        // Model the progress pump's monotonic generation deadline separately
        // from libcurl's larger, bounded stop/terminal-drain transport cap.
        $progress = $options[defined('CURLOPT_XFERINFOFUNCTION') ? CURLOPT_XFERINFOFUNCTION : CURLOPT_PROGRESSFUNCTION] ?? null;
        $advanceMs = min((int) round($duration * 1000), $limitMs);
        for ($elapsedMs = 0; $elapsedMs < $advanceMs;) {
            $stepMs = min(100, $advanceMs - $elapsedMs);
            $GLOBALS['largeClock'] += $stepMs / 1000;
            $elapsedMs += $stepMs;
            if (is_callable($progress) && $progress($handle, 0, 0, 100, 100)) {
                $handle->errno = CURLE_ABORTED_BY_CALLBACK;
                return false;
            }
        }
        if ($duration * 1000 >= $limitMs) {
            $handle->errno = CURLE_OPERATION_TIMEDOUT; $handle->code = 0;
            return false;
        }
        if (!$headerSent && isset($options[CURLOPT_HEADERFUNCTION])) {
            ($options[CURLOPT_HEADERFUNCTION])($handle, 'HTTP/1.1 ' . $handle->code . " Synthetic\r\n");
        }
        if ($error !== null) {
            $body = json_encode($error);
            if ($streaming) { ($options[CURLOPT_WRITEFUNCTION])($handle, $body); return true; }
            return $body;
        }
        $visibleIds = $scenario === 'sparse-evidence' && $extract ? array_slice($ids, 0, 1) : $ids;
        $answer = 'SYNTHETIC_FINAL_ANSWER';
        if ($extract) {
            preg_match_all('/实际附件\d+ => 原始附件#(\d+)/u', $query, $map);
            $rows = [];
            foreach ($visibleIds as $position => $id) $rows[] = ['index' => (int) ($map[1][$position] ?? 0),
                'status' => 'read', 'findings' => 'OBSERVATION_' . $id
                    . ($scenario === 'context-limit' ? str_repeat('Long synthetic extracted text. ', 1000) : '')
                    . ($scenario === 'context-unique' ? implode(' ', array_map(static fn (int $n): string => 'unique_' . $id . '_' . $n, range(1, 1000))) : '')];
            $answer = json_encode(['files' => $rows]);
        }
        if (!$streaming) return json_encode(['answer' => $answer]);
        $write = $options[CURLOPT_WRITEFUNCTION];
        $write($handle, 'data: ' . json_encode(['event' => 'message', 'task_id' => 'large-task-' . count($GLOBALS['largeRequests']), 'answer' => $answer]) . "\n\n");
        if ($extract && $scenario === 'cancel-second' && $GLOBALS['largeExtracts'] === 2) $GLOBALS['largeCancelled'] = true;
        $write($handle, "data: {\"event\":\"message_end\"}\n\n");
        return true;
    }
    function curl_errno(\stdClass $handle): int { return $handle->errno; }
    function curl_getinfo(\stdClass $handle, int $option): int { return $handle->code; }
    function curl_close(\stdClass $handle): void {}
}

namespace {
    require_once dirname(__DIR__) . '/app/common/service/DifyReasoningTextFilter.php';
    require dirname(__DIR__) . '/app/common/service/DifyChatService.php';
    use app\common\service\DifyChatService;

    function largeExpect(bool $condition, string $message): void { if (!$condition) throw new RuntimeException($message); }
    function largeHasObservation(string $query, int $id): bool { return preg_match('/OBSERVATION_SOURCE_' . $id . '(?![0-9])/', $query) === 1; }
    function largeHasGap(string $query, int $id): bool {
        preg_match_all('/原始附件#序号\/范围\[([0-9,-]+)\]/u', $query, $matches);
        foreach ($matches[1] as $list) foreach (explode(',', $list) as $range) {
            $ends = array_map('intval', explode('-', $range));
            if ($id >= $ends[0] && $id <= ($ends[1] ?? $ends[0])) return true;
        }
        return false;
    }
    function largeAddedPayloadBytes(array $payload, string $original): int {
        $baseline = $payload; $baseline['query'] = $original;
        $flags = JSON_UNESCAPED_UNICODE | JSON_INVALID_UTF8_SUBSTITUTE;
        return strlen(json_encode($payload, $flags)) - strlen(json_encode($baseline, $flags));
    }
    function largeFiles(int $count, bool $mixed = false): array {
        return array_map(static function (int $id) use ($mixed): array {
            $document = $mixed && $id % 5 === 0;
            return ['type' => $document ? 'document' : 'image',
                'url' => 'https://synthetic.invalid/' . $id . ($document ? '.pdf' : '.png')];
        }, range(1, $count));
    }
    function largeReset(string $scenario, int $cap = 10): void {
        $GLOBALS['largeScenario'] = $scenario; $GLOBALS['largeClock'] = 1000.0;
        $GLOBALS['largeRequests'] = []; $GLOBALS['largeUploads'] = []; $GLOBALS['largeLogs'] = [];
        $GLOBALS['largeExtracts'] = 0; $GLOBALS['largeStops'] = 0; $GLOBALS['largeCancelled'] = false;
        $GLOBALS['largeTimeoutClock'] = null;
        $GLOBALS['largeMissing'] = [];
        $GLOBALS['largeConfig'] = ['enable' => true, 'base_url' => 'https://synthetic.invalid/v1/chat-messages',
            'timeout' => 90, 'required_attachment_transport' => 'upload', 'max_files' => 3,
            'models' => ['qwen' => ['name' => 'synthetic-model', 'api_key' => 'SYNTHETIC_ONLY_KEY', 'max_files' => $cap]]];
    }
    function largeRun(array $files, bool $streaming, string $query = 'COMPLETE_ORIGINAL_CASE_AND_OUTPUT_SCHEMA'): array {
        $deltas = []; $events = []; $tasks = []; $ends = [];
        $options = ['required_files' => true, 'required_sections' => [
            ['key' => 'basic_info', 'status' => 'prepared', 'availability' => 'present'],
            ['key' => 'chat', 'status' => 'prepared', 'availability' => 'present'],
        ], 'on_progress' => static function (array $event) use (&$events): void { $events[] = $event; },
            'on_timeout' => static function (): void { $GLOBALS['largeTimeoutClock'] = $GLOBALS['largeClock']; },
            'on_task' => static function (...$args) use (&$tasks): void { $tasks[] = $args; },
            'on_transfer_end' => static function (...$args) use (&$ends): void { $ends[] = $args; }];
        $inputs = ['full_original_inputs' => $query];
        if ($streaming) {
            $result = DifyChatService::streamChat('qwen', $inputs, $query, 'same-synthetic-user',
                static function (string $delta) use (&$deltas): bool { $deltas[] = $delta; return true; },
                static fn (): bool => $GLOBALS['largeCancelled'], $files, $options);
        } else $result = DifyChatService::chat('qwen', $inputs, $query, 'same-synthetic-user', $files, $options);
        return compact('result', 'deltas', 'events', 'tasks', 'ends');
    }
    function largeSafe(array $result, array $events): void {
        $encoded = json_encode([$result, $events, $GLOBALS['largeLogs']]);
        largeExpect(!str_contains($encoded, 'PRIVATE_SYNTHETIC_ERROR') && !str_contains($encoded, 'SYNTHETIC_ONLY_KEY')
            && !str_contains($encoded, 'synthetic.invalid'), 'safe result/progress/log receipt must not expose source URL/key/provider message');
    }

    $cases = 0;
    foreach ([false, true] as $streaming) foreach ([false, true] as $mixed) foreach ([10, 11, 20, 40] as $count) {
        largeReset('success');
        ['result' => $result, 'deltas' => $deltas, 'events' => $events] = largeRun(largeFiles($count, $mixed), $streaming);
        largeExpect(!empty($result['ok']) && count($result['items']) === $count && $result['submitted_attachment_count'] === $count,
            '10/11/20/40 image/mixed sources must all remain accounted for');
        $expectedCalls = $count <= 10 ? 1 : (int) ceil($count / 10) + 1;
        largeExpect(count($largeRequests) === $expectedCalls, 'use configured cap and at most one final synthesis');
        foreach ($largeRequests as $request) largeExpect(count($request['ids']) <= 10
            && $request['payload']['user'] === 'same-synthetic-user', 'same app/user and cap throughout pipeline');
        if ($count > 10) {
            $final = $largeRequests[count($largeRequests) - 1]['payload'];
            largeExpect(str_starts_with($final['query'], 'COMPLETE_ORIGINAL_CASE_AND_OUTPUT_SCHEMA')
                && $final['inputs'] === ['full_original_inputs' => 'COMPLETE_ORIGINAL_CASE_AND_OUTPUT_SCHEMA']
                && ($final['files'] ?? []) === [], 'final task preserves complete original text/schema/inputs and truthfully uses extracted evidence');
            foreach (range(1, $count) as $id) largeExpect(largeHasObservation($final['query'], $id), 'every source observation survives final query');
            largeExpect($result['attachment_batch_count'] === (int) ceil($count / 10), 'receipt exposes actual extraction attempts');
        }
        if ($streaming) largeExpect($deltas === ['SYNTHETIC_FINAL_ANSWER'], 'private extraction text never reaches clinical answer');
        largeSafe($result, $events); $cases++;
    }

    foreach ([false, true] as $streaming) foreach (['provider-cap-three', 'reject-documents', 'missing'] as $scenario) {
        largeReset($scenario);
        if ($scenario === 'missing') $largeMissing = [2, 17, 39];
        ['result' => $result, 'deltas' => $deltas, 'events' => $events] = largeRun(largeFiles(40, true), $streaming);
        largeExpect(!empty($result['ok']) && count($result['items']) === 40, 'known source gaps must not erase full task or its complete manifest');
        $rejected = $scenario === 'reject-documents' ? 8 : 0;
        $missing = $scenario === 'missing' ? 3 : 0;
        largeExpect($result['submitted_attachment_count'] === 40 - $rejected - $missing
            && $result['rejected_attachment_count'] === $rejected && $result['skipped_attachment_count'] === $missing,
            'accepted, rejected and missing sources partition original forty sources');
        $final = $largeRequests[count($largeRequests) - 1]['payload']['query'];
        foreach ($result['items'] as $index => $item) {
            $id = $index + 1;
            if ($item['status'] === 'submitted') largeExpect(largeHasObservation($final, $id), 'available source evidence reaches final synthesis');
            else largeExpect(largeHasGap($final, $id), 'every known unread source is covered by explicit compact source-range gaps');
        }
        largeExpect(count($largeRequests) <= 80, 'bisection stays below binary-tree source bound plus synthesis');
        if ($streaming) largeExpect($deltas === ['SYNTHETIC_FINAL_ANSWER'], 'failed child batch content is never displayed');
        largeSafe($result, $events); $cases++;
    }

    foreach ([false, true] as $streaming) foreach (['auth', 'quota', 'server', 'ambiguous', 'network'] as $scenario) {
        largeReset($scenario);
        ['result' => $result, 'deltas' => $deltas, 'events' => $events] = largeRun(largeFiles(40), $streaming);
        largeExpect(empty($result['ok']) && count($largeRequests) === 2 && count($result['items']) === 40,
            'unclassified second-batch failure stops entire task and preserves complete source manifest');
        largeExpect(!array_filter($largeRequests, static fn (array $request): bool => $request['synthesis']),
            'unknown/auth/network faults must not silently become permission to drop sources and synthesize');
        largeExpect(count(array_filter($result['items'], static fn (array $item): bool => $item['status'] === 'prepared')) >= 20,
            'sources never attempted after failure remain unsubmitted');
        largeExpect($deltas === [] && !isset($result['attachment_gaps']),
            'early whole-task failure has no fabricated final answer or completed gap synthesis');
        largeSafe($result, $events); $cases++;
    }

    foreach ([false, true] as $streaming) foreach (['extraction-deadline', 'synthesis-deadline'] as $scenario) {
        largeReset($scenario);
        ['result' => $result, 'deltas' => $deltas, 'events' => $events] = largeRun(largeFiles(40), $streaming);
        largeExpect(empty($result['ok']) && $result['error_code'] === 'UPSTREAM_TIMEOUT', 'whole shared 90-second budget also constrains final synthesis');
        $expected = $scenario === 'extraction-deadline' ? 3 : 5;
        largeExpect(count($largeRequests) === $expected
            && ($streaming ? abs($largeTimeoutClock - 1090.0) < 0.01 && $largeClock <= 1092.51
                : abs($largeClock - 1090.0) < 0.01),
            'later batches share ninety seconds of generation; only bounded stop/terminal draining may follow');
        largeExpect($largeRequests[count($largeRequests) - 1]['limitMs']
            <= ($scenario === 'extraction-deadline' ? 28000 : 10000) + ($streaming ? 2500 : 0),
            'curl cap is the remaining aggregate generation budget plus streaming cleanup, never a fresh budget');
        largeExpect($deltas === [], 'no extracted intermediate evidence is promoted to partial clinical answer on timeout');
        largeSafe($result, $events); $cases++;
    }

    largeReset('cancel-second');
    ['result' => $result, 'deltas' => $deltas, 'events' => $events, 'tasks' => $tasks] = largeRun(largeFiles(40), true);
    largeExpect(empty($result['ok']) && $result['error_code'] === 'AI_ASSISTANT_CANCELLED'
        && count($largeRequests) === 2 && $deltas === [] && $tasks !== [], 'stop during child extraction prevents every later extraction/synthesis and preserves real task IDs');
    largeSafe($result, $events); $cases++;

    foreach ([false, true] as $streaming) {
        largeReset('context-limit');
        ['result' => $result, 'deltas' => $deltas, 'events' => $events] = largeRun(largeFiles(40), $streaming,
            'COMPLETE_ORIGINAL_CASE_' . str_repeat('Long original case. ', 4000));
        $final = $largeRequests[count($largeRequests) - 1];
        largeExpect(!empty($result['ok']) && $final['synthesis'] && strlen($final['payload']['query']) < 120000
            && count($largeRequests) === 5 && $result['submitted_attachment_count'] === 40,
            'lossless repeated-text encoding prevents final context overflow after all forty attachments were extracted');
        foreach (range(1, 40) as $id) largeExpect(largeHasObservation($final['payload']['query'], $id), 'all forty independent observations survive repeated-text encoding');
        largeExpect($result['attachment_gaps'] === [], 'reversible repetition coding does not invent a missing source');
        largeSafe($result, $events); $cases++;
    }

    largeReset('context-unique');
    $GLOBALS['largeConfig']['required_attachment_input_bytes'] = 100000;
    ['result' => $result] = largeRun(largeFiles(40), false);
    $final = $largeRequests[count($largeRequests) - 1]['payload']['query'];
    largeExpect(!empty($result['ok']) && strlen($final) < 120000 && $result['submitted_attachment_count'] === 40
        && count($result['attachment_gaps']) > 0 && str_contains($final, '本轮综合容量不足'),
        'unique oversized evidence becomes explicit per-source synthesis gaps and a bounded answer, never silent truncation or an oversized final request');
    foreach ($result['items'] as $item) largeExpect(($item['status'] ?? '') === 'submitted', 'budget gaps do not rewrite the fact every original source was transmitted');
    largeExpect(largeAddedPayloadBytes($largeRequests[count($largeRequests) - 1]['payload'], 'COMPLETE_ORIGINAL_CASE_AND_OUTPUT_SCHEMA') <= 100000,
        'unique evidence plus its gap metadata obey the actual serialized additional byte budget');
    $cases++;

    foreach ([false, true] as $streaming) {
        largeReset('success');
        ['result' => $result, 'deltas' => $deltas] = largeRun(largeFiles(700), $streaming);
        $final = $largeRequests[count($largeRequests) - 1]['payload'];
        largeExpect(!empty($result['ok']) && count($result['items']) === 700
            && $result['submitted_attachment_count'] === 700 && $result['attachment_gaps'] === []
            && count($largeRequests) === 71, 'seven hundred short observations remain complete without extra inference requests');
        foreach (range(1, 700) as $id) largeExpect(largeHasObservation($final['query'], $id), 'all seven hundred independent source facts fit and survive');
        largeExpect(largeAddedPayloadBytes($final, 'COMPLETE_ORIGINAL_CASE_AND_OUTPUT_SCHEMA') <= 196608,
            'default 192KiB bounds actual serialized additions instead of multiplying per-source fallback prose');
        if ($streaming) largeExpect($deltas === ['SYNTHETIC_FINAL_ANSWER'], 'large source count still emits only final clinical text');
        $cases++;
    }
    largeReset('success');
    $largeConfig['required_attachment_input_bytes'] = 32768;
    $original = 'COMPLETE_ORIGINAL_CASE_' . str_repeat('original "quoted" \\ value' . "\n", 10000);
    ['result' => $result] = largeRun(largeFiles(11), false, $original);
    $final = $largeRequests[count($largeRequests) - 1]['payload'];
    largeExpect(!empty($result['ok']) && str_starts_with($final['query'], $original)
        && $final['inputs'] === ['full_original_inputs' => $original] && $result['attachment_gaps'] === []
        && largeAddedPayloadBytes($final, $original) <= 32768 && count($largeRequests) === 3,
        'a large original query and inputs remain exact; only new serialized attachment evidence is bounded, with no hard failure or extra calls');
    $cases++;

    largeReset('sparse-evidence');
    ['result' => $result] = largeRun(largeFiles(40), false);
    $final = $largeRequests[count($largeRequests) - 1]['payload']['query'];
    largeExpect(!empty($result['ok']) && $result['submitted_attachment_count'] === 40
        && count($result['attachment_gaps']) === 36 && !largeHasObservation($final, 2)
        && $result['items'][1]['evidence_status'] === 'unverified'
        && largeHasGap($final, 2) && str_contains($final, '已提交，但未取得逐来源可核对观察'),
        'a missing observation becomes an explicit source gap without failing the whole known-case answer');
    $cases++;
    echo "Large attachment offline contract: {$cases} scenarios OK (10/11/20/40; mixed documents; known gaps; second-batch faults; 90s budget; stop; context and extraction-completeness risks)\n";
}