<?php

declare(strict_types=1);

namespace app\common\service\prescriptionai;

/**
 * Pure, conservative soft-Dice comparison. No database, configuration or model calls.
 *
 * Catalog contract: trusted server rows {id: positive integer, name: string,
 * aliases?: string[], processing?: string, dictionary_version?: string}.
 * Names (including aliases) must identify exactly one catalog identity. Candidate
 * medicine_id is deliberately ignored; a supplied doctor's ID must match its name.
 *
 * Each herb declares dosage, unit, dose_basis (per_dose/per_day), formula_type
 * (主方/辅方). Explicit prescription-level unit/dose_basis/formula_type may apply
 * to all rows. Only the persisted doctor's 饮片 rows may omit unit/basis (g/per_dose),
 * consistent with the desktop editor's 克 and total = dosage * dose_count contract.
 * The doctor's absent role defaults to 主方 under the same editor contract.
 * Missing and explicit null/empty values are different: null is never a default.
 *
 * Unit spelling aliases are normalized, but there are NO quantity, formulation,
 * per-day/per-dose or extraction-ratio conversions. Changing this requires a new
 * algorithm/configuration version. usage_differences never affect the score.
 */
final class PrescriptionAiComparison
{
    // v1.1.0: the doctor's prescription-level 用量单位/剂量单位 are read as declared values, and a
    // processing label already carried by the medicine name no longer splits one identity.
    public const ALGORITHM_VERSION = 'prescription-soft-dice-v1.1.0';

    private const FORMULATIONS = ['饮片', '颗粒', '浓缩水丸', '丸剂', '散剂', '膏方', '汤剂'];

    private const USAGE_FIELDS = [
        'dose_count', 'usage_days', 'times_per_day', 'dosage_amount', 'dosage_unit',
        'dosage_bag_count', 'usage_instruction', 'usage_time', 'usage_way', 'aux_usage',
    ];

    private const ROW_USAGE_FIELDS = [
        'usage_instruction', 'decoction_instruction', 'special_usage', 'usage_time', 'usage_way', 'instructions',
    ];

    public static function compare(array $doctor, array $candidate, array $catalog = []): array
    {
        $dictionary = self::buildDictionary($catalog);
        $doctorResult = self::normalize($doctor, 'doctor', $dictionary);
        $candidateResult = self::normalize($candidate, 'candidate', $dictionary);
        $issues = array_merge($doctorResult['issues'], $candidateResult['issues']);
        $usageDifferences = self::usageDifferences($doctor, $candidate);

        if ($doctorResult['formulation'] !== $candidateResult['formulation']) {
            $issues[] = self::issue('both', null, 'formulation_mismatch', '剂型不同，未提供经确认的换算规则');
        }
        $allBases = array_unique(array_merge($doctorResult['bases'], $candidateResult['bases']));
        if (count($allBases) > 1) {
            $issues[] = self::issue('both', null, 'dose_basis_mismatch', '剂量基准不同，不能按每剂与每日直接比较');
        }

        $doctorItems = $doctorResult['items'];
        $candidateItems = $candidateResult['items'];
        $keys = array_values(array_unique(array_merge(array_keys($doctorItems), array_keys($candidateItems))));
        sort($keys, SORT_STRING);
        $rows = [];
        $matchedCount = 0;
        $contribution = 0.0;
        foreach ($keys as $key) {
            $left = $doctorItems[$key] ?? null;
            $right = $candidateItems[$key] ?? null;
            $identity = $left ?? $right;
            $ratio = null;
            if ($left !== null && $right !== null) {
                $matchedCount++;
                if ($left['unit'] !== $right['unit']) {
                    $issues[] = self::issue('both', null, 'unit_mismatch', $identity['name'] . '的剂量单位不同，未执行单位换算');
                } elseif ($left['dosage'] !== null && $right['dosage'] !== null
                    && $left['dose_basis'] === $right['dose_basis']) {
                    $ratio = min($left['dosage'], $right['dosage']) / max($left['dosage'], $right['dosage']);
                    $contribution += $ratio;
                }
                if ($left['usage'] !== $right['usage']) {
                    $usageDifferences[] = [
                        'field' => 'herb_usage', 'key' => $key, 'name' => $identity['name'],
                        'doctor' => $left['usage'], 'candidate' => $right['usage'],
                    ];
                }
                if ($left['declared_processing'] !== $right['declared_processing']) {
                    $usageDifferences[] = [
                        'field' => 'herb_processing_label', 'key' => $key, 'name' => $identity['name'],
                        'doctor' => $left['declared_processing'], 'candidate' => $right['declared_processing'],
                    ];
                }
            }
            $rows[] = [
                'key' => $key,
                'medicine_id' => $identity['medicine_id'],
                'name' => $identity['name'],
                'processing' => $identity['processing'],
                'formula_type' => $identity['formula_type'],
                'administration_route' => $identity['administration_route'],
                'group' => $identity['group'],
                'doctor' => $left,
                'candidate' => $right,
                'doctor_dosage' => $left['dosage'] ?? null,
                'candidate_dosage' => $right['dosage'] ?? null,
                'unit' => $identity['unit'],
                'dose_basis' => $identity['dose_basis'],
                'match_type' => $left === null ? 'candidate_only' : ($right === null ? 'doctor_only' : 'matched'),
                'contribution' => $ratio,
            ];
        }

        $denominator = count($doctorItems) + count($candidateItems);
        $identityComplete = $doctorResult['identity_complete'] && $candidateResult['identity_complete'];
        $herbScore = $identityComplete && $denominator > 0
            && $doctorItems !== [] && $candidateItems !== []
            ? 100.0 * 2.0 * $matchedCount / $denominator : null;
        $comparable = $issues === [];
        if (!$comparable) {
            // Partial row ratios must never look like a complete, usable score.
            foreach ($rows as &$row) {
                $row['contribution'] = null;
            }
            unset($row);
        }

        return [
            'status' => $comparable ? 'comparable' : 'not_comparable',
            'score' => $comparable ? min(100.0, max(0.0, 100.0 * 2.0 * $contribution / $denominator)) : null,
            'herb_score' => $herbScore,
            'reason_code' => $comparable ? 'ok' : $issues[0]['code'],
            'reason' => $comparable ? '药味与剂量可比；服法、疗程与风险须独立复核' : $issues[0]['reason'],
            'algorithm_version' => self::ALGORITHM_VERSION,
            'doctor_count' => count($doctorItems),
            'candidate_count' => count($candidateItems),
            'matched_count' => $matchedCount,
            'rows' => $rows,
            'usage_differences' => $usageDifferences,
            'normalization' => [
                'doctor' => $doctorResult,
                'candidate' => $candidateResult,
                'issues' => $issues,
                'dictionary_hash' => $dictionary['hash'],
                'dictionary_versions' => $dictionary['versions'],
                'unit_policy' => 'spelling_aliases_only_no_quantity_conversion',
                'denominator' => $denominator,
                'matched_contribution_sum' => $comparable ? $contribution : null,
            ],
        ];
    }

    private static function normalize(array $prescription, string $side, array $dictionary): array
    {
        $result = [
            'formulation' => self::formulation($prescription['prescription_type'] ?? null),
            'items' => [], 'bases' => [], 'issues' => [], 'merges' => [],
            'defaults' => [], 'identity_complete' => true, 'raw_herb_count' => 0,
        ];
        $status = self::text($prescription['status'] ?? null);
        $blockedStatuses = [
            'insufficient_data' => '资料不足，未形成可比候选方案',
            'withheld_for_risk' => '因风险暂缓提供用药方案',
            'no_medication' => '明确建议暂不使用药物，须单列用药决策差异',
            'no_medication_recommended' => '明确建议暂不使用药物，须单列用药决策差异',
            'failed' => '模型生成失败', 'error' => '模型生成失败',
        ];
        if (isset($blockedStatuses[$status])) {
            $result['issues'][] = self::issue($side, null, $status, $blockedStatuses[$status]);
        }
        if (!in_array($result['formulation'], self::FORMULATIONS, true)) {
            $result['issues'][] = self::issue($side, null, 'unknown_formulation', '剂型缺失或不受支持');
        }
        $herbs = $prescription['herbs'] ?? null;
        if (!is_array($herbs) || $herbs === []) {
            $result['issues'][] = self::issue($side, null, 'empty_prescription', '处方为空或药味结构无效');
            $result['identity_complete'] = false;
            return $result;
        }
        $result['raw_herb_count'] = count($herbs);
        if ($dictionary['names'] === []) {
            $result['issues'][] = self::issue($side, null, 'catalog_unavailable', '缺少可用的服务端药材字典');
        }

        foreach (array_values($herbs) as $index => $herb) {
            if (!is_array($herb)) {
                $result['issues'][] = self::issue($side, $index, 'invalid_herb', '药味必须为结构化对象');
                $result['identity_complete'] = false;
                continue;
            }
            $name = self::text($herb['name'] ?? null);
            $identities = $dictionary['names'][$name] ?? [];
            if ($name === '' || count($identities) !== 1) {
                $code = count($identities) > 1 ? 'ambiguous_herb_name' : 'unknown_herb_name';
                $result['issues'][] = self::issue($side, $index, $code, '药名“' . $name . '”无法唯一映射服务端字典');
                $result['identity_complete'] = false;
                continue;
            }
            $entry = $dictionary['entries'][array_key_first($identities)];
            if ($side === 'doctor' && array_key_exists('medicine_id', $herb)
                && self::positiveId($herb['medicine_id']) !== $entry['id']) {
                $result['issues'][] = self::issue($side, $index, 'doctor_identity_mismatch', '医生药材 ID 与规范药名不一致');
                $result['identity_complete'] = false;
                continue;
            }
            $processing = array_key_exists('processing', $herb) ? self::text($herb['processing']) : $entry['processing'];
            if (in_array(strtolower($processing), ['无', '明确无', '无额外炮制', 'none'], true)) {
                $processing = '';
            }
            if ((array_key_exists('processing', $herb) && !is_string($herb['processing']))
                || in_array(strtolower($processing), ['未知', '不详', 'unknown'], true)
                || ($entry['processing'] !== '' && $processing !== $entry['processing'])) {
                $result['issues'][] = self::issue($side, $index, 'processing_conflict', '炮制信息与药材字典冲突或无效');
                $result['identity_complete'] = false;
                continue;
            }
            $roleValue = self::declaredValue($herb, $prescription, 'formula_type');
            if (!$roleValue['present'] && $side === 'doctor') {
                $roleValue['value'] = '主方';
                $result['defaults'][] = ['row' => $index, 'field' => 'formula_type', 'value' => '主方'];
            }
            $role = self::role($roleValue['value']);
            $route = self::text($herb['administration_route'] ?? '');
            $group = self::text($herb['group'] ?? '');
            if ($role === '' || (array_key_exists('administration_route', $herb) && !is_string($herb['administration_route']))
                || (array_key_exists('group', $herb) && !is_string($herb['group']))) {
                $result['issues'][] = self::issue($side, $index, 'ambiguous_herb_role', '主辅方、给药路径或分组语义不明确');
                $result['identity_complete'] = false;
                continue;
            }
            $unitValue = self::declaredValue($herb, $prescription, 'unit');
            $basisValue = self::declaredValue($herb, $prescription, 'dose_basis');
            if ($side === 'doctor') {
                // The workstation stores the per-herb unit once as the prescription's 用量单位
                // (dosage_unit) and declares the dose basis through 剂量单位=剂/付. Both are the
                // doctor's own explicit values; nothing is guessed when they are absent.
                $declaredUnit = self::unit($prescription['dosage_unit'] ?? null);
                $perDose = in_array(self::text($prescription['dose_unit'] ?? null), ['剂', '付'], true);
                $fallbacks = [];
                if ($declaredUnit !== '') {
                    $fallbacks['unit'] = $declaredUnit;
                } elseif ($result['formulation'] === '饮片') {
                    $fallbacks['unit'] = 'g';
                }
                if ($perDose || $result['formulation'] === '饮片') {
                    $fallbacks['dose_basis'] = 'per_dose';
                }
                foreach ($fallbacks as $field => $default) {
                    $value = $field === 'unit' ? $unitValue : $basisValue;
                    if (!$value['present']) {
                        $result['defaults'][] = ['row' => $index, 'field' => $field, 'value' => $default];
                        if ($field === 'unit') {
                            $unitValue['value'] = $default;
                        } else {
                            $basisValue['value'] = $default;
                        }
                    }
                }
            }
            $unit = self::unit($unitValue['value']);
            $basis = self::basis($basisValue['value']);
            if ($unit === '') {
                $result['issues'][] = self::issue($side, $index, 'missing_or_unknown_unit', '剂量单位缺失或不受支持');
            }
            if ($basis === '') {
                $result['issues'][] = self::issue($side, $index, 'missing_or_unknown_dose_basis', '须明确每剂或每日剂量基准');
            } else {
                $result['bases'][] = $basis;
            }
            $dosage = self::positiveNumber($herb['dosage'] ?? null);
            if ($dosage === null) {
                $result['issues'][] = self::issue($side, $index, 'invalid_dosage', '剂量必须为有限、明确且大于零的数值');
            }
            $usage = [];
            foreach (self::ROW_USAGE_FIELDS as $field) {
                $value = $herb[$field] ?? '';
                if (!is_string($value)) {
                    $result['issues'][] = self::issue($side, $index, 'invalid_herb_usage', '药味煎服说明必须为文本');
                }
                $usage[$field] = in_array(strtolower(self::text($value)), ['无', '明确无', 'none'], true) ? '' : self::text($value);
            }
            // Identity processing comes from the dictionary. When the institution already encodes
            // the processed form in the medicine name (醋五味子 + "醋制", 麸炒白术 + "麸炒"), the
            // written processing only restates the name: it is kept for display and difference
            // reporting but must not split one medicine into two rows. A processing that the name
            // does not carry (黄芪 + "蜜炙") stays a distinct medication item.
            $identityProcessing = $entry['processing'] !== '' || !self::restatesName($processing, $entry['name'])
                ? $processing : '';
            $key = json_encode([$entry['id'], $identityProcessing, $role, $route, $group], JSON_UNESCAPED_UNICODE | JSON_THROW_ON_ERROR);
            $normalized = [
                'medicine_id' => $entry['id'], 'name' => $entry['name'], 'processing' => $identityProcessing,
                'declared_processing' => $processing,
                'formula_type' => $role, 'administration_route' => $route, 'group' => $group,
                'dosage' => $dosage, 'unit' => $unit, 'dose_basis' => $basis, 'usage' => $usage,
                'source_rows' => [$index], 'source_names' => [$name],
                'original_dosages' => [self::auditNumber($herb['dosage'] ?? null)],
            ];
            if (isset($result['items'][$key])) {
                $prior = $result['items'][$key];
                if ($prior['unit'] !== $unit || $prior['dose_basis'] !== $basis || $prior['usage'] !== $usage
                    || $prior['declared_processing'] !== $processing) {
                    $result['issues'][] = self::issue($side, $index, 'duplicate_semantics_conflict', '同药项重复行的单位、基准或煎服语义不一致，不能合并');
                    $result['identity_complete'] = false;
                    continue;
                }
                $merged = $prior['dosage'] === null || $dosage === null ? null : $prior['dosage'] + $dosage;
                if ($merged !== null && !is_finite($merged)) {
                    $result['issues'][] = self::issue($side, $index, 'invalid_dosage', '重复药项合并后剂量不是有限数值');
                    $merged = null;
                }
                $normalized['dosage'] = $merged;
                foreach (['source_rows', 'source_names', 'original_dosages'] as $field) {
                    $normalized[$field] = array_merge($prior[$field], $normalized[$field]);
                }
                $result['merges'][] = ['key' => $key, 'source_rows' => $normalized['source_rows'], 'dosage' => $merged];
            }
            $result['items'][$key] = $normalized;
        }
        $result['bases'] = array_values(array_unique($result['bases']));
        return $result;
    }

    private static function buildDictionary(array $catalog): array
    {
        $result = ['entries' => [], 'names' => [], 'versions' => []];
        foreach ($catalog as $row) {
            if (!is_array($row)) {
                continue;
            }
            $id = self::positiveId($row['id'] ?? null);
            $name = self::text($row['name'] ?? null);
            if ($id === null || $name === '') {
                continue;
            }
            $processing = self::text($row['processing'] ?? '');
            $entryKey = json_encode([$id, $name, $processing], JSON_UNESCAPED_UNICODE | JSON_THROW_ON_ERROR);
            $result['entries'][$entryKey] = ['id' => $id, 'name' => $name, 'processing' => $processing];
            $aliases = isset($row['aliases']) && is_array($row['aliases']) ? $row['aliases'] : [];
            foreach (array_merge([$name], $aliases) as $alias) {
                $alias = self::text($alias);
                if ($alias !== '') {
                    $result['names'][$alias][$entryKey] = true;
                }
            }
            $version = self::text($row['dictionary_version'] ?? '');
            if ($version !== '') {
                $result['versions'][] = $version;
            }
        }
        // A reused ID with different canonical identities is corrupt even when the
        // names themselves differ: matching by the resulting ID would forge overlap.
        $ids = [];
        foreach ($result['entries'] as $entryKey => $entry) {
            $ids[$entry['id']][$entryKey] = true;
        }
        foreach ($result['names'] as &$identities) {
            foreach (array_keys($identities) as $entryKey) {
                $identities += $ids[$result['entries'][$entryKey]['id']];
            }
            ksort($identities, SORT_STRING);
        }
        unset($identities);
        ksort($result['entries'], SORT_STRING);
        ksort($result['names'], SORT_STRING);
        $result['versions'] = array_values(array_unique($result['versions']));
        sort($result['versions'], SORT_STRING);
        $result['hash'] = hash('sha256', json_encode($result, JSON_UNESCAPED_UNICODE | JSON_THROW_ON_ERROR));
        return $result;
    }

    private static function declaredValue(array $row, array $prescription, string $field): array
    {
        if (array_key_exists($field, $row)) {
            return ['present' => true, 'value' => $row[$field]];
        }
        return ['present' => array_key_exists($field, $prescription), 'value' => $prescription[$field] ?? null];
    }

    private static function role($value): string
    {
        $roles = ['主方' => '主方', 'main' => '主方', 'primary' => '主方', '1' => '主方',
            '辅方' => '辅方', 'aux' => '辅方', 'auxiliary' => '辅方', 'secondary' => '辅方', '2' => '辅方'];
        return $roles[self::text($value)] ?? '';
    }

    /** True when every character of a processing label already appears in the medicine name. */
    private static function restatesName(string $processing, string $name): bool
    {
        $label = str_replace(['制', '品', '法', '的'], '', self::text($processing));
        if ($label === '' || $name === '') {
            return false;
        }
        foreach (preg_split('//u', $label, -1, PREG_SPLIT_NO_EMPTY) ?: [] as $character) {
            if (mb_strpos($name, $character) === false) {
                return false;
            }
        }
        return true;
    }

    /**
     * Spelling aliases only. Different dosage forms are never merged: 颗粒 and 浓缩水丸 stay
     * distinct, and no quantity or extraction-ratio conversion is implied.
     */
    private static function formulation($value): string
    {
        $text = self::text($value);
        $aliases = ['中药饮片' => '饮片', '草药' => '饮片', '中药配方颗粒' => '颗粒', '配方颗粒' => '颗粒',
            '免煎颗粒' => '颗粒', '中药颗粒' => '颗粒', '汤药' => '汤剂', '中药汤剂' => '汤剂'];
        return $aliases[$text] ?? $text;
    }

    private static function unit($value): string
    {
        $units = ['g' => 'g', '克' => 'g', 'mg' => 'mg', '毫克' => 'mg', 'kg' => 'kg', '千克' => 'kg',
            'ml' => 'ml', '毫升' => 'ml', '片' => '片', '粒' => '粒', '丸' => '丸', '袋' => '袋'];
        return $units[strtolower(self::text($value))] ?? '';
    }

    private static function basis($value): string
    {
        $bases = ['per_dose' => 'per_dose', '每剂' => 'per_dose', 'per_day' => 'per_day', '每日' => 'per_day'];
        return $bases[self::text($value)] ?? '';
    }

    private static function text($value): string
    {
        if (!is_string($value) || preg_match('//u', $value) !== 1) {
            return '';
        }
        return preg_replace('/^[\s\x{3000}]+|[\s\x{3000}]+$/u', '', $value) ?? '';
    }

    private static function positiveId($value): ?int
    {
        if ((!is_int($value) && !is_string($value)) || !preg_match('/^[1-9][0-9]*$/D', (string) $value)) {
            return null;
        }
        $id = filter_var($value, FILTER_VALIDATE_INT, ['options' => ['min_range' => 1]]);
        return $id === false ? null : $id;
    }

    private static function positiveNumber($value): ?float
    {
        if ((!is_int($value) && !is_float($value) && !is_string($value)) || !is_numeric($value)) {
            return null;
        }
        $number = (float) $value;
        return is_finite($number) && $number > 0.0 ? $number : null;
    }

    private static function auditNumber($value)
    {
        if (is_float($value) && !is_finite($value)) {
            return is_nan($value) ? 'NaN' : ($value > 0 ? 'Infinity' : '-Infinity');
        }
        return is_scalar($value) || $value === null ? $value : '[invalid non-scalar]';
    }

    private static function issue(string $side, ?int $row, string $code, string $reason): array
    {
        return ['side' => $side, 'row' => $row, 'code' => $code, 'reason' => $reason];
    }

    private static function usageDifferences(array $doctor, array $candidate): array
    {
        $doctor = self::usageView($doctor);
        $candidate = self::usageView($candidate);
        $differences = [];
        foreach (self::USAGE_FIELDS as $field) {
            $left = $doctor[$field] ?? null;
            $right = $candidate[$field] ?? null;
            if (self::stableValue($left) !== self::stableValue($right)) {
                $differences[] = ['field' => $field, 'doctor' => $left, 'candidate' => $right];
            }
        }
        return $differences;
    }

    /**
     * Display-only: a side that states one unanimous per-herb unit also states it as the
     * prescription's 用量单位. Never used for identity, dosage or scoring.
     */
    private static function usageView(array $prescription): array
    {
        if (self::text($prescription['dosage_unit'] ?? null) !== '' || !is_array($prescription['herbs'] ?? null)) {
            return $prescription;
        }
        $units = [];
        foreach ($prescription['herbs'] as $herb) {
            $units[] = is_array($herb) ? self::unit($herb['unit'] ?? null) : '';
        }
        $units = array_values(array_unique($units));
        if (count($units) === 1 && $units[0] !== '') {
            $prescription['dosage_unit'] = $units[0];
        }
        return $prescription;
    }

    private static function stableValue($value)
    {
        if (is_array($value)) {
            ksort($value);
            return array_map([self::class, 'stableValue'], $value);
        }
        if (is_string($value)) {
            $value = self::text($value);
        }
        // Database numeric strings and the same JSON number are equivalent usage.
        if ((is_string($value) || is_int($value) || is_float($value)) && is_numeric($value)) {
            return self::auditNumber((float) $value);
        }
        return $value;
    }
}