server.py

#!/usr/bin/env python3
"""知产管家 · IP Keeper — 本地服务器"""
import os, json, sqlite3, mimetypes, math, zipfile, re, shutil, uuid, threading, calendar, unicodedata, subprocess, tempfile
import hashlib
from difflib import SequenceMatcher
from rules.dates import (_to_date, _add_years, _add_months, _month_end)
from rules.common import (_as_bool, norm_patent_type)
from rules.versions import (RULESET_VERSION, CNIPA_PATENT_LAW_URL, CNIPA_OA_URL, CNIPA_FEE_REDUCTION_URL, CNIPA_TM_2026_URL, PATENT_FEE_RULE_VERSION, LEGAL_RULE_VERSIONS)
from rules.cn_patent_term import (DESIGN_TERM_CHANGE_DATE, patent_term_years)
from rules.cn_patent_fee import (FEE_TABLE, FEE_REDUCTION_YEARS, FEE_SINGLE_OWNER_RATIO, FEE_MULTIPLE_OWNER_RATIO, annual_fee_late_rate, patent_owner_count, normalize_fee_reduction_status, resolve_fee_reduction_ratio, patent_grant_fee_year, calculate_cn_annual_fee)
from rules.cn_deadline import (calculate_legal_deadline)
from contextlib import nullcontext
from ipkeeper_alert_center import SCHEMA as ALERT_CENTER_SCHEMA, register as register_alert_center
from datetime import datetime, date, timedelta
from pathlib import Path
from io import BytesIO
from flask import Flask, request, jsonify, send_file, send_from_directory
from ipkeeper_attachment_utils import build_duplicate_groups, file_sha256
from ipkeeper_backup_utils import (
    BackupValidationError,
    create_backup_archive,
    database_is_valid as backup_database_is_valid,
    directory_summary,
    extract_and_validate_backup,
)

CODE_DIR   = Path(__file__).parent.resolve()
BASE_DIR   = CODE_DIR
DB_PATH    = BASE_DIR / "ipkeeper.db"
UPLOAD_DIR = BASE_DIR / "uploads"
STATIC_DIR = CODE_DIR / "static"
DEFAULT_WATCH_DIR = BASE_DIR / "待关联"
UPLOAD_DIR.mkdir(parents=True, exist_ok=True)
DEFAULT_WATCH_DIR.mkdir(parents=True, exist_ok=True)

# ── 启动诊断 ────────────────────────────────────────────────
print(f"ℹ️  BASE_DIR   = {BASE_DIR}")
print(f"ℹ️  STATIC_DIR = {STATIC_DIR}")
print(f"ℹ️  index.html 存在: {(STATIC_DIR/'index.html').exists()}")
if not (STATIC_DIR/'index.html').exists():
    print(f"❌  错误：static/index.html 不存在！")
    print(f"   请确保解压后的所有文件在同一个目录")

app = Flask(__name__, static_folder=str(STATIC_DIR))
app.config['MAX_CONTENT_LENGTH'] = int(
    os.environ.get('IPKEEPER_MAX_UPLOAD_BYTES', str(2 * 1024 * 1024 * 1024))
)

WEB_PORT = int(os.environ.get('IPKEEPER_PORT', '5678'))
APP_VERSION = 'web'
BACKUP_OPERATION_LOCK = threading.Lock()
BACKUP_STATUS_LOCK = threading.Lock()
BACKUP_STATUS = {
    'active': False,
    'kind': '',
    'phase': 'idle',
    'sequence': 0,
    'error': '',
}
AUTO_BACKUP_STARTED = False
MAINTENANCE_MODE = False
# File analysis is relatively expensive (especially OCR).  Cache watch-folder
# analysis by absolute path + mtime + size so refreshing the watch view does not
# repeatedly re-read unchanged files.  The cache is intentionally process-local;
# changing or replacing a file invalidates its key automatically.
WATCH_ANALYSIS_CACHE = {}
WATCH_ANALYSIS_CACHE_LIMIT = 512

ALLOWED_EXT = {'.pdf','.png','.jpg','.jpeg','.docx','.doc','.xlsx','.xls',
               '.zip','.rar','.txt','.ofd','.msg','.eml'}

USPTO_MAINTENANCE_URL = 'https://www.uspto.gov/patents/maintain'
EPO_UNITARY_RENEWAL_URL = 'https://www.epo.org/en/legal/guidelines-up/2026/section_3_7'


def _clean_filename(name):
    base = Path(name or "attachment").name
    cleaned = "".join(c for c in base if c.isalnum() or c in "._-")
    return cleaned or "attachment"


def _doc_mime(name):
    return mimetypes.guess_type(name or "")[0] or "application/octet-stream"


def _safe_document_filename(item_type, item_id, original_name):
    ext = Path(original_name or "").suffix.lower()
    ts = datetime.now().strftime("%Y%m%d_%H%M%S_%f")
    stem = Path(_clean_filename(original_name)).stem[:80] or "attachment"
    return f"{item_type}_{item_id}_{ts}_{uuid.uuid4().hex[:8]}_{stem}{ext}"


def _find_reusable_document_file(db, digest, size):
    if not digest or not size:
        return None
    rows = db.execute("""
        SELECT filename, mime_type
        FROM documents
        WHERE file_hash=? AND file_size=?
        ORDER BY id DESC
    """, (digest, size)).fetchall()
    for row in rows:
        filename = row["filename"]
        if filename and (UPLOAD_DIR / filename).exists():
            return dict(row)
    return None


def _store_document_source(db, source_path, original_name, item_type, item_id, move=False):
    """Store one physical file, reusing identical content when possible."""
    source_path = Path(source_path)
    size = source_path.stat().st_size
    digest = file_sha256(source_path)
    mime = _doc_mime(original_name)
    existing = _find_reusable_document_file(db, digest, size)
    if existing:
        if move:
            try:
                source_path.unlink(missing_ok=True)
            except Exception:
                pass
        return {
            "filename": existing["filename"],
            "file_size": size,
            "mime_type": existing.get("mime_type") or mime,
            "file_hash": digest,
            "reused": True,
            "path": UPLOAD_DIR / existing["filename"],
        }

    safe = _safe_document_filename(item_type, item_id, original_name)
    dest = UPLOAD_DIR / safe
    if move:
        shutil.move(str(source_path), str(dest))
    else:
        shutil.copy2(source_path, dest)
    return {
        "filename": safe,
        "file_size": dest.stat().st_size,
        "mime_type": mime,
        "file_hash": digest,
        "reused": False,
        "path": dest,
    }


def _ensure_document_hashes(db, limit=0):
    sql = """
        SELECT id, filename, file_size
        FROM documents
        WHERE COALESCE(file_hash, '')=''
        ORDER BY id
    """
    if limit:
        sql += f" LIMIT {int(limit)}"
    changed = 0
    for row in db.execute(sql).fetchall():
        path = UPLOAD_DIR / row["filename"]
        if not path.exists() or not path.is_file():
            continue
        try:
            size = path.stat().st_size
            db.execute(
                "UPDATE documents SET file_hash=?, file_size=COALESCE(file_size, ?) WHERE id=?",
                (file_sha256(path), size, row["id"]),
            )
            changed += 1
        except Exception:
            continue
    return changed


def _unlink_if_unreferenced(db, filename):
    if not filename:
        return False
    row = db.execute("SELECT COUNT(*) AS c FROM documents WHERE filename=?", (filename,)).fetchone()
    if row and row["c"]:
        return False
    try:
        (UPLOAD_DIR / filename).unlink(missing_ok=True)
        return True
    except Exception:
        return False


TRASH_TYPE_LABELS = {
    'patent': '专利',
    'trademark': '商标',
    'copyright': '软著',
    'document': '附件',
    'fee_payment': '年费记录',
    'status_history': '状态记录',
    'trademark_logo': '商标图',
    'fee_receipt': '缴费凭证',
}


def _trash_add(db, item_type, item_id, name, payload):
    """Store a complete recoverable snapshot. Recycle-bin rows are never auto-purged."""
    cur = db.execute(
        """INSERT INTO recycle_bin(item_type,item_id,name,payload,deleted_at)
           VALUES(?,?,?,?,?)""",
        (item_type, item_id, name or TRASH_TYPE_LABELS.get(item_type, '已删除数据'),
         json.dumps(payload, ensure_ascii=False), now_str()),
    )
    return cur.lastrowid


def _rows_as_dicts(db, sql, params=()):
    return [dict(row) for row in db.execute(sql, params).fetchall()]


def _insert_snapshot_row(db, table, row, replace_id=None, preserve_id=True):
    allowed = {
        'patents', 'trademarks', 'copyrights', 'documents',
        'status_history', 'fee_payments', 'data_health_marks',
        'legal_events',
    }
    if table not in allowed or not isinstance(row, dict) or not row:
        raise ValueError('无效的恢复数据')
    restored = dict(row)
    if replace_id is not None and 'id' in restored:
        restored['id'] = replace_id
    if not preserve_id:
        restored.pop('id', None)
    columns = list(restored)
    placeholders = ','.join('?' for _ in columns)
    cur = db.execute(
        f"INSERT INTO {table} ({','.join(columns)}) VALUES ({placeholders})",
        [restored[column] for column in columns],
    )
    return restored.get('id') if preserve_id else cur.lastrowid


def _trash_payload_filenames(payload):
    names = set()
    if not isinstance(payload, dict):
        return names
    for doc in payload.get('documents', []):
        if isinstance(doc, dict) and doc.get('filename'):
            names.add(doc['filename'])
    record = payload.get('record') or {}
    if isinstance(record, dict):
        for key in ('filename', 'receipt_filename', 'logo_filename'):
            if record.get(key):
                names.add(record[key])
    for payment in payload.get('fee_payments', []):
        if isinstance(payment, dict) and payment.get('receipt_filename'):
            names.add(payment['receipt_filename'])
    if payload.get('logo_filename'):
        names.add(payload['logo_filename'])
    if payload.get('receipt_filename'):
        names.add(payload['receipt_filename'])
    return names


def _file_is_referenced(db, filename, excluding_trash_id=None):
    if not filename:
        return False
    if db.execute("SELECT 1 FROM documents WHERE filename=? LIMIT 1", (filename,)).fetchone():
        return True
    if db.execute("SELECT 1 FROM fee_payments WHERE receipt_filename=? LIMIT 1", (filename,)).fetchone():
        return True
    if db.execute("SELECT 1 FROM trademarks WHERE logo_filename=? LIMIT 1", (filename,)).fetchone():
        return True
    sql = "SELECT id,payload FROM recycle_bin"
    params = []
    if excluding_trash_id is not None:
        sql += " WHERE id<>?"
        params.append(excluding_trash_id)
    for row in db.execute(sql, params).fetchall():
        try:
            if filename in _trash_payload_filenames(json.loads(row['payload'])):
                return True
        except Exception:
            continue
    return False


def _delete_document_rows(db, ids):
    """Move attachment rows to the recycle bin without removing physical files."""
    ids = [int(x) for x in ids if str(x).strip()]
    if not ids:
        return {"deleted": 0, "files_removed": 0}
    placeholders = ",".join("?" * len(ids))
    rows = db.execute(f"SELECT * FROM documents WHERE id IN ({placeholders})", ids).fetchall()
    if not rows:
        return {"deleted": 0, "files_removed": 0}
    trashed = 0
    for row in rows:
        record = dict(row)
        marks = _rows_as_dicts(
            db,
            "SELECT * FROM data_health_marks WHERE item_type='document' AND item_id=?",
            (str(row['id']),),
        )
        _trash_add(db, 'document', row['id'], record.get('original_name') or record.get('filename'), {
            'version': 1,
            'record': record,
            'health_marks': marks,
        })
        db.execute("DELETE FROM data_health_marks WHERE item_type='document' AND item_id=?", (str(row['id']),))
        db.execute("DELETE FROM documents WHERE id=?", (row['id'],))
        trashed += 1
    return {"deleted": trashed, "trashed": trashed, "files_removed": 0}


def _delete_item_documents(db, item_type, item_id):
    rows = db.execute(
        "SELECT id FROM documents WHERE item_type=? AND item_id=?",
        (item_type, item_id),
    ).fetchall()
    return _delete_document_rows(db, [row["id"] for row in rows])


RECORD_TABLE_BY_ITEM_TYPE = {
    'patent': 'patents',
    'trademark': 'trademarks',
    'trademark_evidence': 'trademarks',
    'copyright': 'copyrights',
}


def _record_exists(db, item_type, item_id):
    table = RECORD_TABLE_BY_ITEM_TYPE.get(item_type)
    if not table:
        return False
    try:
        numeric_id = int(item_id)
    except (TypeError, ValueError):
        return False
    return db.execute(f"SELECT 1 FROM {table} WHERE id=?", (numeric_id,)).fetchone() is not None


def _delete_health_marks_for_item(db, item_type, item_id):
    db.execute(
        "DELETE FROM data_health_marks WHERE item_type=? AND item_id=?",
        (item_type, str(item_id)),
    )


def _move_case_to_trash(db, item_type, item_id):
    meta = {
        'patent': ('patents', 'title', ('patent',)),
        'trademark': ('trademarks', 'name', ('trademark', 'trademark_evidence')),
        'copyright': ('copyrights', 'name', ('copyright',)),
    }.get(item_type)
    if not meta:
        raise ValueError('不支持的数据类型')
    table, name_key, document_types = meta
    row = db.execute(f"SELECT * FROM {table} WHERE id=?", (item_id,)).fetchone()
    if not row:
        return None
    record = dict(row)
    doc_placeholders = ','.join('?' for _ in document_types)
    documents = _rows_as_dicts(
        db,
        f"SELECT * FROM documents WHERE item_type IN ({doc_placeholders}) AND item_id=? ORDER BY id",
        tuple(document_types) + (item_id,),
    )
    history = _rows_as_dicts(
        db, "SELECT * FROM status_history WHERE item_type=? AND item_id=? ORDER BY id",
        (item_type, item_id),
    )
    legal_events = _rows_as_dicts(
        db, "SELECT * FROM legal_events WHERE item_type=? AND item_id=? ORDER BY id",
        (item_type, item_id),
    )
    payments = _rows_as_dicts(
        db, "SELECT * FROM fee_payments WHERE patent_id=? ORDER BY id", (item_id,),
    ) if item_type == 'patent' else []
    mark_conditions = ["(item_type=? AND item_id=?)"]
    mark_params = [item_type, str(item_id)]
    for document in documents:
        mark_conditions.append("(item_type='document' AND item_id=?)")
        mark_params.append(str(document['id']))
    health_marks = _rows_as_dicts(
        db, "SELECT * FROM data_health_marks WHERE " + ' OR '.join(mark_conditions), mark_params,
    )
    trash_id = _trash_add(db, item_type, item_id, record.get(name_key), {
        'version': 1,
        'record': record,
        'documents': documents,
        'status_history': history,
        'legal_events': legal_events,
        'fee_payments': payments,
        'health_marks': health_marks,
    })
    if documents:
        document_ids = [document['id'] for document in documents]
        placeholders = ','.join('?' for _ in document_ids)
        db.execute(f"DELETE FROM documents WHERE id IN ({placeholders})", document_ids)
    if health_marks:
        db.executemany("DELETE FROM data_health_marks WHERE issue_id=?", [(mark['issue_id'],) for mark in health_marks])
    db.execute("DELETE FROM status_history WHERE item_type=? AND item_id=?", (item_type, item_id))
    db.execute("DELETE FROM legal_events WHERE item_type=? AND item_id=?", (item_type, item_id))
    if item_type == 'patent':
        db.execute("DELETE FROM fee_payments WHERE patent_id=?", (item_id,))
    db.execute(f"DELETE FROM {table} WHERE id=?", (item_id,))
    return trash_id


def _restore_health_marks(db, marks):
    for mark in marks or []:
        try:
            _insert_snapshot_row(db, 'data_health_marks', mark)
        except sqlite3.IntegrityError:
            continue


def _restore_trash_entry(db, trash_row):
    item_type = trash_row['item_type']
    payload = json.loads(trash_row['payload'])
    record = payload.get('record') or {}
    root_meta = {
        'patent': ('patents', 'patent'),
        'trademark': ('trademarks', 'trademark'),
        'copyright': ('copyrights', 'copyright'),
    }.get(item_type)
    if root_meta:
        table, _ = root_meta
        old_id = int(record.get('id'))
        if db.execute(f"SELECT 1 FROM {table} WHERE id=?", (old_id,)).fetchone():
            raise ValueError('原位置已有同编号数据，暂时无法恢复')
        _insert_snapshot_row(db, table, record)
        for history in payload.get('status_history', []):
            _insert_snapshot_row(db, 'status_history', history)
        for event in payload.get('legal_events', []):
            _insert_snapshot_row(db, 'legal_events', event)
        for payment in payload.get('fee_payments', []):
            _insert_snapshot_row(db, 'fee_payments', payment)
        for document in payload.get('documents', []):
            _insert_snapshot_row(db, 'documents', document)
        _restore_health_marks(db, payload.get('health_marks'))
        return {'item_type': item_type, 'item_id': old_id}
    if item_type == 'document':
        if not _record_exists(db, record.get('item_type'), record.get('item_id')):
            raise ValueError('关联案件不存在，请先恢复对应案件')
        if db.execute("SELECT 1 FROM documents WHERE id=?", (record.get('id'),)).fetchone():
            raise ValueError('原位置已有同编号附件，暂时无法恢复')
        _insert_snapshot_row(db, 'documents', record)
        _restore_health_marks(db, payload.get('health_marks'))
        return {'item_type': item_type, 'item_id': record.get('id')}
    if item_type == 'fee_payment':
        if not db.execute("SELECT 1 FROM patents WHERE id=?", (record.get('patent_id'),)).fetchone():
            raise ValueError('关联专利不存在，请先恢复对应专利')
        _insert_snapshot_row(db, 'fee_payments', record)
        return {'item_type': item_type, 'item_id': record.get('id')}
    if item_type == 'status_history':
        if not _record_exists(db, record.get('item_type'), record.get('item_id')):
            raise ValueError('关联案件不存在，请先恢复对应案件')
        _insert_snapshot_row(db, 'status_history', record)
        return {'item_type': item_type, 'item_id': record.get('id')}
    if item_type == 'trademark_logo':
        trademark_id = payload.get('trademark_id')
        current = db.execute("SELECT name,logo_filename FROM trademarks WHERE id=?", (trademark_id,)).fetchone()
        if not current:
            raise ValueError('关联商标不存在，请先恢复对应商标')
        if current['logo_filename'] and current['logo_filename'] != payload.get('logo_filename'):
            _trash_add(db, 'trademark_logo', trademark_id, f"{current['name']} · 商标图", {
                'version': 1,
                'trademark_id': trademark_id,
                'logo_filename': current['logo_filename'],
            })
        db.execute(
            "UPDATE trademarks SET logo_filename=?,updated_at=? WHERE id=?",
            (payload.get('logo_filename') or '', now_str(), trademark_id),
        )
        return {'item_type': item_type, 'item_id': trademark_id}
    if item_type == 'fee_receipt':
        payment_id = payload.get('payment_id')
        current = db.execute("SELECT * FROM fee_payments WHERE id=?", (payment_id,)).fetchone()
        if not current:
            raise ValueError('关联缴费记录不存在，请先恢复对应缴费记录')
        if current['receipt_filename'] and current['receipt_filename'] != payload.get('receipt_filename'):
            _trash_add(db, 'fee_receipt', payment_id, current['receipt_original_name'] or '缴费凭证', {
                'version': 1,
                'payment_id': payment_id,
                'receipt_filename': current['receipt_filename'],
                'receipt_original_name': current['receipt_original_name'],
                'receipt_size': current['receipt_size'],
            })
        db.execute(
            """UPDATE fee_payments
               SET receipt_filename=?,receipt_original_name=?,receipt_size=? WHERE id=?""",
            (payload.get('receipt_filename') or '', payload.get('receipt_original_name') or '',
             payload.get('receipt_size') or 0, payment_id),
        )
        return {'item_type': item_type, 'item_id': payment_id}
    raise ValueError('该回收站数据暂不支持恢复')


def _purge_trash_entry(db, trash_row):
    try:
        payload = json.loads(trash_row['payload'])
    except Exception:
        payload = {}
    filenames = _trash_payload_filenames(payload)
    db.execute("DELETE FROM recycle_bin WHERE id=?", (trash_row['id'],))
    removed = 0
    for filename in filenames:
        if not _file_is_referenced(db, filename):
            try:
                (UPLOAD_DIR / filename).unlink(missing_ok=True)
                removed += 1
            except Exception:
                continue
    return removed


def _json_payload():
    payload = request.get_json(silent=True)
    return payload if isinstance(payload, dict) else {}



# ── PDF 文书识别规则 ──────────────────────────────────────────────────────────
# 每条规则：(关键词列表, 文书名称, 建议专利状态, 建议商标状态)
# 关键词全部命中（AND）才触发，按优先级排列
# 规则设计原则：
#   1. 商标规则含"商标"关键词，专利规则含"专利"关键词，避免交叉误匹配
#   2. 通用规则（如"受理"）放在最后，仅作为兜底
#   3. 驳回类规则需区分专利驳回和商标驳回
DOC_RULES = [
    # ── 商标（优先匹配，因为商标文书常含"申请号""受理"等通用词）──
    (['商标注册申请受理'],           '商标申请受理通知书', None, '已受理'),
    (['注册商标变更证明'],           '注册商标变更证明', None, '已注册'),
    (['商标', '变更证明'],           '注册商标变更证明', None, '已注册'),
    (['商标注册证'],                 '商标注册证',       None, '已注册'),
    (['商标注册公告'],               '商标注册公告',     None, '已注册'),
    (['注册公告', '商标'],           '商标注册公告',     None, '已注册'),
    (['商标注册申请初步审定公告'],     '商标初审公告',     None, '初审公告'),
    (['初步审定', '商标'],           '商标初审公告',     None, '初审公告'),
    (['驳回复审', '商标'],           '商标驳回复审材料', None, '复审中'),
    (['商标驳回'],                   '商标驳回通知书',   None, '已驳回'),
    (['驳回通知书', '商标'],         '商标驳回通知书',   None, '已驳回'),
    (['驳回', '商标', '注册'],       '商标驳回通知书',   None, '已驳回'),
    (['不予注册', '商标'],           '商标驳回通知书',   None, '已驳回'),
    (['异议申请', '商标'],           '其他',             None, '异议中'),
    (['异议决定', '商标'],           '其他',             None, None),
    (['撤销申请', '连续三年'],       '其他',             None, '撤三中'),
    (['无效宣告', '商标'],           '其他',             None, '无效中'),
    (['商标', '续展'],               '其他',             None, None),
    (['商标', '转让'],               '其他',             None, None),
    # ── 专利 ──
    (['专利证书', '授权'],           '专利证书',         '已授权', None),
    (['授权通知书', '专利'],         '授权通知书',       '待登记', None),
    (['授予发明专利权'],             '授权通知书',       '待登记', None),
    (['办理登记手续'],               '办理登记通知',     '待登记', None),
    (['专利申请受理'],               '专利受理通知书',   '已受理', None),
    (['受理通知书', '专利'],         '专利受理通知书',   '已受理', None),
    (['驳回决定', '专利'],           '驳回决定书',       '已驳回', None),
    (['驳回决定'],                   '驳回决定书',       '已驳回', None),
    (['复审决定', '专利'],           '复审决定书',       None, None),
    (['复审决定书'],                 '复审决定书',       None, None),
    (['复审请求', '专利'],           '复审请求书',       '复审中', None),
    (['宣告专利权全部无效'],          '无效宣告决定书',   '失效', None),
    (['无效宣告', '专利'],           '无效宣告请求书',   None, None),
    (['视为撤回'],                   '视撤通知书',       '视为撤回', None),
    (['放弃专利权'],                 '放弃通知书',       '失效', None),
    (['进入实质审查'],               '进入实审通知',     '实审中', None),
    (['实质审查请求'],               '实审请求书',       '实审中', None),
    (['审查意见通知书'],             '审查意见通知书',   '实审中', None),
    (['专利申请公布'],               '申请公布通知',     '已公开', None),
    (['检索报告'],                   '检索报告',         '实审中', None),
    # ── 通用兜底（最后匹配）──
    (['商标', '受理'],               '商标申请受理通知书', None, '已受理'),
    (['申请号', '受理'],             '受理通知书',       '已受理', None),
]

# 文件名是上传人可见且可直接核对的证据。命中这些明确词组时，优先级高于
# OCR/正文推断；只有文件名没有足够信息，才回退到正文规则。
FILENAME_DOC_RULES = {
    'trademark': [
        (('驳回', '复审'), '商标驳回复审材料'),
        (('驳回',), '商标驳回通知书'),
        (('不予注册',), '商标驳回通知书'),
        (('初步审定',), '商标初审公告'),
        (('初审公告',), '商标初审公告'),
        (('注册公告',), '商标注册公告'),
        (('注册证',), '商标注册证'),
        (('变更证明',), '注册商标变更证明'),
        (('受理',), '商标申请受理通知书'),
    ],
    'patent': [
        (('驳回', '复审'), '复审请求书'),
        (('驳回',), '驳回决定书'),
        (('审查意见',), '审查意见通知书'),
        (('办理登记',), '办理登记通知书'),
        (('授权通知',), '授权通知书'),
        (('专利证书',), '专利证书'),
        (('受理',), '受理通知书'),
        (('补正',), '补正通知书'),
        (('视撤',), '视撤通知书'),
        (('年费', '收据'), '年费缴费收据'),
        (('年费',), '年费缴费通知'),
    ],
    'copyright': [
        (('驳回',), '驳回通知书'),
        (('补正',), '补正通知书'),
        (('受理',), '登记受理通知书'),
        (('登记证',), '著作权登记证书'),
    ],
}


def _filename_doc_type(fname, item_type=''):
    """Return a document type only when the filename has an unambiguous cue."""
    text = Path(fname or '').stem.lower()
    scopes = [item_type] if item_type in FILENAME_DOC_RULES else []
    if not scopes:
        if '商标' in text:
            scopes = ['trademark']
        elif '专利' in text or re.search(r'cn\s*\d{6,}', text, re.I):
            scopes = ['patent']
        elif '软著' in text or '著作权' in text:
            scopes = ['copyright']
    for scope in scopes:
        for words, doc_type in FILENAME_DOC_RULES[scope]:
            if all(word in text for word in words):
                return doc_type
    return ''

def extract_pdf_text(path: Path, max_chars=8000) -> str:
    """提取 PDF 文本，失败返回空字符串"""
    try:
        from pdfminer.high_level import extract_text
        text = extract_text(str(path))
        return (text or '')[:max_chars]
    except Exception:
        pass
    try:
        import pypdf
        reader = pypdf.PdfReader(str(path))
        parts = []
        for page in reader.pages[:8]:
            parts.append(page.extract_text() or '')
        return '\n'.join(parts)[:max_chars]
    except Exception:
        return ''


def extract_ocr_text(path: Path, max_chars=8000) -> str:
    """Best-effort local OCR for scanned PDFs/images; silently falls back when unavailable."""
    tesseract = shutil.which('tesseract')
    if not tesseract:
        return ''
    lang = os.environ.get('IPKEEPER_OCR_LANG', 'chi_sim+eng')

    def run_tesseract(image_path):
        try:
            proc = subprocess.run(
                [tesseract, str(image_path), 'stdout', '-l', lang, '--psm', '6'],
                capture_output=True, text=True, timeout=30,
            )
            return proc.stdout or ''
        except Exception:
            return ''

    suffix = path.suffix.lower()
    if suffix in {'.png', '.jpg', '.jpeg', '.bmp', '.tif', '.tiff', '.webp'}:
        return run_tesseract(path)[:max_chars]
    if suffix != '.pdf':
        return ''
    pdftoppm = shutil.which('pdftoppm')
    if not pdftoppm:
        return ''
    with tempfile.TemporaryDirectory(prefix='ipkeeper_ocr_') as td:
        prefix = Path(td) / 'page'
        try:
            subprocess.run(
                [pdftoppm, '-f', '1', '-l', '3', '-jpeg', '-r', '180', str(path), str(prefix)],
                capture_output=True, timeout=40, check=False,
            )
        except Exception:
            return ''
        parts = []
        for image_path in sorted(Path(td).glob('page-*.jpg')):
            text = run_tesseract(image_path)
            if text:
                parts.append(text)
            if sum(len(x) for x in parts) >= max_chars:
                break
        return '\n'.join(parts)[:max_chars]


def extract_document_text(path: Path, max_chars=8000) -> str:
    """Extract text from common attachment formats for case prefill."""
    suffix = path.suffix.lower()
    if suffix == '.pdf':
        text = extract_pdf_text(path, max_chars)
        if len(re.sub(r'\s+', '', text)) >= 40:
            return text
        return (text + '\n' + extract_ocr_text(path, max_chars)).strip()[:max_chars]
    if suffix in {'.png', '.jpg', '.jpeg', '.bmp', '.tif', '.tiff', '.webp'}:
        return extract_ocr_text(path, max_chars)
    if suffix == '.txt':
        try:
            return path.read_text(encoding='utf-8', errors='ignore')[:max_chars]
        except Exception:
            return ''
    if suffix == '.docx':
        try:
            import docx
            doc = docx.Document(str(path))
            return '\n'.join(p.text for p in doc.paragraphs if p.text)[:max_chars]
        except Exception:
            return ''
    return ''


def _normalize_ocr_spacing(text):
    """Collapse OCR-added spaces between CJK characters while keeping word spacing."""
    return re.sub(r'(?<=[\u3400-\u9fff])\s+(?=[\u3400-\u9fff])', '', text or '')


def analyze_doc_text(text: str, item_type: str):
    """
    对提取的文本运行规则匹配。
    返回 {'doc_type': str, 'suggested_status': str|None, 'confidence': float, 'snippet': str}
    """
    if not text.strip():
        return None
    # 归一化
    t = _normalize_ocr_spacing(text.replace('\n', ' ').replace('\r', ' '))
    # 按 item_type 优先匹配对应类型的规则，避免专利规则误匹配商标文书
    def _match(rules_subset):
        for keywords, doc_name, patent_status, tm_status in rules_subset:
            if all(kw in t for kw in keywords):
                suggested = patent_status if item_type == 'patent' else tm_status
                snippet = re.sub(r'\s+', ' ', t[:200]).strip()
                return {
                    'doc_type': doc_name,
                    'suggested_status': suggested,
                    # This is deterministic keyword coverage, not a calibrated
                    # machine-learning probability.
                    'confidence': min(.85, .55 + .10 * len(keywords)),
                    'confidence_type': 'rule_match_strength',
                    'matched_keywords': keywords,
                    'snippet': snippet,
                }
        return None
    # 按关键词特征分类规则
    trademark_indicators = {'商标', '注册', '异议', '撤三', '无效', '初步审定'}
    patent_indicators = {'专利', '发明', '实用新型', '外观', '实审', '复审', '公开', 'PCT'}
    tm_rules, patent_rules, general_rules = [], [], []
    for rule in DOC_RULES:
        keywords = rule[0]
        if any(kw in trademark_indicators for kw in keywords):
            tm_rules.append(rule)
        elif any(kw in patent_indicators for kw in keywords):
            patent_rules.append(rule)
        else:
            general_rules.append(rule)
    # 先匹配对应类型，再匹配通用规则
    if item_type == 'trademark':
        result = _match(tm_rules) or _match(general_rules)
    elif item_type == 'patent':
        result = _match(patent_rules) or _match(general_rules)
    else:
        result = _match(DOC_RULES)
    if result:
        return result
    return {
        'doc_type': '其他文书',
        'suggested_status': None,
        'confidence': 0.0,
        'confidence_type': 'rule_match_strength',
        'matched_keywords': [],
        'snippet': re.sub(r'\s+', ' ', t[:200]).strip(),
    }


def extract_doc_fields(text: str, item_type: str, filename: str = '') -> dict:
    """从 PDF 文本中提取可用字段，返回 dict 用于自动填充新记录。
    只提取确信度高的字段，不瞎猜。"""
    fields = {}
    # 保留原始换行用于行首提取，同时生成平文本用于正则
    lines = [l.strip() for l in text.split('\n') if l.strip()]
    t = text.replace('\n', ' ').replace('\r', ' ').replace('\xa0', ' ').replace('　', ' ')
    # 归一化连续空格
    t = _normalize_ocr_spacing(re.sub(r'\s+', ' ', t))

    if item_type == 'trademark':
        # 申请号：优先从文件名提取
        m = re.search(r'(\d{7,9})', filename)
        if not m:
            m = re.search(r'申请号[:：]?\s*(\d{7,9})', t)
        if m:
            fields['app_no'] = m.group(1)
        # 注册号
        m = re.search(r'注册号[:：]?\s*(\d+)', t)
        if m:
            fields['reg_no'] = m.group(1)
        # 类别（"类别:第10类" 或 "第10类"）
        m = re.search(r'类\s*别[:：]?\s*第?\s*(\d+)\s*类', t)
        if not m:
            m = re.search(r'第\s*(\d+)\s*类', t)
        if m:
            fields['classes'] = m.group(1)
        # 申请人/注册人：接受通知书中无"申请人:"标签，公司名通常在文档开头前几行
        owner = ''
        # 先尝试有标签的情况
        for pat in [r'注册人[:：]\s*(.+?)(?:\s+地址)', r'权利人[:：]\s*(.+?)(?:\s+地址)',
                    r'申请人[:：]\s*(.+?)(?:\s+地址)', r'受让人[:：]\s*(.+?)(?:\s+地址)']:
            m = re.search(pat, t)
            if m:
                owner = m.group(1).strip()
                break
        # 无标签时：从文档前几行找公司名（包含"公司"/"集团"/"大学"等关键词的行）
        if not owner:
            for line in lines[:6]:
                if any(kw in line for kw in ['公司', '集团', '大学', '研究院', '研究所', '医院', '有限', '股份']) and len(line) <= 40:
                    owner = line
                    break
        if owner:
            # 清理：去掉尾部的地址/邮编等
            owner = re.sub(r'(北京市|上海市|广东省|地址|邮编|电话|Tel).*$', '', owner).strip()
            if 2 <= len(owner) <= 80:
                fields['owner'] = owner
        # 申请日期（标签后可能有其他内容，所以也尝试直接找"YYYY年MM月DD日"）
        m = re.search(r'申请日期[:：]?\s*(\d{4})\s*年\s*(\d{1,2})\s*月\s*(\d{1,2})\s*日', t)
        if not m:
            # 有些格式：申请日期: XXXXXX申请号:2026年05月08日 → 取申请号后的日期
            m2 = re.search(r'申请号[:：]?\s*\d{7,}\s*申请号[:：]?\s*(\d{4})\s*年\s*(\d{1,2})\s*月\s*(\d{1,2})\s*日', t)
            if m2:
                m = m2
        if not m:
            # 兜底：找所有日期，取"申请号:"附近最近的日期
            dates = list(re.finditer(r'(\d{4})\s*年\s*(\d{1,2})\s*月\s*(\d{1,2})\s*日', t))
            if dates:
                # 如果有"申请号"，取其后的最近日期；否则取最晚的
                app_no_pos = t.find('申请号')
                if app_no_pos >= 0:
                    after = [d for d in dates if d.start() > app_no_pos]
                    best = after[0] if after else dates[-1]
                else:
                    best = max(dates, key=lambda d: (int(d.group(1)), int(d.group(2)), int(d.group(3))))
                m = best
        if m:
            fields['app_date'] = f'{m.group(1)}-{int(m.group(2)):02d}-{int(m.group(3)):02d}'
        m = re.search(r'商标名[称]?[:：]\s*[\""\"]?\s*(.+?)\s*[\""\"]?(?:\s+注册|类|申请|商标)', t)
        if m and 1 <= len(m.group(1).strip()) <= 20:
            fields['name'] = m.group(1).strip()

    elif item_type == 'patent':
        codes = re.sub(r'\s+', '', t)
        # 申请号
        for pat in [r'申请号[:：]?(?:CN|ZL)?(\d{10,16}(?:\.\d)?)',
                    r'专利申请号[:：]?(?:CN|ZL)?(\d{10,16}(?:\.\d)?)',
                    r'(?:CN|ZL)(\d{10,16}(?:\.\d)?)']:
            m = re.search(pat, codes, re.I)
            if m:
                fields['app_no'] = m.group(1).upper()
                break
        # 公开号
        m = re.search(r'(?:公开|授权公告)号[:：]?(CN\d+[A-Z]?)', codes, re.I)
        if m:
            fields['pub_no'] = m.group(1).upper()
        # 授权号/专利号
        m = re.search(r'(?:授权|专利).{0,4}号[:：]?(ZL\d{10,16}(?:\.\d)?)', codes, re.I)
        if not m:
            m = re.search(r'(ZL\d{10,16}(?:\.\d)?)', codes, re.I)
        if m:
            fields['grant_no'] = m.group(1).upper()
        # 发明名称（有标签的情况）
        for pat in [r'发明名称\s*[:：]\s*(.+?)(?:专.{0,6}权人|申请号|发明人|专利号)',
                    r'专利名称\s*[:：]\s*(.+?)(?:申请号|专利号)',
                    r'名\s*称\s*[:：]\s*(.+?)(?:申请号|专利号)']:
            m = re.search(pat, t)
            if m:
                fields['title'] = m.group(1).strip()[:120]
                break
        # 发明人
        m = re.search(r'发明人\s*[:：]\s*(.+?)(?:申请号|申请人|地址|专利号)', t)
        if m:
            fields['inventors'] = m.group(1).strip()[:100]
        # 申请人（有标签的情况）
        for pat in [r'申请人\s*[:：]\s*(.+?)(?:地址|邮编)',
                    r'专.{0,5}权人\s*[:：]\s*(.+?)(?:地址|邮编|发明)']:
            m = re.search(pat, t)
            if m:
                fields['owner'] = m.group(1).strip()[:80]
                break
        # IPC 分类号
        m = re.search(r'(?:IPC|分类号)[:：]?\s*([A-H]\d{2}[A-Z]\s*\d+/\d+)', t, re.I)
        if m:
            fields['ipc'] = m.group(1).replace(' ', '')
        # 申请日期
        m = re.search(r'(?:专利)?申请(?:日期|日)\s*[:：]?\s*(\d{4})\s*年\s*(\d{1,2})\s*月\s*(\d{1,2})\s*日', t)
        if m:
            fields['app_date'] = f'{m.group(1)}-{int(m.group(2)):02d}-{int(m.group(3)):02d}'
        m = re.search(r'授权公告日\s*[:：]?\s*(\d{4})\s*年\s*(\d{1,2})\s*月\s*(\d{1,2})\s*日', t)
        if m:
            fields['grant_date'] = f'{m.group(1)}-{int(m.group(2)):02d}-{int(m.group(3)):02d}'

    elif item_type == 'copyright':
        # 登记号
        m = re.search(r'(\d{4}SR\d+)', t, re.I)
        if not m:
            m = re.search(r'(\d{4}SR\d+)', filename, re.I)
        if m:
            fields['reg_no'] = m.group(1).upper()
        # 软件名称（有标签）
        for pat in [r'软件名称[:：]\s*(.+?)(?:\s+登记号|版本)', r'作品名称[:：]\s*(.+?)(?:\s+登记)']:
            m = re.search(pat, t)
            if m:
                fields['name'] = m.group(1).strip()[:100]
                break
        # 版本号
        m = re.search(r'版本[号]?[:：]\s*V?\s*([\d.]+)', t)
        if m:
            fields['version'] = 'V' + m.group(1)
        # 著作权人（有标签）
        for pat in [r'著作权人[:：]\s*(.+?)(?:\s+地址)', r'权利人[:：]\s*(.+?)(?:\s+地址)']:
            m = re.search(pat, t)
            if m:
                fields['owner'] = m.group(1).strip()[:80]
                break
        # 登记日期
        m = re.search(r'登记日期[:：]?\s*(\d{4})\s*年\s*(\d{1,2})\s*月\s*(\d{1,2})\s*日', t)
        if m:
            fields['reg_date'] = f'{m.group(1)}-{int(m.group(2)):02d}-{int(m.group(3)):02d}'
    return fields


# 费减按案件备案资格和权利人数量执行。















def get_fee(patent_type, year, entity, app_date=None, grant_date=None,
            due_date=None, as_of=None, owner=None, fee_reduction_approved=False):
    quote = calculate_cn_annual_fee(
        patent_type, year, entity, app_date, grant_date, due_date, as_of, owner,
        fee_reduction_approved
    )
    return quote['base'], quote['total_due']

def get_db():
    conn = sqlite3.connect(str(DB_PATH), timeout=30)
    conn.row_factory = sqlite3.Row
    conn.execute("PRAGMA busy_timeout=10000")
    conn.execute("PRAGMA foreign_keys=ON")
    conn.execute("PRAGMA synchronous=FULL")
    return conn


def checkpoint_database():
    """Flush committed WAL data so web-service restarts never lose saved changes."""
    if not DB_PATH.exists():
        return
    conn = sqlite3.connect(str(DB_PATH), timeout=10)
    try:
        conn.execute("PRAGMA wal_checkpoint(TRUNCATE)")
        conn.commit()
    finally:
        conn.close()

# ── 自动关联辅助 ────────────────────────────────────────────
TEXT_MATCH_THRESHOLD = 0.85

_TEXT_MATCH_NOISE_WORDS = [
    '发明专利证书', '实用新型证书', '外观设计证书', '专利证书', '授权证书',
    '商标注册证', '注册证书', '登记证书', '受理通知书', '授权通知书',
    '驳回通知书', '驳回决定书', '复审决定书', '审查意见通知书', '检索报告',
    '办理登记通知书', '公开公告', '证书', '通知书', '受理', '授权', '注册',
    '专利', '商标', '软著', '著作权', '发明', '实用新型', '外观设计',
    '北京至真健康科技股份有限公司', '北京至真互联网技术有限公司',
    '吉林至真明熠医疗器械有限公司', '至真健康', '至真互联网', '至真明熠',
    '江苏', '北京', '美国', '日本', '韩国', '欧盟', '南非', '荷兰',
]


def _normalize_text_match(value):
    """Normalize filename/title text for conservative fuzzy matching."""
    text = unicodedata.normalize('NFKC', str(value or '').lower())
    text = Path(text).stem
    text = re.sub(r'(cn|zl)?\d{7,18}(?:\.\d)?', ' ', text, flags=re.I)
    text = re.sub(r'pct[/a-z]{2}\d{4}/\d{6}', ' ', text, flags=re.I)
    text = re.sub(r'\d{4}sr\d+', ' ', text, flags=re.I)
    text = re.sub(r'^\s*\d+[\s_.-]*', ' ', text)
    for word in _TEXT_MATCH_NOISE_WORDS:
        text = text.replace(word.lower(), ' ')
    text = re.sub(r'[\s_.,，。;；:：()（）\[\]【】{}《》<>、/\\|+\-&]+', '', text)
    return text.strip()


def _text_match_score(filename_text, record_text):
    if not filename_text or not record_text:
        return 0.0
    shorter, longer = sorted([filename_text, record_text], key=len)
    if len(shorter) < 6:
        return 0.0
    if shorter in longer:
        return 1.0
    ratio = SequenceMatcher(None, filename_text, record_text).ratio()
    match = SequenceMatcher(None, longer, shorter).find_longest_match(
        0, len(longer), 0, len(shorter)
    )
    partial = match.size / max(len(shorter), 1)
    return max(ratio, partial)


def _record_context_bonus(fname, record):
    """Small tie-breakers for duplicate titles, especially patent family filings."""
    raw = unicodedata.normalize('NFKC', str(fname or '')).lower()
    raw_digits = re.sub(r'\D+', '', raw)
    bonus = 0.0

    country = str(record.get('country') or '').strip().lower()
    country_aliases = {
        '中国': ['中国', 'cn', '国内'],
        '美国': ['美国', 'us', 'usa', 'unitedstates'],
        '日本': ['日本', 'jp', 'japan'],
        '韩国': ['韩国', 'kr', 'korea'],
        '欧盟': ['欧盟', 'eu'],
        '新加坡': ['新加坡', 'sg', 'singapore'],
        '南非': ['南非', 'za'],
        '荷兰': ['荷兰', 'nl'],
    }
    for key, aliases in country_aliases.items():
        if country == key.lower() and any(alias.lower() in raw for alias in aliases):
            bonus += 0.08
            break

    for field in ('app_no', 'grant_no', 'pub_no', 'reg_no'):
        value = str(record.get(field) or '').lower()
        if not value:
            continue
        compact = re.sub(r'[^a-z0-9]+', '', unicodedata.normalize('NFKC', value))
        digits = re.sub(r'\D+', '', compact)
        if compact and compact in re.sub(r'[^a-z0-9]+', '', raw):
            bonus += 0.10
            break
        if len(digits) >= 7 and digits in raw_digits:
            bonus += 0.10
            break

    owner = _normalize_text_match(record.get('owner') or '')
    filename_text = _normalize_text_match(fname)
    if owner and len(owner) >= 6 and (owner in filename_text or filename_text in owner):
        bonus += 0.03

    return bonus


def _best_text_record_match(fname, db, hint=None):
    """Match a pending filename to an existing title/name with >=85% similarity."""
    if db is None:
        return None, None, 0.0

    filename_text = _normalize_text_match(Path(fname).name)
    if len(filename_text) < 6:
        return None, None, 0.0

    sources = {
        'patent': (
            "SELECT * FROM patents WHERE COALESCE(title,'') != ''",
            'title',
            row_to_dict,
        ),
        'trademark': (
            "SELECT * FROM trademarks WHERE COALESCE(name,'') != ''",
            'name',
            row_to_dict,
        ),
        'copyright': (
            "SELECT * FROM copyrights WHERE COALESCE(name,'') != ''",
            'name',
            row_to_dict,
        ),
    }
    order = [hint] if hint in sources else []
    order += [k for k in sources if k not in order]

    best = (None, None, 0.0)
    second_score = 0.0
    for item_type in order:
        sql, name_field, convert = sources[item_type]
        for row in db.execute(sql).fetchall():
            record = convert(row)
            base_score = _text_match_score(filename_text, _normalize_text_match(record.get(name_field)))
            score = base_score
            if base_score >= TEXT_MATCH_THRESHOLD:
                score += _record_context_bonus(fname, record)
            if score > best[2]:
                second_score = best[2]
                best = (item_type, record, score)
            elif score > second_score:
                second_score = score

    # 85%以上算匹配；分数很接近时不自动关联，避免同名/近似案件挂错。
    if best[2] >= TEXT_MATCH_THRESHOLD and best[2] - second_score >= 0.03:
        return best
    return None, None, best[2]


def _match_file(fname, db):
    """尝试从文件名/路径中提取编号并匹配知产记录。
    支持子目录：待关联/专利/、待关联/商标/、待关联/软著/
    也支持平铺命名，如 CN202110000001_授权证书.pdf
    返回 (item_type, item_dict) 或 (None, None)
    """
    name = Path(fname).name  # just filename

    # 1. Patent – CN + 12-18 digits, or number in Chinese parentheses
    for pat in [r'(CN\d{10,16}(?:\.\d)?)', r'(ZL\d{10,16})', r'(PCT[/A-Z]{2}\d{4}/\d{6})',
                r'（(\d{10,16}(?:\.\d)?)）', r'\((\d{10,16}(?:\.\d)?)\)']:
        m = re.search(pat, name, re.I)
        if m:
            raw = m.group(1)
            base = re.sub(r'[.\-]', '', raw)
            variants = {raw, base}
            # 生成带点和不带点的变体
            if '.' in raw:
                variants.add(base)  # CN202110000001.1 → CN2021100000011
            elif len(base) > 3:
                variants.add(base[:-1] + '.' + base[-1])  # CN202110000001 → CN20211000000.1 | CN2021100000011 → CN202110000001.1
            # 用 OR 查询所有变体
            placeholders = ' OR '.join(['app_no=?','grant_no=?','pub_no=?']*len(variants))
            params = []
            for v in variants:
                params += [v, v, v]
            row = db.execute(f"SELECT * FROM patents WHERE {placeholders}", params).fetchone()
            if row: return 'patent', row_to_dict(row)

    # 2. Trademark – 8-digit number (Chinese trademark app no)
    m = re.search(r'(?<!\d)(\d{7,9})(?!\d)', name)
    if m:
        num = m.group(1)
        row = db.execute("SELECT * FROM trademarks WHERE app_no=? OR reg_no=? OR app_no LIKE ? OR reg_no LIKE ?",
                         [num, num, f'%{num}%', f'%{num}%']).fetchone()
        if row: return 'trademark', row_to_dict(row)

    # 3. Copyright – YYYY SR/sr digits
    m = re.search(r'(\d{4}SR\d+)', name, re.I)
    if m:
        row = db.execute("SELECT * FROM copyrights WHERE reg_no LIKE ?",
                         [f"%{m.group(1)}%"]).fetchone()
        if row: return 'copyright', row_to_dict(row)

    # 4. Subfolder hints:  待关联/专利/…  or  待关联/商标/…
    path_lower = fname.lower()
    if '专利' in fname or 'patent' in path_lower:
        hint = 'patent'
    elif '商标' in fname or 'trademark' in path_lower:
        hint = 'trademark'
    elif '软著' in fname or '著作' in fname or 'copyright' in path_lower:
        hint = 'copyright'
    else:
        hint = None
    # 文件名无法判断类型时，尝试从PDF内容推断
    if not hint and Path(fname).suffix.lower() == '.pdf':
        hint = _guess_type_from_content(Path(fname))

    # 5. Title/name fuzzy matching: filename text vs existing case title/name.
    text_type, text_record, _score = _best_text_record_match(fname, db, hint)
    if text_record:
        return text_type, text_record

    return hint, None          # matched type but no specific record


def _doc_type_from_name(fname, item_type=''):
    """从文件名猜测文件类型（优先级：具体→通用，避免误匹配）"""
    matched = _filename_doc_type(fname, item_type)
    if matched:
        return matched
    # 已经确定案件类型但文件名没有明确特征时，不套用另一业务类型的
    # 通用关键词；交由正文识别或由用户在下拉框确认。
    if item_type in FILENAME_DOC_RULES:
        return '其他'
    stem = Path(fname).stem
    n = fname.lower()
    # 商标相关（优先，因为商标文件名常含通用词如"受理"）
    if any(k in n for k in ['注册商标变更证明', '商标变更证明', '变更证明']): return '注册商标变更证明'
    if any(k in n for k in ['商标注册证', '商标证', '注册证']): return '商标注册证'
    if any(k in n for k in ['商标复审可行性方案', '商标复审方案', '驳回复审方案']): return '商标复审方案书'
    if any(k in n for k in ['商标驳回复审', '驳回复审']): return '商标驳回复审材料'
    # “商标部分驳回通知书”等常见命名不包含连续的“商标驳回”，
    # 只要文件名同时出现商标和驳回，即应优先归为驳回通知书。
    if '商标' in n and ('驳回' in n or '不予注册' in n): return '商标驳回通知书'
    if any(k in n for k in ['商标受理', '受理通知书']): return '商标申请受理通知书'
    if any(k in n for k in ['注册公告']): return '商标注册公告'
    if any(k in n for k in ['初审公告', '初步审定']): return '商标初审公告'
    if any(k in n for k in ['商标异议', '商标续展', '商标转让']): return '其他'
    # 专利相关
    if re.search(r'cn\s*\d{6,}[a]\b', stem, re.I) or re.search(r'(?<![A-Za-z])A(?![A-Za-z])', stem):
        return '申请文件公开版'
    if re.search(r'cn\s*\d{6,}[b]\b', stem, re.I) or re.search(r'(?<![A-Za-z])B(?![A-Za-z])', stem):
        return '申请文件授权版'
    if any(k in n for k in ['办理登记']): return '办理登记通知'
    if any(k in n for k in ['授权通知', '授权证', 'grant']): return '授权通知书'
    if any(k in n for k in ['专利证书', 'certificate']): return '专利证书'
    if any(k in n for k in ['审查意见']): return '审查意见通知书'
    if any(k in n for k in ['驳回决定', 'rejection']): return '驳回决定书'
    if any(k in n for k in ['复审决定', 'review']): return '复审决定书'
    if any(k in n for k in ['检索报告']): return '检索报告'
    if any(k in n for k in ['专利受理']): return '专利受理通知书'
    if any(k in n for k in ['公开', '公告', 'publication']): return '公开公告'
    # 软著相关
    if any(k in n for k in ['软著', '登记证', 'registration']): return '登记证书'
    # 通用兜底（最后匹配）
    if '受理通知' in n: return '受理通知书'
    if '驳回' in n: return '驳回决定书'
    if '证书' in n: return '证书'
    return '其他'


def _suggested_status_for_doc_type(item_type, doc_type):
    """仅用于上传预览的状态建议；不直接改变案件法律状态。"""
    if item_type == 'trademark':
        return {
            '商标申请受理通知书': '已受理',
            '商标驳回通知书': '已驳回',
            '商标驳回复审材料': '复审中',
            '商标初审公告': '初审公告',
            '商标注册公告': '已注册',
            '商标注册证': '已注册',
            '注册商标变更证明': '已注册',
        }.get(doc_type)
    if item_type == 'patent':
        return {
            '受理通知书': '已受理',
            '专利受理通知书': '已受理',
            '实质审查请求书': '实审中',
            '审查意见通知书': '实审中',
            '驳回决定书': '已驳回',
            '办理登记通知书': '待登记',
            '授权通知书': '待登记',
            '专利证书': '已授权',
            '申请公布通知': '已公开',
        }.get(doc_type)
    return None


def _guess_type_from_content(fpath):
    """当文件名无法判断类型时，从文本/OCR内容推断属于专利/商标/软著。"""
    try:
        # extract_document_text 同时覆盖可搜索 PDF、扫描 PDF 和图片。
        # 这里不把“未知”强行归为专利，避免监控文件夹误挂案件。
        text = extract_document_text(fpath)
        if not text:
            return None
        t = _normalize_ocr_spacing(text.replace('\n', ' ').replace('\r', ' '))
        # 商标特征词
        if any(kw in t for kw in ['商标法', '商标注册', '商标驳回', '商标证', '尼斯分类', '商品/服务']):
            return 'trademark'
        # 专利特征词
        if any(kw in t for kw in ['专利法', '专利号', '发明人', 'IPC', '实用新型', '外观设计']):
            return 'patent'
        # 软著特征词
        if any(kw in t for kw in ['软件著作权', '登记号', '著作权人']):
            return 'copyright'
    except Exception:
        pass
    return None


def init_db():
    global AUTO_BACKUP_STARTED
    with get_db() as db:
        db.executescript(ALERT_CENTER_SCHEMA)
        db.executescript("""
        CREATE TABLE IF NOT EXISTS patents (
            id INTEGER PRIMARY KEY AUTOINCREMENT,
            title TEXT NOT NULL, app_no TEXT, pub_no TEXT, grant_no TEXT,
            type TEXT DEFAULT '发明', country TEXT DEFAULT '中国', jurisdiction TEXT DEFAULT '中国', authority TEXT DEFAULT 'CNIPA', filing_route TEXT DEFAULT '直接申请', status TEXT DEFAULT '已受理',
            app_date TEXT, pub_date TEXT, grant_date TEXT, inventors TEXT, owner TEXT,
            agent TEXT, ipc TEXT, next_fee_date TEXT, current_year INTEGER DEFAULT 1,
            fee_entity TEXT DEFAULT '无费减', fee_reduction_approved INTEGER DEFAULT 0,
            fee_reduction_status TEXT DEFAULT '未申请', fee_reduction_ratio REAL DEFAULT 0,
            fee_reduction_effective_from TEXT, fee_reduction_effective_to TEXT,
            fee_reduction_verified_date TEXT, fee_reduction_source TEXT DEFAULT '',
            fee_route TEXT DEFAULT 'auto', fee_deadline_verified INTEGER DEFAULT 0,
            notes TEXT, tags TEXT DEFAULT '[]',
            created_at TEXT DEFAULT (datetime('now','localtime')),
            updated_at TEXT DEFAULT (datetime('now','localtime'))
        );
        CREATE TABLE IF NOT EXISTS trademarks (
            id INTEGER PRIMARY KEY AUTOINCREMENT,
            name TEXT NOT NULL, app_no TEXT, reg_no TEXT, type TEXT DEFAULT '文字',
            classes TEXT, goods_services TEXT, country TEXT DEFAULT '中国', jurisdiction TEXT DEFAULT '中国', authority TEXT DEFAULT 'CNIPA', filing_route TEXT DEFAULT '直接申请', status TEXT DEFAULT '已受理',
            app_date TEXT, reg_date TEXT, renewal_date TEXT, owner TEXT, agent TEXT,
            initial_review_notice_no TEXT DEFAULT '', reg_announcement_no TEXT DEFAULT '',
            exclusive_right_period TEXT DEFAULT '',
            notes TEXT, tags TEXT DEFAULT '[]',
            created_at TEXT DEFAULT (datetime('now','localtime')),
            updated_at TEXT DEFAULT (datetime('now','localtime'))
        );
        CREATE TABLE IF NOT EXISTS copyrights (
            id INTEGER PRIMARY KEY AUTOINCREMENT,
            name TEXT NOT NULL, version TEXT, reg_no TEXT, reg_date TEXT,
            jurisdiction TEXT DEFAULT '中国', authority TEXT DEFAULT 'CPCC', filing_route TEXT DEFAULT '直接登记',
            completion_date TEXT, owner TEXT, type TEXT DEFAULT '原始', language TEXT,
            development_mode TEXT DEFAULT '独立开发', acquisition_mode TEXT DEFAULT '原始取得',
            owner_type TEXT DEFAULT '法人或其他组织', publication_status TEXT DEFAULT '未发表',
            first_publication_date TEXT, first_publication_place TEXT,
            death_date TEXT,
            registration_status TEXT DEFAULT '已登记',
            notes TEXT, tags TEXT DEFAULT '[]',
            created_at TEXT DEFAULT (datetime('now','localtime')),
            updated_at TEXT DEFAULT (datetime('now','localtime'))
        );
        CREATE TABLE IF NOT EXISTS documents (
            id INTEGER PRIMARY KEY AUTOINCREMENT, item_type TEXT NOT NULL,
            item_id INTEGER NOT NULL, filename TEXT NOT NULL, original_name TEXT NOT NULL,
            file_size INTEGER, mime_type TEXT, doc_type TEXT DEFAULT '其他',
            description TEXT, received_date TEXT, file_hash TEXT DEFAULT '',
            uploaded_at TEXT DEFAULT (datetime('now','localtime'))
        );
        CREATE TABLE IF NOT EXISTS field_provenance (
            id INTEGER PRIMARY KEY AUTOINCREMENT,
            item_type TEXT NOT NULL,
            item_id INTEGER NOT NULL,
            field TEXT NOT NULL,
            value TEXT,
            source_document_id INTEGER,
            source_page TEXT DEFAULT '',
            confidence REAL,
            extraction_method TEXT DEFAULT 'document_review',
            confirmed_by TEXT DEFAULT '人工文书复核',
            confirmed_at TEXT DEFAULT (datetime('now','localtime')),
            created_at TEXT DEFAULT (datetime('now','localtime'))
        );
        CREATE TABLE IF NOT EXISTS status_history (
            id INTEGER PRIMARY KEY AUTOINCREMENT,
            item_type TEXT NOT NULL,
            item_id INTEGER NOT NULL,
            old_status TEXT,
            new_status TEXT NOT NULL,
            note TEXT DEFAULT '',
            operator TEXT DEFAULT '',
            changed_at TEXT DEFAULT (datetime('now','localtime'))
        );
        CREATE TABLE IF NOT EXISTS fee_payments (
            id INTEGER PRIMARY KEY AUTOINCREMENT,
            patent_id INTEGER NOT NULL,
            fee_year INTEGER,
            standard_amount INTEGER DEFAULT 0,
            paid_amount INTEGER DEFAULT 0,
            paid_date TEXT,
            payer TEXT DEFAULT '',
            agent TEXT DEFAULT '',
            receipt_filename TEXT DEFAULT '',
            receipt_original_name TEXT DEFAULT '',
            receipt_size INTEGER DEFAULT 0,
            note TEXT DEFAULT '',
            record_source TEXT DEFAULT 'manual',
            amount_verified INTEGER DEFAULT 1,
            created_at TEXT DEFAULT (datetime('now','localtime'))
        );
        CREATE TABLE IF NOT EXISTS alert_workflow (
            id INTEGER PRIMARY KEY AUTOINCREMENT,
            alert_key TEXT NOT NULL,
            status TEXT NOT NULL,
            note TEXT NOT NULL,
            created_at TEXT DEFAULT (datetime('now','localtime'))
        );
        CREATE TABLE IF NOT EXISTS alerts_dismissed (
            alert_id TEXT PRIMARY KEY, dismissed_at TEXT DEFAULT (datetime('now','localtime'))
        );
        CREATE TABLE IF NOT EXISTS data_health_marks (
            issue_id TEXT PRIMARY KEY,
            status TEXT NOT NULL CHECK(status IN ('confirmed','ignored')),
            title TEXT DEFAULT '',
            item_type TEXT DEFAULT '',
            item_id TEXT DEFAULT '',
            field TEXT DEFAULT '',
            fingerprint TEXT DEFAULT '',
            marked_at TEXT NOT NULL,
            updated_at TEXT DEFAULT (datetime('now','localtime'))
        );
        CREATE TABLE IF NOT EXISTS recycle_bin (
            id INTEGER PRIMARY KEY AUTOINCREMENT,
            item_type TEXT NOT NULL,
            item_id INTEGER,
            name TEXT NOT NULL,
            payload TEXT NOT NULL,
            deleted_at TEXT NOT NULL
        );
        CREATE TABLE IF NOT EXISTS legal_events (
            id INTEGER PRIMARY KEY AUTOINCREMENT,
            item_type TEXT NOT NULL,
            item_id INTEGER NOT NULL,
            event_type TEXT NOT NULL,
            event_date TEXT,
            effective_date TEXT,
            source_document_id INTEGER,
            review_status TEXT NOT NULL DEFAULT 'confirmed'
                CHECK(review_status IN ('candidate','confirmed','rejected')),
            details TEXT DEFAULT '{}',
            operator TEXT DEFAULT '',
            created_at TEXT DEFAULT (datetime('now','localtime')),
            confirmed_at TEXT
        );
        CREATE TABLE IF NOT EXISTS deadline_tasks (
            id INTEGER PRIMARY KEY AUTOINCREMENT,
            task_key TEXT NOT NULL UNIQUE,
            item_type TEXT NOT NULL,
            item_id INTEGER NOT NULL,
            event_id INTEGER,
            kind TEXT NOT NULL,
            title TEXT NOT NULL,
            deadline TEXT NOT NULL,
            status TEXT NOT NULL DEFAULT 'pending'
                CHECK(status IN ('pending','in_progress','waiting','completed','ignored','superseded')),
            priority TEXT DEFAULT 'normal',
            rule_version TEXT DEFAULT '',
            source TEXT DEFAULT 'deadline_engine',
            deadline_source TEXT DEFAULT 'rule',
            official_deadline TEXT,
            estimated_deadline TEXT,
            override_reason TEXT DEFAULT '',
            payload TEXT DEFAULT '{}',
            created_at TEXT DEFAULT (datetime('now','localtime')),
            updated_at TEXT DEFAULT (datetime('now','localtime')),
            completed_at TEXT
        );
        CREATE TABLE IF NOT EXISTS settings (key TEXT PRIMARY KEY, value TEXT);
        INSERT OR IGNORE INTO settings(key,value) VALUES
            ('company',''),('alert_patent_fee','90,30,7'),
            ('alert_trademark_renewal','365,180,30'),('alert_pct_phase','60,30'),
            ('default_fee_entity','无费减'),
            ('default_country','中国'),('alert_default_window','90'),
            ('alert_urgent_days','14'),('alert_soon_days','30'),
            ('watch_folder_path',''),('attachment_filters','{}'),
            ('auto_backup_enabled','1'),('auto_backup_retention','7');
        """)
        # WAL 模式 — 只需设置一次，提升并发读写性能
        db.execute("PRAGMA journal_mode=WAL")
        db.execute("PRAGMA foreign_keys=ON")
        # 性能索引 — 加速列表查询和去重检查
        db.execute("CREATE INDEX IF NOT EXISTS idx_patents_app_no ON patents(app_no)")
        db.execute("CREATE INDEX IF NOT EXISTS idx_patents_status ON patents(status)")
        db.execute("CREATE INDEX IF NOT EXISTS idx_patents_created ON patents(created_at)")
        db.execute("CREATE INDEX IF NOT EXISTS idx_trademarks_app_no ON trademarks(app_no)")
        db.execute("CREATE INDEX IF NOT EXISTS idx_trademarks_status ON trademarks(status)")
        db.execute("CREATE INDEX IF NOT EXISTS idx_trademarks_created ON trademarks(created_at)")
        db.execute("CREATE INDEX IF NOT EXISTS idx_copyrights_reg_no ON copyrights(reg_no)")
        db.execute("CREATE INDEX IF NOT EXISTS idx_copyrights_created ON copyrights(created_at)")
        db.execute("CREATE INDEX IF NOT EXISTS idx_documents_item ON documents(item_type, item_id)")
        db.execute("CREATE INDEX IF NOT EXISTS idx_documents_filename ON documents(filename)")
        db.execute("CREATE INDEX IF NOT EXISTS idx_fee_payments_patent ON fee_payments(patent_id)")
        db.execute("CREATE INDEX IF NOT EXISTS idx_fee_payments_date ON fee_payments(paid_date)")
        db.execute("CREATE INDEX IF NOT EXISTS idx_status_history_item ON status_history(item_type, item_id)")
        db.execute("CREATE INDEX IF NOT EXISTS idx_alerts_dismissed ON alerts_dismissed(alert_id)")
        db.execute("CREATE INDEX IF NOT EXISTS idx_data_health_marks_status ON data_health_marks(status)")
        db.execute("CREATE INDEX IF NOT EXISTS idx_recycle_bin_deleted ON recycle_bin(deleted_at DESC)")
        db.execute("CREATE INDEX IF NOT EXISTS idx_recycle_bin_type ON recycle_bin(item_type)")
        db.execute("CREATE INDEX IF NOT EXISTS idx_legal_events_item ON legal_events(item_type,item_id,created_at)")
        db.execute("CREATE INDEX IF NOT EXISTS idx_legal_events_document ON legal_events(source_document_id)")
        db.execute("CREATE INDEX IF NOT EXISTS idx_deadline_tasks_deadline ON deadline_tasks(deadline,status)")
        db.execute("CREATE INDEX IF NOT EXISTS idx_deadline_tasks_item ON deadline_tasks(item_type,item_id)")
        for col in [("patents","current_year","INTEGER DEFAULT 1"),
                    ("patents","fee_entity","TEXT DEFAULT '无费减'"),
                    ("patents","fee_reduction_approved","INTEGER DEFAULT 0"),
                    ("patents","fee_reduction_status","TEXT DEFAULT '未申请'"),
                    ("patents","fee_reduction_ratio","REAL DEFAULT 0"),
                    ("patents","fee_reduction_effective_from","TEXT"),
                    ("patents","jurisdiction","TEXT DEFAULT '中国'"),
                    ("patents","authority","TEXT DEFAULT 'CNIPA'"),
                    ("patents","filing_route","TEXT DEFAULT '直接申请'"),
                    ("patents","fee_reduction_effective_to","TEXT"),
                    ("patents","fee_reduction_verified_date","TEXT"),
                    ("patents","fee_reduction_source","TEXT DEFAULT ''"),
                    ("patents","fee_route","TEXT DEFAULT 'auto'"),
                    ("patents","fee_deadline_verified","INTEGER DEFAULT 0"),
                    ("patents","oa_round","TEXT DEFAULT 'first'"),
                    ("patents","tags","TEXT DEFAULT '[]'"),
                    ("patents","grant_date","TEXT"),
                    ("trademarks","goods_services","TEXT DEFAULT ''"),
                    ("trademarks","jurisdiction","TEXT DEFAULT '中国'"),
                    ("trademarks","authority","TEXT DEFAULT 'CNIPA'"),
                    ("trademarks","filing_route","TEXT DEFAULT '直接申请'"),
                    ("trademarks","logo_filename","TEXT DEFAULT ''"),
                    ("trademarks","tags","TEXT DEFAULT '[]'"),
                   ("trademarks","reg_date","TEXT"),
                   ("trademarks","renewal_date","TEXT"),
                   ("trademarks","initial_review_notice_no","TEXT DEFAULT ''"),
                   ("trademarks","reg_announcement_no","TEXT DEFAULT ''"),
                   ("trademarks","exclusive_right_period","TEXT DEFAULT ''"),
                    ("copyrights","tags","TEXT DEFAULT '[]'"),
                    ("copyrights","type","TEXT DEFAULT '原始'"),
                    ("copyrights","language","TEXT"),
                    ("copyrights","development_mode","TEXT DEFAULT '独立开发'"),
                    ("copyrights","acquisition_mode","TEXT DEFAULT '原始取得'"),
                    ("copyrights","owner_type","TEXT DEFAULT '法人或其他组织'"),
                    ("copyrights","publication_status","TEXT DEFAULT '未发表'"),
                    ("copyrights","first_publication_date","TEXT"),
                    ("copyrights","first_publication_place","TEXT"),
                    ("copyrights","death_date","TEXT"),
                    ("copyrights","registration_status","TEXT DEFAULT '已登记'"),
                    ("copyrights","jurisdiction","TEXT DEFAULT '中国'"),
                    ("copyrights","authority","TEXT DEFAULT 'CPCC'"),
                    ("copyrights","filing_route","TEXT DEFAULT '直接登记'"),
                   ("documents","description","TEXT DEFAULT ''"),
                   ("documents","received_date","TEXT"),
                   ("documents","file_hash","TEXT DEFAULT ''"),
                   ("documents","analysis_json","TEXT DEFAULT ''"),
                   ("documents","review_status","TEXT DEFAULT ''"),
                   ("documents","reviewed_at","TEXT"),
                   ("trademarks","rejection_date","TEXT"),
                   ("trademarks","review_simple_submitted_date","TEXT"),
                   ("trademarks","review_complete_submitted_date","TEXT"),
                   ("patents","oa_date","TEXT"),
                   ("patents","rejection_date","TEXT"),
                   ("patents","grant_notice_date","TEXT"),
                   ("trademarks","pub_date","TEXT"),
                   ("trademarks","opposition_notice_date","TEXT"),
                   ("trademarks","reg_fee_notice_date","TEXT"),
                   ("fee_payments","record_source","TEXT DEFAULT 'manual'"),
                   ("fee_payments","amount_verified","INTEGER DEFAULT 1"),
                    ("data_health_marks","fingerprint","TEXT DEFAULT ''")]:
            try: db.execute(f"ALTER TABLE {col[0]} ADD COLUMN {col[1]} {col[2]}")
            except: pass
        for col in [("alert_tasks","deadline_task_id","INTEGER REFERENCES deadline_tasks(id)"),("deadline_tasks","deadline_source","TEXT DEFAULT 'rule'"),("deadline_tasks","official_deadline","TEXT"),("deadline_tasks","estimated_deadline","TEXT"),("deadline_tasks","override_reason","TEXT DEFAULT ''")]:
            try: db.execute(f"ALTER TABLE {col[0]} ADD COLUMN {col[1]} {col[2]}")
            except: pass
        db.execute("CREATE INDEX IF NOT EXISTS idx_documents_hash ON documents(file_hash, file_size)")
        db.execute("CREATE INDEX IF NOT EXISTS idx_field_provenance_item ON field_provenance(item_type, item_id, field)")
        db.execute("CREATE INDEX IF NOT EXISTS idx_field_provenance_doc ON field_provenance(source_document_id)")
        db.execute("UPDATE patents SET jurisdiction=CASE WHEN country NOT IN ('中国','中华人民共和国','CN','') AND COALESCE(jurisdiction,'中国')='中国' THEN country ELSE COALESCE(NULLIF(jurisdiction,''),country,'中国') END, authority=CASE WHEN country IN ('PCT','马德里','国际') THEN 'WIPO' WHEN country IN ('欧洲','欧盟','EP','EPO') THEN 'EPO' WHEN country IN ('中国','中华人民共和国','CN','') THEN 'CNIPA' ELSE COALESCE(NULLIF(authority,''),'其他') END, filing_route=CASE WHEN country='PCT' AND COALESCE(filing_route,'直接申请')='直接申请' THEN 'PCT' WHEN country='马德里' AND COALESCE(filing_route,'直接申请')='直接申请' THEN '马德里' ELSE COALESCE(NULLIF(filing_route,''),'直接申请') END")
        db.execute("UPDATE trademarks SET jurisdiction=CASE WHEN country NOT IN ('中国','中华人民共和国','CN','') AND COALESCE(jurisdiction,'中国')='中国' THEN country ELSE COALESCE(NULLIF(jurisdiction,''),country,'中国') END, authority=CASE WHEN country IN ('PCT','马德里','国际') THEN 'WIPO' WHEN country IN ('欧洲','欧盟','EUIPO') THEN 'EUIPO' ELSE 'CNIPA' END, filing_route=CASE WHEN country='马德里' AND COALESCE(filing_route,'直接申请')='直接申请' THEN '马德里' WHEN country='PCT' AND COALESCE(filing_route,'直接申请')='直接申请' THEN 'PCT' ELSE COALESCE(NULLIF(filing_route,''),'直接申请') END")
        db.execute("UPDATE copyrights SET jurisdiction=COALESCE(NULLIF(jurisdiction,''),'中国'), authority=COALESCE(NULLIF(authority,''),'CPCC'), filing_route=COALESCE(NULLIF(filing_route,''),'直接登记')")
        # 旧企业规模分类只能表示历史填法，不能证明费减已经获批。
        db.execute("""UPDATE patents SET fee_entity='无费减', fee_reduction_approved=0
                      WHERE fee_entity IN ('大型企业','中型企业','小型企业','微型企业','个人')
                         OR fee_entity IS NULL OR fee_entity=''""")
        # 将旧版“有费减-主体类型 + 勾选”迁移为独立的官方资格状态和比例。
        db.execute("""UPDATE patents SET fee_reduction_status='已批准'
                      WHERE COALESCE(fee_reduction_status,'未申请') IN ('','未申请')
                        AND (fee_reduction_approved=1 OR fee_entity LIKE '有费减%')""")
        db.execute("""UPDATE patents SET fee_reduction_ratio=CASE
                          WHEN fee_entity LIKE '%多个%' THEN 0.30
                          WHEN fee_entity LIKE '%单个%' THEN 0.15
                          ELSE fee_reduction_ratio END
                      WHERE COALESCE(fee_reduction_ratio,0)=0
                        AND COALESCE(fee_reduction_status,'未申请')='已批准'""")
        # 年费只适用于已授权专利；历史记录中的未授权截止日统一清空，
        # 避免在列表、导出或日历中被误认为待缴年费。
        db.execute("""UPDATE patents SET next_fee_date=NULL
                      WHERE status NOT IN ('已授权','授权')
                        AND COALESCE(next_fee_date,'')<>''""")
        db.execute("""UPDATE settings SET value='无费减'
                      WHERE key='default_fee_entity' AND value='有费减-单个主体'""")
        db.execute("""UPDATE copyrights SET
                        development_mode=CASE WHEN type IN ('委托','合作') THEN type ELSE COALESCE(NULLIF(development_mode,''),'独立开发') END,
                        acquisition_mode=CASE WHEN type IN ('继受','继受取得') THEN '继受取得' ELSE COALESCE(NULLIF(acquisition_mode,''),'原始取得') END
                      WHERE COALESCE(development_mode,'')='' OR COALESCE(acquisition_mode,'')=''
                         OR type IN ('委托','合作','继受','继受取得')""")
        db.execute("""UPDATE patents SET type='外观设计' WHERE type IN ('外观','外观专利','外观设计专利')""")
        db.execute("""UPDATE patents SET type='实用新型' WHERE type IN ('实用','实用新型专利')""")
        db.execute("""UPDATE patents SET status='已受理' WHERE status IN ('申请中','受理')""")
        db.execute("""UPDATE patents SET status='实审中' WHERE status IN ('审查中','实审','实质审查中')""")
        db.execute("""UPDATE patents SET status='已授权' WHERE status='授权'""")
        db.execute("""UPDATE patents SET status='已驳回' WHERE status='驳回'""")
        db.execute("""UPDATE patents SET status='主动撤回' WHERE status='撤回'""")
        db.execute("""UPDATE patents SET status='视为撤回' WHERE status='视撤'""")
        db.execute("""UPDATE patents SET status='失效' WHERE status IN ('无效','放弃','期满')""")
        db.execute("""UPDATE trademarks SET type='文字+图形' WHERE type IN ('组合','文字图形')""")
        db.execute("""UPDATE trademarks SET type='三维标志' WHERE type IN ('立体','三维')""")
        db.execute("""UPDATE trademarks SET status='已受理' WHERE status IN ('申请中','受理')""")
        db.execute("""UPDATE trademarks SET status='初审公告' WHERE status IN ('初审','初步审定')""")
        db.execute("""UPDATE trademarks SET status='已注册' WHERE status='注册'""")
        db.execute("""UPDATE trademarks SET status='异议中' WHERE status='异议'""")
        db.execute("""UPDATE trademarks SET status='撤三中' WHERE status='撤三'""")
        db.execute("""UPDATE trademarks SET status='无效中' WHERE status='无效'""")
        db.execute("""UPDATE trademarks SET status='已撤销' WHERE status='撤销'""")
        db.execute("""UPDATE trademarks SET status='已期满' WHERE status='期满'""")
        # These routes cannot be calculated by the generic foreign invention
        # rules. Normalize legacy imports so the UI and deadline engine both
        # show that the official deadline must be maintained manually.
        db.execute("""UPDATE patents SET fee_route='manual'
                      WHERE COALESCE(fee_route,'auto')='auto'
                        AND country IN ('欧盟','欧洲','EP','EPO','EU')""")
        db.execute("""UPDATE patents SET fee_route='manual'
                      WHERE COALESCE(fee_route,'auto')='auto'
                        AND country NOT IN ('中国','中华人民共和国','CN','China','CHINA','PRC','P.R.C.')
                        AND type IS NOT NULL AND type<>'发明'""")
        # The filename is explicit enough to classify this business proposal;
        # do not let the phrase "初步审定" in its legal quotation turn it into
        # a misleading primary trademark notice.
        db.execute("""UPDATE documents SET doc_type='商标复审方案书'
                      WHERE item_type='trademark'
                        AND doc_type IN ('','其他','其他文书')
                        AND original_name LIKE '%复审可行性方案%'""")
        # 续展截止日只属于已注册商标。历史导入曾可能把公告日误写到该字段，
        # 启动时自动清理，避免未注册案件被误判为“已到期”。
        db.execute("""UPDATE trademarks SET renewal_date=NULL
                      WHERE COALESCE(renewal_date,'')<>''
                        AND status NOT IN ('已注册','注册')""")
        db.execute("""UPDATE trademarks SET renewal_date=NULL
                      WHERE status IN ('已注册','注册')
                        AND COALESCE(reg_date,'')<>''
                        AND COALESCE(renewal_date,'')<>''
                        AND renewal_date<=reg_date""")
        # 专用权期间本身已经包含有效期截止日。历史导入未单独填写续展截止日时，
        # 从“YYYY-MM-DD至YYYY-MM-DD”中补齐末日，避免体检和续展预警把已有信息报成缺失。
        for tm in db.execute("""SELECT id, reg_date, exclusive_right_period
                               FROM trademarks
                               WHERE status IN ('已注册','注册')
                                 AND COALESCE(renewal_date,'')=''
                                 AND COALESCE(exclusive_right_period,'')<>''""").fetchall():
            dates = re.findall(r'(?:19|20)\d{2}[-/.年]\d{1,2}[-/.月]\d{1,2}', str(tm['exclusive_right_period'] or ''))
            if len(dates) < 2:
                continue
            raw = dates[-1].replace('年', '-').replace('月', '-').replace('日', '').replace('/', '-').replace('.', '-')
            try:
                end_date = date.fromisoformat(raw[:10])
                reg_raw = str(tm['reg_date'] or '').strip()
                if reg_raw and end_date <= date.fromisoformat(reg_raw[:10]):
                    continue
                db.execute("UPDATE trademarks SET renewal_date=? WHERE id=?", (end_date.isoformat(), tm['id']))
            except (TypeError, ValueError):
                continue
        # 数据库兜底：即使将来新增导入方式或遗漏接口校验，也不能把未注册商标
        # 写成存在续展截止日。
        db.execute("""CREATE TRIGGER IF NOT EXISTS trg_tm_renewal_guard_insert
                      AFTER INSERT ON trademarks
                      WHEN COALESCE(NEW.renewal_date,'')<>''
                       AND (
                            NEW.status NOT IN ('已注册','注册')
                            OR date(NEW.renewal_date) IS NULL
                            OR (
                                COALESCE(NEW.reg_date,'')<>''
                                AND NEW.renewal_date<=NEW.reg_date
                            )
                       )
                      BEGIN
                        UPDATE trademarks SET renewal_date=NULL WHERE id=NEW.id;
                      END""")
        db.execute("""CREATE TRIGGER IF NOT EXISTS trg_tm_renewal_guard_update
                      AFTER UPDATE OF status, reg_date, renewal_date ON trademarks
                      WHEN COALESCE(NEW.renewal_date,'')<>''
                       AND (
                            NEW.status NOT IN ('已注册','注册')
                            OR date(NEW.renewal_date) IS NULL
                            OR (
                                COALESCE(NEW.reg_date,'')<>''
                                AND NEW.renewal_date<=NEW.reg_date
                            )
                       )
                      BEGIN
                        UPDATE trademarks SET renewal_date=NULL WHERE id=NEW.id;
                      END""")
        # Referential guards for legacy tables that predate SQLite foreign-key clauses.
        for operation in ('INSERT', 'UPDATE OF item_type, item_id'):
            suffix = 'insert' if operation == 'INSERT' else 'update'
            db.execute(f"""CREATE TRIGGER IF NOT EXISTS trg_documents_patent_guard_{suffix}
                           BEFORE {operation} ON documents
                           WHEN NEW.item_type='patent'
                            AND NOT EXISTS(SELECT 1 FROM patents WHERE id=NEW.item_id)
                           BEGIN SELECT RAISE(ABORT, '关联专利不存在'); END""")
            db.execute(f"""CREATE TRIGGER IF NOT EXISTS trg_documents_trademark_guard_{suffix}
                           BEFORE {operation} ON documents
                           WHEN NEW.item_type IN ('trademark','trademark_evidence')
                            AND NOT EXISTS(SELECT 1 FROM trademarks WHERE id=NEW.item_id)
                           BEGIN SELECT RAISE(ABORT, '关联商标不存在'); END""")
            db.execute(f"""CREATE TRIGGER IF NOT EXISTS trg_documents_copyright_guard_{suffix}
                           BEFORE {operation} ON documents
                           WHEN NEW.item_type='copyright'
                            AND NOT EXISTS(SELECT 1 FROM copyrights WHERE id=NEW.item_id)
                           BEGIN SELECT RAISE(ABORT, '关联软著不存在'); END""")
        db.execute("""CREATE TRIGGER IF NOT EXISTS trg_fee_payment_patent_guard_insert
                      BEFORE INSERT ON fee_payments
                      WHEN NOT EXISTS(SELECT 1 FROM patents WHERE id=NEW.patent_id)
                      BEGIN SELECT RAISE(ABORT, '关联专利不存在'); END""")
        db.execute("""CREATE TRIGGER IF NOT EXISTS trg_fee_payment_patent_guard_update
                      BEFORE UPDATE OF patent_id ON fee_payments
                      WHEN NOT EXISTS(SELECT 1 FROM patents WHERE id=NEW.patent_id)
                      BEGIN SELECT RAISE(ABORT, '关联专利不存在'); END""")
        _ensure_document_hashes(db, limit=2000)
        for row in db.execute("""
            SELECT id FROM trademarks
            WHERE type<>'图形' AND COALESCE(logo_filename,'')<>''
        """).fetchall():
            clear_trademark_logo(db, row['id'])
    print("✅ 数据库初始化完成")
    # 自动备份在后台低频运行，不阻塞服务启动；可用环境变量在测试/维护时关闭。
    if not AUTO_BACKUP_STARTED and os.environ.get('IPKEEPER_DISABLE_AUTO_BACKUP', '').lower() not in ('1', 'true', 'yes'):
        AUTO_BACKUP_STARTED = True
        threading.Thread(target=_auto_backup_worker, name='ipkeeper-auto-backup', daemon=True).start()

def row_to_dict(row):
    d = dict(row)
    for k in ('tags',):
        if k in d and d[k]:
            try: d[k] = json.loads(d[k])
            except: d[k] = []
    return d


def copyright_row_to_dict(row):
    d = row_to_dict(row)
    d['protection_end_date'] = None
    d['protection_note'] = '保护期需结合著作权人主体、首次发表及自然人死亡信息人工核验'
    first_pub = _to_date(d.get('first_publication_date'))
    death_date = _to_date(d.get('death_date'))
    if d.get('owner_type') == '法人或其他组织' and first_pub:
        d['protection_end_date'] = date(first_pub.year + 50, 12, 31).isoformat()
        d['protection_note'] = '法人或其他组织：首次发表后第50年12月31日（管理估算）'
    elif d.get('owner_type') == '自然人':
        if death_date:
            d['protection_end_date'] = date(death_date.year + 50, 12, 31).isoformat()
            d['protection_note'] = '自然人：死亡后第50年12月31日（管理估算）'
        else:
            d['protection_note'] = '自然人：终生及死亡后50年；请补充死亡日期以计算保护期'
    elif d.get('owner_type'):
        d['protection_note'] = '主体类型需核验；法人/其他组织按首次发表后50年，自然人按死亡后50年计算'
    d['protection_model'] = 'life_plus_50' if d.get('owner_type') == '自然人' else ('publication_plus_50' if d.get('owner_type') == '法人或其他组织' else 'manual_review')
    d['protection_verified'] = bool(d.get('protection_end_date'))
    return d

def patent_row_to_dict(row):
    d = row_to_dict(row)
    inactive_statuses = {'失效', '已驳回', '主动撤回', '视为撤回', '已期满'}
    fee_eligible_status = d.get('status') in ('已授权', '授权')
    if d.get('status') in inactive_statuses or not fee_eligible_status:
        computed_year = d.get('current_year')
        computed_deadline = None
    else:
        computed_year = calc_patent_current_year(
            d.get('country'), d.get('app_date'), d.get('grant_date'),
            d.get('current_year'), d.get('next_fee_date'), d.get('type'),
            fee_route=d.get('fee_route'))
        computed_deadline = calc_patent_next_fee_date(
            d.get('country'), d.get('app_date'), d.get('grant_date'),
            computed_year if computed_year is not None else d.get('current_year'),
            d.get('next_fee_date'), d.get('type'), d.get('fee_route'))
    # 已保存的“保护期结束后阶段”（例如实用新型第11年）用于表达案件已
    # 没有下一笔国内年费；不能因计算函数返回 None 而丢掉这个状态。
    d['current_year'] = computed_year if computed_year is not None else d.get('current_year')
    d['next_fee_date'] = computed_deadline
    d['fee_windows'] = None
    if _is_china(d.get('country')) and computed_deadline:
        due = _to_date(computed_deadline)
        if due:
            d['fee_windows'] = {'statutory_deadline': computed_deadline,
                'no_surcharge_until': _add_months(due,1).isoformat(),
                'supplement_until': _add_months(due,6).isoformat(),
                'note': '补缴窗口仅适用于授权当年以后的年费；授权当年按登记通知缴纳。'}
    if _is_china(d.get('country')):
        d['fee_rule'] = {
            'country': '中国',
            'term_year': patent_term_years(d.get('type'), d.get('app_date')),
            'rule_version': PATENT_FEE_RULE_VERSION,
            'source_url': CNIPA_FEE_REDUCTION_URL,
            'note': '按官方确认的费减资格和比例执行；授权当年起10年内适用，超过后按全额估算。',
        }
        if fee_eligible_status and d.get('current_year') not in (None, ''):
            d['fee_quote'] = calculate_cn_annual_fee(
                d.get('type'), d.get('current_year'),
                d.get('fee_entity') or '无费减',
                d.get('app_date'), d.get('grant_date'),
                d.get('next_fee_date'), owner=d.get('owner'),
                fee_reduction_approved=d.get('fee_reduction_approved'),
                fee_reduction_status=d.get('fee_reduction_status'),
                fee_reduction_ratio=d.get('fee_reduction_ratio'),
                fee_reduction_effective_from=d.get('fee_reduction_effective_from'),
                fee_reduction_effective_to=d.get('fee_reduction_effective_to'),
            )
        else:
            d['fee_quote'] = None
    else:
        d['fee_rule'] = foreign_patent_rule_summary(
            d.get('country'), d.get('type'), d.get('fee_route'))
        d['fee_quote'] = None
    return d

def ok(data=None, **kw): return jsonify({"ok": True, "data": data, **kw})
def err(msg, code=400): return jsonify({"ok": False, "error": msg}), code
def now_str(): return datetime.now().strftime("%Y-%m-%d %H:%M:%S")

def clear_trademark_logo(db, tid):
    row = db.execute("SELECT name,logo_filename FROM trademarks WHERE id=?", (tid,)).fetchone()
    if row and row['logo_filename']:
        _trash_add(db, 'trademark_logo', tid, f"{row['name']} · 商标图", {
            'version': 1,
            'trademark_id': tid,
            'logo_filename': row['logo_filename'],
        })
    db.execute("UPDATE trademarks SET logo_filename='',updated_at=? WHERE id=?", (now_str(), tid))

@app.after_request
def add_cors(resp):
    origin = request.headers.get('Origin', '')
    if origin in {f'http://127.0.0.1:{WEB_PORT}', f'http://localhost:{WEB_PORT}'}:
        resp.headers['Access-Control-Allow-Origin'] = origin
        resp.headers['Vary'] = 'Origin'
        resp.headers['Access-Control-Allow-Headers'] = 'Content-Type'
        resp.headers['Access-Control-Allow-Methods'] = 'GET,POST,PUT,DELETE,OPTIONS'
    resp.headers['X-Content-Type-Options'] = 'nosniff'
    # 附件预览在附件中心的同源 iframe 中展示；普通页面仍禁止被嵌入。
    is_attachment_preview = (
        (request.path.startswith('/api/documents/') and request.path.endswith('/preview'))
        or request.path == '/api/watch/preview'
    )
    resp.headers['X-Frame-Options'] = 'SAMEORIGIN' if is_attachment_preview else 'DENY'
    resp.headers['Cross-Origin-Resource-Policy'] = 'same-origin'
    resp.headers['Content-Security-Policy'] = (
        "default-src 'self'; base-uri 'self'; object-src 'none'; "
        + ("frame-ancestors 'self'; " if is_attachment_preview else "frame-ancestors 'none'; ")
        + "form-action 'self'; connect-src 'self'; "
        "img-src 'self' data: blob:; frame-src 'self' blob:; "
        "script-src 'self'; style-src 'self' 'unsafe-inline'"
    )
    resp.headers['Referrer-Policy'] = 'no-referrer'
    resp.headers['Cache-Control'] = 'no-store' if request.path.startswith('/api/') else 'no-cache'
    return resp

@app.before_request
def protect_local_api():
    """网页端只接受本机访问，避免本地数据接口被外部网络直接暴露。"""
    if not request.path.startswith('/api/'):
        return None
    if request.remote_addr not in ('127.0.0.1', '::1'):
        return err('仅允许本机访问', 403)
    if request.method not in ('GET', 'HEAD', 'OPTIONS'):
        allowed_origins = {
            f'http://127.0.0.1:{WEB_PORT}',
            f'http://localhost:{WEB_PORT}',
            f'http://[::1]:{WEB_PORT}',
        }
        fetch_site = str(request.headers.get('Sec-Fetch-Site') or '').lower()
        origin = str(request.headers.get('Origin') or '')
        referer = str(request.headers.get('Referer') or '')
        if fetch_site == 'cross-site':
            return err('已阻止跨站写入请求', 403)
        if origin and origin not in allowed_origins:
            return err('请求来源不受信任', 403)
        if not origin and referer and not any(
            referer == allowed or referer.startswith(allowed + '/')
            for allowed in allowed_origins
        ):
            return err('请求来源不受信任', 403)
    if MAINTENANCE_MODE and request.path not in {
        '/api/backup/restore', '/api/backup/status'
    }:
        return err('正在安全恢复数据，请稍候', 503)
    return None

@app.route('/', defaults={'path': ''})
@app.route('/<path:path>')
def serve_static(path):
    if path == 'api' or path.startswith('api/'):
        return err('接口不存在，请确认服务已更新并重启', 404)
    if path and (STATIC_DIR / path).exists(): return send_from_directory(str(STATIC_DIR), path)
    return send_from_directory(str(STATIC_DIR), 'index.html')

# ── 状态历史工具 ──
def record_status_change(db, item_type, item_id, old_status, new_status, note='', operator=''):
    if old_status == new_status: return
    try:
        cur = db.execute(
            "INSERT INTO status_history (item_type,item_id,old_status,new_status,note,operator) VALUES (?,?,?,?,?,?)",
            (item_type, item_id, old_status, new_status, note, operator))
        db.execute(
            """INSERT INTO legal_events
               (item_type,item_id,event_type,event_date,effective_date,details,operator,confirmed_at)
               VALUES (?,?,?,?,?,?,?,?)""",
            (item_type, item_id, 'status_transition', now_str()[:10], now_str()[:10],
             json.dumps({'old_status': old_status, 'new_status': new_status, 'note': note}, ensure_ascii=False),
             operator or '', now_str()))
    except Exception:
        pass  # status_history table may not exist in older DBs

# ══════════════ PATENTS ══════════════
def calc_current_year(app_date: str, given_year=None) -> int:
    """根据申请日自动计算当前年度（第几年年费）"""
    if given_year and int(given_year) > 1:
        return int(given_year)
    if not app_date:
        return given_year or 1
    try:
        from datetime import date
        app_y = int(str(app_date)[:4])
        cur_y = date.today().year
        yr = cur_y - app_y + 1
        return max(1, yr)
    except Exception:
        return given_year or 1








def _upsert_deadline_task(db, item_type, item_id, kind, title, deadline, payload=None,
                          event_id=None, priority='normal', rule_version=''):
    """Create/update one canonical deadline task without reopening completed work."""
    if not deadline:
        return None
    base_key = f'{kind}:{item_type}:{item_id}'
    # Each annual fee / notice is a separate occurrence. Completed work must not
    # suppress the next year's fee or a later notice of the same kind.
    basis = (payload or {}).get('basis') or {}
    occurrence = hashlib.sha256(json.dumps([deadline, basis], sort_keys=True).encode()).hexdigest()[:20]
    task_key = f'{base_key}:{occurrence}'
    legacy = db.execute('SELECT * FROM deadline_tasks WHERE task_key=?', (base_key,)).fetchone()
    if legacy:
        previous_date = legacy['estimated_deadline'] or legacy['deadline']
        migrated_key = task_key if previous_date == deadline else base_key + ':legacy:' + str(legacy['id'])
        db.execute('UPDATE deadline_tasks SET task_key=? WHERE id=?', (migrated_key, legacy['id']))
    body = json.dumps(payload or {}, ensure_ascii=False)
    estimated_deadline = deadline
    row = db.execute("SELECT id,status,deadline_source,official_deadline,override_reason FROM deadline_tasks WHERE task_key=?", (task_key,)).fetchone()
    if row:
        if row['deadline_source'] == 'official_document' and row['official_deadline']:
            deadline = row['official_deadline']
        db.execute("""UPDATE deadline_tasks SET item_type=?,item_id=?,event_id=COALESCE(?,event_id),kind=?,title=?,deadline=?,
                      priority=?,rule_version=?,deadline_source=?,official_deadline=?,estimated_deadline=?,override_reason=?,payload=?,updated_at=?
                      WHERE task_key=?""",
                   (item_type, item_id, event_id, kind, title, deadline, priority,
                    rule_version, row['deadline_source'] or 'rule', row['official_deadline'], estimated_deadline, row['override_reason'] or '', body, now_str(), task_key))
        return row['id']
    cur = db.execute("""INSERT INTO deadline_tasks
        (task_key,item_type,item_id,event_id,kind,title,deadline,status,priority,rule_version,source,deadline_source,estimated_deadline,payload)
        VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?)""",
        (task_key, item_type, item_id, event_id, kind, title, deadline, 'pending', priority,
         rule_version, 'deadline_engine', 'rule', deadline, body))
    return cur.lastrowid


def sync_deadline_tasks(db):
    """Materialize all current legal deadlines into the canonical task table."""
    db.execute('''CREATE TABLE IF NOT EXISTS data_correction_log (
        id INTEGER PRIMARY KEY, item_type TEXT, item_id INTEGER, field TEXT,
        old_value TEXT, new_value TEXT, reason TEXT, created_at TEXT)''')
    created = 0
    active_keys = set()

    def add(item_type, row, kind, title, deadline, info=None, priority='normal'):
        nonlocal created
        if not deadline:
            return
        task_id = _upsert_deadline_task(
            db, item_type, row['id'], kind, title, deadline,
            payload={'case_title': row.get('title') or row.get('name'),
                     'basis': {'oa_round': row.get('oa_round')} if kind == 'patent_oa_response' else {},
                     'app_no': row.get('app_no'), 'owner': row.get('owner'),
                     'classes': row.get('classes'), 'type': row.get('type'),
                     'country': row.get('country'), 'current_year': row.get('current_year'),
                     'fee_entity': row.get('fee_entity'), 'rule': info or {}},
            priority=priority, rule_version=(info or {}).get('rule_version', ''))
        if task_id:
            active_keys.add(task_id)
            created += 1

    for raw in db.execute("SELECT * FROM patents WHERE status IN ('已授权','授权')").fetchall():
        r = row_to_dict(raw)
        cy = calc_patent_current_year(r.get('country'), r.get('app_date'), r.get('grant_date'),
                                      r.get('current_year'), r.get('next_fee_date'), r.get('type'),
                                      fee_route=r.get('fee_route'))
        deadline = calc_patent_next_fee_date(r.get('country'), r.get('app_date'), r.get('grant_date'),
                                             cy if cy is not None else r.get('current_year'),
                                             r.get('next_fee_date'), r.get('type'), r.get('fee_route'))
        if _is_china(r.get('country')) and deadline != r.get('next_fee_date'):
            db.execute('INSERT INTO data_correction_log(item_type,item_id,field,old_value,new_value,reason,created_at) VALUES(?,?,?,?,?,?,?)',
                       ('patent',r['id'],'next_fee_date',r.get('next_fee_date'),deadline,
                        '统一年费引擎派生缓存；不改变已缴年度或缴费记录',now_str()))
            db.execute('UPDATE patents SET next_fee_date=? WHERE id=?',(deadline,r['id']))
        if deadline:
            add('patent', r, 'patent_fee', '专利年费', deadline,
                {'rule_version': PATENT_FEE_RULE_VERSION}, 'high')
        if r.get('oa_date') and r.get('status') in ('实审中','审查中'):
            info = calculate_legal_deadline('patent_oa_response', r['oa_date'], oa_round=r.get('oa_round'))
            add('patent', r, 'patent_oa_response', info['label'], info['deadline'], info, 'high')

    for raw in db.execute("SELECT * FROM patents WHERE country IN ('中国','中华人民共和国','CN','China','CHINA','PRC','P.R.C.')").fetchall():
        r = row_to_dict(raw)
        if r.get('oa_date') and r.get('status') in ('实审中','审查中'):
            info = calculate_legal_deadline('patent_oa_response', r['oa_date'], oa_round=r.get('oa_round'))
            add('patent', r, 'patent_oa_response', info['label'], info['deadline'], info, 'high')
        if r.get('status') == '已驳回' and r.get('rejection_date'):
            info = calculate_legal_deadline('patent_rejection_review', r['rejection_date'])
            add('patent', r, 'patent_rejection_review', info['label'], info['deadline'], info, 'high')
        if r.get('status') in ('待登记','已授权','授权') and r.get('grant_notice_date') and not r.get('grant_date'):
            info = calculate_legal_deadline('patent_grant_pay', r['grant_notice_date'])
            add('patent', r, 'patent_grant_pay', info['label'], info['deadline'], info, 'high')
        if r.get('type') == '发明' and r.get('status') in ('已受理','初审中','已公开','公开') and r.get('app_date'):
            info = calculate_legal_deadline('patent_exam_request', r['app_date'])
            add('patent', r, 'patent_exam_request', info['label'], info['deadline'], info, 'normal')
        if r.get('status') in ('已授权','授权') and r.get('app_date'):
            info = calculate_legal_deadline('patent_expire', r['app_date'], patent_type=r['type'])
            add('patent', r, 'patent_expire', info['label'], info['deadline'], info, 'normal')

    for raw in db.execute("SELECT * FROM trademarks").fetchall():
        r = row_to_dict(raw)
        if r.get('status') in ('已注册','注册') and r.get('renewal_date'):
            add('trademark', r, 'tm_renewal', '商标续展', r['renewal_date'], priority='high')
        if r.get('status') == '已驳回' and r.get('rejection_date'):
            info = calculate_legal_deadline('tm_rejection_review', r['rejection_date'])
            add('trademark', r, 'tm_rejection_review', info['label'], info['deadline'], info, 'high')
        if r.get('status') == '复审中' and r.get('rejection_date'):
            if not r.get('review_simple_submitted_date'):
                info = calculate_legal_deadline('tm_rejection_simple', r['rejection_date'])
                add('trademark', r, 'tm_rejection_simple', info['label'], info['deadline'], info, 'high')
            elif not r.get('review_complete_submitted_date'):
                info = calculate_legal_deadline('tm_rejection_complete', r['rejection_date'])
                add('trademark', r, 'tm_rejection_complete', info['label'], info['deadline'], info, 'high')
        if r.get('status') == '初审公告' and r.get('pub_date'):
            info = calculate_legal_deadline('tm_opposition_period', r['pub_date'])
            add('trademark', r, 'tm_opposition_period', info['label'], info['deadline'], info, 'high')
        if r.get('status') == '异议中' and r.get('opposition_notice_date'):
            info = calculate_legal_deadline('tm_opposition_response', r['opposition_notice_date'])
            add('trademark', r, 'tm_opposition_response', info['label'], info['deadline'], info, 'high')
    # 任何不再由当前案件状态/阶段产生的待办，统一标记为已替代。
    for old in db.execute("SELECT id,task_key FROM deadline_tasks WHERE status IN ('pending','in_progress')").fetchall():
        if old['id'] not in active_keys:
            db.execute("UPDATE deadline_tasks SET status='superseded',updated_at=? WHERE task_key=?",
                       (now_str(), old['task_key']))
    return created


def deadline_tasks_for_response(db, days=3650):
    sync_deadline_tasks(db)
    thresholds = alert_thresholds_for_db(db)
    cutoff = (date.today() + timedelta(days=days)).isoformat()
    rows = db.execute("""SELECT * FROM deadline_tasks
                        WHERE status NOT IN ('completed','ignored','superseded')
                          AND deadline<=?
                        ORDER BY deadline,id""", (cutoff,)).fetchall()
    out = []
    for row in rows:
        item = dict(row)
        try:
            item['payload'] = json.loads(item.get('payload') or '{}')
        except Exception:
            item['payload'] = {}
        item['days'] = (date.fromisoformat(item['deadline'][:10]) - date.today()).days
        item['level'] = alert_level_for_days(item['days'], thresholds)
        out.append(item)
    return out


def _alert_thresholds_from_settings(settings_map):
    """预警风险等级的唯一配置源：系统设置中的两个阈值。"""
    def safe_int(key, fallback, minimum=1, maximum=365):
        try:
            return max(minimum, min(maximum, int(settings_map.get(key, fallback))))
        except (TypeError, ValueError):
            return fallback

    urgent = safe_int('alert_urgent_days', 14)
    soon = max(urgent, safe_int('alert_soon_days', 30))
    return {'urgent': urgent, 'soon': soon}


def alert_thresholds_for_db(db):
    rows = db.execute(
        "SELECT key,value FROM settings WHERE key IN ('alert_urgent_days','alert_soon_days')"
    ).fetchall()
    return _alert_thresholds_from_settings({row['key']: row['value'] for row in rows})


def alert_level_for_days(days, thresholds):
    if days < 0:
        return 'overdue'
    if days <= thresholds['urgent']:
        return 'urgent'
    if days <= thresholds['soon']:
        return 'soon'
    return 'upcoming'


@app.route('/api/deadline-tasks', methods=['GET','PATCH','OPTIONS'])
def deadline_tasks_api():
    if request.method == 'OPTIONS': return ok()
    with get_db() as db:
        if request.method == 'PATCH':
            d = _json_payload()
            task_id = d.get('id')
            task = db.execute('SELECT * FROM deadline_tasks WHERE id=?',(task_id,)).fetchone()
            if not task: return err('期限任务不存在',404)
            status = str(d.get('status') or '').strip()
            if status and status not in ('pending','in_progress','waiting','completed','ignored','superseded'):
                return err('任务状态无效', 400)
            fields=[]; values=[]
            if status:
                fields += ['status=?','completed_at=?']; values += [status, now_str() if status == 'completed' else None]
            if d.get('official_deadline'):
                try: date.fromisoformat(str(d['official_deadline'])[:10])
                except ValueError: return err('官方期限格式无效',400)
                doc = db.execute('SELECT * FROM documents WHERE id=? AND item_type=? AND item_id=?',
                                 (d.get('source_document_id'),task['item_type'],task['item_id'])).fetchone()
                reason = str(d.get('override_reason') or '').strip()
                if not doc or d.get('confirmed') is not True or not reason:
                    return err('请关联本案件官文、填写核验说明并确认官方期限',400)
                event = db.execute('''INSERT INTO legal_events(item_type,item_id,event_type,event_date,effective_date,source_document_id,details,operator,confirmed_at)
                    VALUES(?,?,?,?,?,?,?,?,?)''',(task['item_type'],task['item_id'],'official_deadline_confirmed',doc['received_date'],
                    str(d['official_deadline'])[:10],doc['id'],json.dumps({'task_id':task_id,'estimated_deadline':task['estimated_deadline'] or task['deadline'],'previous_official_deadline':task['official_deadline'],'reason':reason},ensure_ascii=False),'人工文书复核',now_str()))
                db.execute('''INSERT INTO field_provenance(item_type,item_id,field,value,source_document_id,confidence,extraction_method,confirmed_by,confirmed_at)
                    VALUES(?,?,?,?,?,1.0,'manual_document_confirmation','人工文书复核',?)''',
                    (task['item_type'],task['item_id'],'deadline_tasks.'+str(task_id)+'.official_deadline',str(d['official_deadline'])[:10],doc['id'],now_str()))
                fields += ['event_id=?','estimated_deadline=COALESCE(estimated_deadline,deadline)']; values += [event.lastrowid]
                fields += ['deadline=?','official_deadline=?','deadline_source=?','override_reason=?']; values += [str(d['official_deadline'])[:10],str(d['official_deadline'])[:10],'official_document',str(d.get('override_reason') or '')]
            if not fields: return err('没有可更新的任务字段',400)
            fields.append('updated_at=?'); values += [now_str(), task_id]
            db.execute("UPDATE deadline_tasks SET " + ','.join(fields) + " WHERE id=?", values)
            return ok()
        try:
            days = max(1, min(3650, int(request.args.get('days', 3650))))
        except (TypeError, ValueError):
            days = 3650
        if request.args.get('include_closed') == '1':
            sync_deadline_tasks(db)
            return ok([dict(r) for r in db.execute("SELECT * FROM deadline_tasks WHERE status<>'superseded' ORDER BY deadline,id")])
        return ok(deadline_tasks_for_response(db, days))

def _next_anniversary_after(app_d: date, after_d: date, start_year: int = 4, term_year: int = 20):
    """返回 filing date 的下一个周年日（严格晚于 after_d）。"""
    if not app_d or not after_d:
        return None
    for year_no in range(start_year, term_year + 1):
        ann = _add_years(app_d, year_no - 1)
        if ann and ann > after_d:
            return ann
    return None

FOREIGN_FEE_RULES = {
    # 说明：
    # - basis：计算基准日
    # - mode：到期日生成方式
    # - stages / start_year：对应年费阶段
    # - grace_months：宽限期（月）
    # - early_months：可提前缴费窗口（月）
    # - note：给前端/详情页展示的规则摘要
    '美国': {
        'aliases': ['US', 'USA', 'UNITED STATES', 'UNITED STATES OF AMERICA'],
        'mode': 'milestone',
        'basis': 'grant_date',
        'stages': [3.5, 7.5, 11.5],
        'early_months': 6,
        'grace_months': 6,
        'term_year': 20,
        'note': '授权日计；3.5/7.5/11.5年缴费，提前6个月可缴，逾期6个月宽限。',
        'source_url': USPTO_MAINTENANCE_URL,
    },
    '日本': {
        'aliases': ['JP', 'JAPAN'],
        'mode': 'annual',
        'basis': 'grant_date',
        'start_year': 4,
        'term_year': 20,
        'early_months': 0,
        'grace_months': 6,
        'note': '授权日计；前3年通常在授权登记时一次缴清，第4年起按年缴，截止日按上一年度末或通知书所示。',
    },
    '韩国': {
        'aliases': ['KR', 'KOREA', 'REPUBLIC OF KOREA', 'SOUTH KOREA'],
        'mode': 'annual',
        'basis': 'grant_date',
        'start_year': 4,
        'term_year': 20,
        'early_months': 0,
        'grace_months': 6,
        'note': '登记日计；前3年在设置登记时处理，第4年起按年缴到届满。',
    },
    '新加坡': {
        'aliases': ['SG', 'SINGAPORE'],
        'mode': 'annual',
        'basis': 'app_date',
        'start_year': 4,
        'term_year': 20,
        'early_months': 3,
        'grace_months': 6,
        'note': '申请日计；第4年起按年续缴，可提前3个月，逾期6个月可补缴。',
    },
    '南非': {
        'aliases': ['ZA', 'SOUTH AFRICA'],
        'mode': 'annual',
        'basis': 'app_date',
        'start_year': 4,
        'term_year': 20,
        'early_months': 0,
        'grace_months': 6,
        'note': '申请日计；自第4年起按年缴，首缴通常对应第3个周年节点，逾期6个月内可补缴并加罚金。',
    },
    '荷兰': {
        'aliases': ['NL', 'NETHERLANDS', 'HOLLAND'],
        'mode': 'annual_month_end',
        'basis': 'app_date',
        'start_year': 4,
        'term_year': 20,
        'early_months': 0,
        'grace_months': 6,
        'note': '申请日计；第4年起按年缴，首缴为申请月月底对应的第3个周年节点，逾期6个月加50%罚金。',
    },
    '欧洲单一专利': {
        'aliases': ['UNITARY PATENT', 'UP', '欧洲单一专利'],
        'mode': 'annual_month_end',
        'basis': 'app_date',
        'start_year': 2,
        'term_year': 20,
        'early_months': 3,
        'grace_months': 6,
        'note': '单一专利授权后向EPO集中缴纳；到期日为申请日周年所在月月末。请核对单一效力登记与官方账单。',
        'source_url': EPO_UNITARY_RENEWAL_URL,
    },
}

_FOREIGN_RULE_LOOKUP = {}
for _canon, _rule in FOREIGN_FEE_RULES.items():
    _FOREIGN_RULE_LOOKUP[_canon.upper()] = _canon
    for _alias in _rule.get('aliases', []):
        _FOREIGN_RULE_LOOKUP[str(_alias).strip().upper()] = _canon

def _normalize_country(country):
    c = (country or '').strip()
    if not c:
        return '中国'
    if c.upper() in {'CN', 'CHINA', 'PRC', 'P.R.C.'} or c in {'中国', '中华人民共和国'}:
        return '中国'
    return _FOREIGN_RULE_LOOKUP.get(c.upper(), c)


def _is_china(country):
    return _normalize_country(country) == '中国'

FEE_ROUTES = {'auto', 'manual', 'unitary_patent', 'ep_validated', 'epo_application'}

def _normalize_fee_route(route):
    value = str(route or 'auto').strip().lower()
    aliases = {'官方账单': 'manual', '单一专利': 'unitary_patent', '欧洲单一专利': 'unitary_patent'}
    value = aliases.get(value, value)
    return value if value in FEE_ROUTES else 'manual'


def _safe_patent_fee_route(country, patent_type=None, route='auto'):
    """Prevent unsupported foreign rights from using a generic auto route."""
    normalized = _normalize_fee_route(route)
    if normalized != 'auto' or _is_china(country):
        return normalized
    normalized_country = _normalize_country(country)
    european = normalized_country in {'欧盟', '欧洲', 'EP', 'EPO', 'EU'}
    non_invention = patent_type and norm_patent_type(patent_type) != '发明'
    return 'manual' if european or non_invention else normalized

def _json_list(value, default=None):
    if default is None:
        default = []
    if value is None or value == '':
        return default
    if isinstance(value, str):
        try:
            parsed = json.loads(value)
            return parsed if isinstance(parsed, list) else default
        except Exception:
            return default
    if isinstance(value, list):
        return value
    return default

def _patent_fee_rule(country, patent_type=None, fee_route='auto'):
    normalized = _normalize_country(country)
    route = str(fee_route or 'auto').strip()
    if route in ('manual', 'ep_validated', 'epo_application'):
        return None
    if route == 'unitary_patent':
        return FOREIGN_FEE_RULES.get('欧洲单一专利')
    # Foreign design, utility-model and plant rights use materially different
    # national rules. They must use an official/manual deadline until a
    # dedicated rule exists.
    if patent_type and norm_patent_type(patent_type) != '发明':
        return None
    if normalized in {'欧盟', '欧洲', 'EP', 'EPO', 'EU'}:
        return None
    return FOREIGN_FEE_RULES.get(normalized)

def foreign_patent_rule_summary(country, patent_type=None, fee_route='auto'):
    rule = _patent_fee_rule(country, patent_type, fee_route)
    if not rule:
        return {
            'country': _normalize_country(country),
            'mode': 'manual',
            'requires_verification': True,
            'rule_version': RULESET_VERSION,
            'note': '该权利类型或申请路线没有安全的统一自动规则，请录入并核对官方截止日。',
        }
    return {
        'country': _normalize_country(country),
        'mode': rule['mode'],
        'basis': rule['basis'],
        'start_year': rule.get('start_year'),
        'stages': rule.get('stages'),
        'early_months': rule.get('early_months', 0),
        'grace_months': rule.get('grace_months', 0),
        'term_year': rule.get('term_year', 20),
        'note': rule.get('note', ''),
        'source_url': rule.get('source_url', ''),
        'rule_version': RULESET_VERSION,
        'requires_verification': True,
    }

def calc_patent_current_year(country, app_date=None, grant_date=None, given_year=None,
                             next_fee_date=None, patent_type='发明', as_of=None,
                             fee_route='auto'):
    """根据国家规则计算应显示的年度/缴费阶段。

    国内专利仍沿用原有申请日年度逻辑；国外专利按国家规则保留阶段号。
    """
    country = _normalize_country(country)
    rule = _patent_fee_rule(country, patent_type, fee_route)
    if _is_china(country):
        # 已保存的年度是“当期待缴”状态，不得因日期过期而自动翻年。
        # 只有确认缴费或新增缴费记录才能推进；无已存年度时才按今天初始化。
        if given_year not in (None, ''):
            try:
                recorded = int(float(given_year))
            except (TypeError, ValueError):
                recorded = 1
            term = patent_term_years(patent_type, app_date)
            return recorded if recorded >= 1 and (not term or recorded <= term) else None
        app_d = _to_date(app_date)
        if app_d:
            today = _to_date(as_of) or date.today()
            base_yr = today.year - app_d.year + 1
            # 这里只能根据日历推算“当前申请年度”。不能假设上一年度已经缴费，
            # 因此不因已过周年日再自动翻到下一年；已缴费后的推进由缴费记录负责。
            yr = max(1, base_yr)
            term = patent_term_years(patent_type, app_date)
            return yr if not term or yr <= term else None
        return 1

    if given_year not in (None, ''):
        try:
            v = float(given_year)
            return int(v) if v.is_integer() else v
        except Exception:
            pass

    if not rule:
        # 未配置规则的国外案件不套用中国年度，等待手工维护。
        return None

    if rule['mode'] == 'milestone':
        return 3.5
    if rule['mode'] in ('annual', 'annual_month_end'):
        return int(rule.get('start_year', 4))
    return calc_current_year(app_date, given_year)

def calc_patent_next_fee_date(country, app_date=None, grant_date=None,
                              current_year=None, next_fee_date=None,
                              patent_type='发明', fee_route='auto'):
    """根据国家规则计算下一次缴费绝限日。

    涉外专利按国家规则自动计算；国内专利若已有历史截止日则保留原值。
    """
    country = _normalize_country(country)
    rule = _patent_fee_rule(country, patent_type, fee_route)
    stored_fee_date = _to_date(next_fee_date)
    if _is_china(country):
        # 国内专利：年费日按申请日周年日计算
        app_d = _to_date(app_date)
        if app_d:
            yr = None
            if current_year not in (None, ''):
                try:
                    yr = int(float(current_year))
                except Exception:
                    pass
            if yr is None:
                yr = calc_patent_current_year(
                    country, app_date, grant_date, None, next_fee_date, patent_type
                    , fee_route=fee_route
                )
            term = patent_term_years(patent_type, app_date)
            if not yr or (term and yr > term):
                return None
            # 下一次年费日 = 申请日 + (yr-1) 年（第yr年的周年日）
            d = _add_years(app_d, yr - 1)
            if d:
                return d.isoformat()
        return next_fee_date

    if not rule:
        return next_fee_date or None

    app_d = _to_date(app_date)
    grant_d = _to_date(grant_date)
    stage = None
    try:
        if current_year not in (None, ''):
            stage = float(current_year)
    except Exception:
        stage = None

    if rule['mode'] == 'milestone':
        if not grant_d:
            return None
        stage = stage or 3.5
        if stage <= 3.5:
            d = _add_months(grant_d, 42)
        elif stage <= 7.5:
            d = _add_months(grant_d, 90)
        else:
            d = _add_months(grant_d, 138)
        return d.isoformat() if d else None

    if country == '新加坡':
        if not app_d:
            return next_fee_date if next_fee_date else None
        # 已经确认缴费并推进过的案件，必须优先使用数据库保存的下一缴费日。
        # 否则每次读取都会重新回到第 5 年首次缴费日，导致同一案件反复出现在预警中心。
        if stored_fee_date:
            return stored_fee_date.isoformat()
        first_due = _add_years(app_d, 4)  # 5th year renewal due date
        late_grant_cutoff = _add_months(app_d, 45)
        if grant_d and grant_d > late_grant_cutoff:
            first_due = _add_months(grant_d, 3)
        return first_due.isoformat() if first_due else None

    anchor = grant_d if rule.get('basis') == 'grant_date' else app_d
    if not anchor:
        return None

    if stage is None:
        stage = float(rule.get('start_year', 4))

    years_offset = max(0, int(round(stage)) - 1)
    d = _add_years(anchor, years_offset)
    if not d:
        return None
    if rule['mode'] == 'annual_month_end':
        d = _month_end(d)
    return d.isoformat()

def next_patent_fee_stage(country, current_year=None, patent_type='发明', app_date=None,
                          fee_route='auto'):
    """缴费后推进到下一阶段；国外特殊国家按其本国节奏递进。"""
    country = _normalize_country(country)
    rule = _patent_fee_rule(country, patent_type, fee_route)
    try:
        stage = float(current_year) if current_year not in (None, '') else None
    except Exception:
        stage = None

    if _is_china(country):
        nxt = (stage or 1) + 1
        term = patent_term_years(patent_type, app_date)
        return int(nxt) if not term or nxt <= term else None
    if not rule:
        return None
    if rule['mode'] == 'milestone':
        if stage is None or stage <= 3.5:
            return 7.5
        if stage <= 7.5:
            return 11.5
        return None
    if stage is None:
        stage = float(rule.get('start_year', 4))
    nxt = stage + 1
    if nxt > rule.get('term_year', 20):
        return None
    return nxt

def next_patent_fee_date_after_payment(country, app_date, grant_date, current_year,
                                       next_fee_date, patent_type='发明', fee_route='auto'):
    """缴费后推算下一次缴费日。"""
    country = _normalize_country(country)
    rule = _patent_fee_rule(country, patent_type, fee_route)
    d = _to_date(next_fee_date)
    # 若原缴费日为空，根据国家规则推算当前应缴截止日
    if not d:
        if rule:
            # 国外专利：按规则的 basis 选择基准日
            basis = rule.get('basis', 'app_date')
            anchor = _to_date(grant_date) if basis == 'grant_date' else _to_date(app_date)
            if anchor and current_year:
                try:
                    stage = float(current_year)
                    if rule['mode'] == 'milestone':
                        # 里程碑模式：3.5/7.5/11.5年，用月份计算
                        if stage <= 3.5:
                            d = _add_months(anchor, 42)
                        elif stage <= 7.5:
                            d = _add_months(anchor, 90)
                        else:
                            d = _add_months(anchor, 138)
                    else:
                        years_offset = max(0, int(round(stage)) - 1)
                        d = _add_years(anchor, years_offset)
                        if rule['mode'] == 'annual_month_end':
                            d = _month_end(d)
                except Exception:
                    d = None
        elif _is_china(country):
            # 国内专利：年费日就是申请日对应周年日。
            app_d = _to_date(app_date)
            if app_d and current_year:
                try:
                    d = _add_years(app_d, int(float(current_year)) - 1)
                except Exception:
                    d = None
    if not d:
        return None
    if _is_china(country):
        try:
            current = int(float(current_year))
        except (TypeError, ValueError):
            return None
        term = patent_term_years(patent_type, app_date)
        if term and current >= term:
            return None
        return _add_years(d, 1).isoformat()
    if not rule:
        # 未配置规则的国外案件不自动套用中国规则。
        return None
    if country == '新加坡':
        app_d = _to_date(app_date)
        if not app_d:
            return None
        grant_d = _to_date(grant_date)
        late_grant_cutoff = _add_months(app_d, 45)
        first_due = _add_years(app_d, 4)
        if grant_d and grant_d > late_grant_cutoff:
            first_due = _add_months(grant_d, 3)
        if first_due and abs((d - first_due).days) <= 2:
            nxt = _next_anniversary_after(app_d, d, 5, 20)
            return nxt.isoformat() if nxt else None
        nxt = _next_anniversary_after(app_d, d, 4, 20)
        return nxt.isoformat() if nxt else None
    if rule['mode'] == 'milestone':
        return _add_years(d, 4).isoformat()
    d2 = _add_years(d, 1)
    if rule['mode'] == 'annual_month_end':
        d2 = _month_end(d2)
    return d2.isoformat()


def norm_patent_status(v):
    s = (v or '').strip()
    if s in ('申请中','受理','已受理'): return '已受理'
    if s in ('公开','公布','已公开'): return '已公开'
    if s in ('审查中','实审','实审中','实质审查中'): return '实审中'
    if s in ('授权','已授权'): return '已授权'
    if s in ('待登记','授权待登记','办理登记中'): return '待登记'
    if s in ('驳回','已驳回'): return '已驳回'
    if s in ('撤回','主动撤回'): return '主动撤回'
    if s in ('视撤','视为撤回'): return '视为撤回'
    if s in ('无效','放弃','期满','失效'): return '失效'
    return s or '已受理'

def norm_tm_status(v):
    s = (v or '').strip()
    if s in ('申请中','受理','已受理'): return '已受理'
    if s in ('初审','初步审定','初审公告'): return '初审公告'
    if s in ('注册','已注册'): return '已注册'
    if s in ('异议','异议中'): return '异议中'
    if s in ('撤三','撤三中'): return '撤三中'
    if s in ('无效','无效中'): return '无效中'
    if s in ('撤销','已撤销'): return '已撤销'
    if s in ('期满','已期满'): return '已期满'
    if s in ('驳回','已驳回'): return '已驳回'
    if s in ('复审','复审中'): return '复审中'
    if s in ('放弃','已放弃'): return '已放弃'
    return s or '已受理'

def sanitize_tm_renewal_date(status, reg_date, renewal_date):
    """只保留已注册商标的合法续展截止日。"""
    if norm_tm_status(status) != '已注册':
        return None
    raw = str(renewal_date or '').strip()
    if not raw:
        return None
    try:
        renewal = date.fromisoformat(raw[:10])
    except (TypeError, ValueError):
        return None
    reg_raw = str(reg_date or '').strip()
    if reg_raw:
        try:
            if renewal <= date.fromisoformat(reg_raw[:10]):
                return None
        except (TypeError, ValueError):
            pass
    return renewal.isoformat()

def norm_tm_type(v):
    s = (v or '').strip()
    if s in ('组合','文字图形','文字+图形'): return '文字+图形'
    if s in ('立体','三维','三维标志'): return '三维标志'
    if '颜色' in s: return '颜色组合'
    return s or '文字'

@app.route('/api/patents', methods=['GET','POST','OPTIONS'])
def patents_api():
    if request.method == 'OPTIONS': return ok()
    if request.method == 'GET':
        q = request.args.get('q','').strip()
        status  = request.args.get('status','')
        country = request.args.get('country','').strip()
        page  = max(1, request.args.get('page', 1, type=int))
        limit = min(5000, max(1, request.args.get('limit', 1000, type=int)))
        with get_db() as db:
            sql = "SELECT * FROM patents WHERE 1=1"; params = []
            if q:
                sql += " AND (title LIKE ? OR app_no LIKE ? OR pub_no LIKE ? OR grant_no LIKE ? OR inventors LIKE ? OR owner LIKE ?)"
                p = f'%{q}%'; params += [p,p,p,p,p,p]
            if status:  sql += " AND status=?";  params.append(status)
            if country: sql += " AND country=?"; params.append(country)
            count_sql = sql.replace("SELECT *", "SELECT COUNT(*)", 1)
            total = db.execute(count_sql, params).fetchone()[0]
            rows = db.execute(sql+" ORDER BY created_at DESC LIMIT ? OFFSET ?", params + [limit, (page-1)*limit]).fetchall()
        return ok({'items': [patent_row_to_dict(r) for r in rows], 'total': total, 'page': page, 'limit': limit, 'pages': max(1, math.ceil(total/limit))})
    d = _json_payload()
    if not str(d.get('title') or '').strip():
        return err('专利名称不能为空', 400)
    app_date = d.get('app_date')
    country = _normalize_country(d.get('country', '中国'))
    p_type = norm_patent_type(d.get('type','发明'))
    fee_route = _safe_patent_fee_route(country, p_type, d.get('fee_route', 'auto'))
    recorded_year = d.get('current_year')
    current_year = calc_patent_current_year(
        country, app_date, d.get('grant_date'), d.get('current_year'),
        d.get('next_fee_date'), p_type, fee_route=fee_route)
    p_status = norm_patent_status(d.get('status','已受理'))
    next_fee_date = calc_patent_next_fee_date(
        country, app_date, d.get('grant_date'),
        current_year if current_year is not None else recorded_year,
        d.get('next_fee_date'), p_type, fee_route) if p_status in ('已授权', '授权') else None
    with get_db() as db:
        cur = db.execute("""INSERT INTO patents
            (title,app_no,pub_no,grant_no,type,country,jurisdiction,authority,filing_route,status,app_date,pub_date,grant_date,
             inventors,owner,agent,ipc,next_fee_date,current_year,fee_entity,
             fee_reduction_approved,fee_reduction_status,fee_reduction_ratio,
             fee_reduction_effective_from,fee_reduction_effective_to,fee_reduction_verified_date,fee_reduction_source,
             fee_route,fee_deadline_verified,notes,tags,
             oa_date,oa_round,rejection_date,grant_notice_date)
            VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)""",
            (d.get('title',''),d.get('app_no',''),d.get('pub_no',''),d.get('grant_no',''),
                 p_type,country,d.get('jurisdiction') or country,d.get('authority') or ('WIPO' if country in ('PCT','马德里','国际') else 'CNIPA'),d.get('filing_route') or ('PCT' if country=='PCT' else ('马德里' if country=='马德里' else '直接申请')),p_status,
             app_date,d.get('pub_date'),d.get('grant_date'),
             d.get('inventors',''),d.get('owner',''),d.get('agent',''),d.get('ipc',''),
             next_fee_date,current_year,d.get('fee_entity','无费减'),
             1 if _as_bool(d.get('fee_reduction_approved')) else 0,
             normalize_fee_reduction_status(d.get('fee_reduction_status'), d.get('fee_reduction_approved'), d.get('fee_entity')),
             resolve_fee_reduction_ratio(d.get('fee_reduction_ratio'), d.get('fee_entity'), d.get('owner')) if normalize_fee_reduction_status(d.get('fee_reduction_status'), d.get('fee_reduction_approved'), d.get('fee_entity')) == '已批准' else 0,
             d.get('fee_reduction_effective_from'),d.get('fee_reduction_effective_to'),d.get('fee_reduction_verified_date'),d.get('fee_reduction_source',''),
             fee_route,1 if _as_bool(d.get('fee_deadline_verified')) else 0,
             d.get('notes',''),json.dumps(d.get('tags',[])),
             d.get('oa_date'),d.get('oa_round','first'),
             d.get('rejection_date'),d.get('grant_notice_date')))
        new_id = cur.lastrowid
        record_status_change(db,'patent',new_id,None,p_status,'创建案件')
    return ok({"id": new_id})

@app.route('/api/patents/<int:pid>', methods=['GET','PUT','DELETE','OPTIONS'])
def patent_detail(pid):
    if request.method == 'OPTIONS': return ok()
    if request.method == 'GET':
        with get_db() as db: row = db.execute("SELECT * FROM patents WHERE id=?",(pid,)).fetchone()
        return ok(patent_row_to_dict(row)) if row else err("not found",404)
    if request.method == 'PUT':
        d = _json_payload()
        if 'title' in d and not str(d.get('title') or '').strip():
            return err('专利名称不能为空', 400)
        with get_db() as db:
            old_row = db.execute("SELECT * FROM patents WHERE id=?",(pid,)).fetchone()
            if not old_row:
                return err("专利不存在", 404)
            old = row_to_dict(old_row) if old_row else {}
            def _keep(key, default=''):
                # Missing keys preserve existing data. Explicit empty values clear
                # optional fields, which is essential when correcting OCR/import errors.
                if key in d:
                    return d.get(key)
                ov = old.get(key)
                return ov if ov not in (None, '') else default
            app_date = _keep('app_date')
            grant_date = _keep('grant_date')
            country = _normalize_country(_keep('country', '中国'))
            p_type = norm_patent_type(_keep('type','发明'))
            fee_route = _safe_patent_fee_route(country, p_type, _keep('fee_route','auto'))
            current_year = calc_patent_current_year(
                country, app_date, grant_date, _keep('current_year', 1),
                _keep('next_fee_date'), p_type,
                fee_route=fee_route)
            p_status = norm_patent_status(_keep('status','已受理'))
            next_fee_date = calc_patent_next_fee_date(
                country, app_date, grant_date,
                current_year if current_year is not None else _keep('current_year', 1),
                _keep('next_fee_date'), p_type, fee_route) if p_status in ('已授权', '授权') else None
            old_status = old.get('status')
            old_tags = _json_list(old.get('tags'))
            new_tags = _json_list(d.get('tags'), old_tags) if d.get('tags') is not None else old_tags
            db.execute("""UPDATE patents SET title=?,app_no=?,pub_no=?,grant_no=?,type=?,country=?,jurisdiction=?,authority=?,filing_route=?,status=?,
                app_date=?,pub_date=?,grant_date=?,inventors=?,owner=?,agent=?,ipc=?,next_fee_date=?,
                current_year=?,fee_entity=?,fee_reduction_approved=?,fee_reduction_status=?,fee_reduction_ratio=?,
                fee_reduction_effective_from=?,fee_reduction_effective_to=?,fee_reduction_verified_date=?,fee_reduction_source=?,
                fee_route=?,fee_deadline_verified=?,
                notes=?,tags=?,oa_date=?,oa_round=?,rejection_date=?,grant_notice_date=?,updated_at=? WHERE id=?""",
                (_keep('title'),_keep('app_no'),_keep('pub_no'),_keep('grant_no'),
                 p_type,country,_keep('jurisdiction',country),_keep('authority','CNIPA'),_keep('filing_route','直接申请'),p_status,
                 app_date,_keep('pub_date'),grant_date,
                 _keep('inventors'),_keep('owner'),_keep('agent'),_keep('ipc'),
                 next_fee_date,current_year,_keep('fee_entity','无费减'),
                 1 if _as_bool(_keep('fee_reduction_approved',0)) else 0,
                 normalize_fee_reduction_status(_keep('fee_reduction_status','未申请'), _keep('fee_reduction_approved',0), _keep('fee_entity','无费减')),
                 resolve_fee_reduction_ratio(_keep('fee_reduction_ratio',0), _keep('fee_entity','无费减'), _keep('owner')) if normalize_fee_reduction_status(_keep('fee_reduction_status','未申请'), _keep('fee_reduction_approved',0), _keep('fee_entity','无费减')) == '已批准' else 0,
                 _keep('fee_reduction_effective_from'),_keep('fee_reduction_effective_to'),_keep('fee_reduction_verified_date'),_keep('fee_reduction_source'),
                 fee_route,1 if _as_bool(_keep('fee_deadline_verified',0)) else 0,
                 _keep('notes'),json.dumps(new_tags),
                 _keep('oa_date'),_keep('oa_round','first'),
                 _keep('rejection_date'),_keep('grant_notice_date'),
                 now_str(),pid))
            record_status_change(db,'patent',pid,old_status,p_status,d.get('status_note',''))
        return ok()
    with get_db() as db:
        if not db.execute("SELECT 1 FROM patents WHERE id=?", (pid,)).fetchone():
            return err("专利不存在", 404)
        trash_id = _move_case_to_trash(db, 'patent', pid)
    return ok({'trash_id': trash_id})

@app.route('/api/patents/bulk-fee-paid', methods=['POST','OPTIONS'])
def bulk_fee_paid():
    if request.method == 'OPTIONS': return ok()
    payload = _json_payload()
    ids = payload.get('ids', [])
    expected_years = payload.get('expected_years') or {}
    paid_date = _to_date(payload.get('paid_date')) or date.today()
    payer = str(payload.get('payer') or '').strip()
    if not ids: return err("无效ID列表")
    updated = []
    skipped = []
    with get_db() as db:
        for pid in ids:
            row = db.execute("SELECT * FROM patents WHERE id=?",(pid,)).fetchone()
            if not row: continue
            expected = expected_years.get(str(pid), expected_years.get(pid))
            if expected not in (None, '') and str(expected) != str(row['current_year']):
                skipped.append({"id": row['id'], "current_year": row['current_year'], "reason": "案件年度已变化，请刷新后确认"})
                continue
            fee_year = row['current_year']
            if fee_year in (None, ''):
                skipped.append({"id": row['id'], "current_year": fee_year,
                                "reason": "缺少可确认的缴费年度"})
                continue
            existing = db.execute(
                """SELECT id FROM fee_payments
                   WHERE patent_id=? AND fee_year=? AND paid_date=? AND record_source='bulk'""",
                (pid, fee_year, paid_date.isoformat()),
            ).fetchone()
            if existing:
                skipped.append({"id": row['id'], "current_year": fee_year,
                                "reason": "今天已存在该年度的批量缴费记录"})
                continue
            standard_amount = 0
            if _is_china(row['country']):
                due = _add_years(_to_date(row['app_date']), int(float(fee_year)) - 1)
                quote = calculate_cn_annual_fee(
                    row['type'], fee_year, row['fee_entity'] or '无费减',
                    row['app_date'], row['grant_date'], due, paid_date,
                    owner=row['owner'],
                    fee_reduction_approved=row['fee_reduction_approved'],
                    fee_reduction_status=row['fee_reduction_status'],
                    fee_reduction_ratio=row['fee_reduction_ratio'],
                )
                standard_amount = quote['base']
            payment = db.execute(
                """INSERT INTO fee_payments
                   (patent_id,fee_year,standard_amount,paid_amount,paid_date,payer,note,
                    record_source,amount_verified)
                   VALUES (?,?,?,?,?,?,?,?,0)""",
                (pid, fee_year, standard_amount, 0, paid_date.isoformat(), payer,
                 '批量确认已缴；实际金额与缴费凭证待补录', 'bulk'),
            )
            new_year = next_patent_fee_stage(
                row['country'], row['current_year'], row['type'], row['app_date'],
                row['fee_route'])
            new_date = next_patent_fee_date_after_payment(
                row['country'], row['app_date'], row['grant_date'],
                row['current_year'], row['next_fee_date'], row['type'], row['fee_route'])
            stored_year = new_year if new_year is not None else (
                patent_term_years(row['type'], row['app_date']) + 1
                if _is_china(row['country']) else row['current_year'])
            db.execute("UPDATE patents SET current_year=?,next_fee_date=?,updated_at=? WHERE id=?",
                       (stored_year, new_date, now_str(), pid))
            updated.append({"id": pid, "new_year": stored_year, "new_date": new_date,
                            "payment_id": payment.lastrowid, "amount_pending": True})
    return ok({"updated": updated, "skipped": skipped})

@app.route('/api/patents/recalc-years', methods=['POST','OPTIONS'])
def recalc_years():
    """按各案件的国家、类型和申请日重算年费阶段与到期日。"""
    if request.method == 'OPTIONS': return ok()
    updated = 0
    with get_db() as db:
        rows = db.execute("SELECT * FROM patents").fetchall()
        for row in rows:
            try:
                computed_year = calc_patent_current_year(
                    row['country'], row['app_date'], row['grant_date'],
                    row['current_year'], row['next_fee_date'], row['type'],
                    fee_route=row['fee_route'])
                new_year = computed_year if computed_year is not None else row['current_year']
                new_date = calc_patent_next_fee_date(
                    row['country'], row['app_date'], row['grant_date'],
                    new_year if new_year is not None else row['current_year'],
                    row['next_fee_date'], row['type'], row['fee_route'])
                if new_year != row['current_year'] or new_date != row['next_fee_date']:
                    db.execute(
                        "UPDATE patents SET current_year=?,next_fee_date=?,updated_at=? WHERE id=?",
                        (new_year, new_date, now_str(), row['id']))
                    updated += 1
            except Exception:
                continue
    return ok({"updated": updated, "message": f"已更新 {updated} 条专利年度数据"})


# ══════════════ TRADEMARKS ══════════════
@app.route('/api/trademarks', methods=['GET','POST','OPTIONS'])
def trademarks_api():
    if request.method == 'OPTIONS': return ok()
    if request.method == 'GET':
        q = request.args.get('q','').strip()
        status  = request.args.get('status','')
        classes = request.args.get('classes','').strip()
        country = request.args.get('country','').strip()
        page  = max(1, request.args.get('page', 1, type=int))
        limit = min(5000, max(1, request.args.get('limit', 1000, type=int)))
        with get_db() as db:
            sql = "SELECT * FROM trademarks WHERE 1=1"; params = []
            if q:
                sql += " AND (name LIKE ? OR app_no LIKE ? OR reg_no LIKE ? OR owner LIKE ?)"
                p = f'%{q}%'; params += [p,p,p,p]
            if status:  sql += " AND status=?";          params.append(status)
            if classes: sql += " AND classes LIKE ?";    params.append(f'%{classes}%')
            if country: sql += " AND country=?";         params.append(country)
            count_sql = sql.replace("SELECT *", "SELECT COUNT(*)", 1)
            total = db.execute(count_sql, params).fetchone()[0]
            rows = db.execute(sql+" ORDER BY created_at DESC LIMIT ? OFFSET ?", params + [limit, (page-1)*limit]).fetchall()
        return ok({'items': [row_to_dict(r) for r in rows], 'total': total, 'page': page, 'limit': limit, 'pages': max(1, math.ceil(total/limit))})
    d = _json_payload()
    if not str(d.get('name') or '').strip():
        return err('商标名称不能为空', 400)
    tm_type = norm_tm_type(d.get('type','文字'))
    tm_status = norm_tm_status(d.get('status','已受理'))
    tm_app_no = str(d.get('app_no') or '').strip() or str(d.get('reg_no') or '').strip()
    tm_reg_date = d.get('reg_date')
    tm_renewal_date = sanitize_tm_renewal_date(tm_status, tm_reg_date, d.get('renewal_date'))
    with get_db() as db:
        cur = db.execute("""INSERT INTO trademarks
            (name,app_no,reg_no,type,classes,goods_services,country,jurisdiction,authority,filing_route,status,app_date,reg_date,renewal_date,owner,agent,initial_review_notice_no,reg_announcement_no,exclusive_right_period,notes,tags,rejection_date,pub_date,opposition_notice_date,reg_fee_notice_date)
            VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)""",
            (d.get('name',''),tm_app_no,d.get('reg_no',''),tm_type,
             d.get('classes',''),d.get('goods_services',''),d.get('country','中国'),d.get('jurisdiction') or d.get('country','中国'),d.get('authority') or 'CNIPA',d.get('filing_route') or '直接申请',tm_status,
             d.get('app_date'),tm_reg_date,tm_renewal_date,
             d.get('owner',''),d.get('agent',''),d.get('initial_review_notice_no',''),
             d.get('reg_announcement_no',''),d.get('exclusive_right_period',''),
             d.get('notes',''),json.dumps(d.get('tags',[])),
             d.get('rejection_date'),d.get('pub_date'),d.get('opposition_notice_date'),d.get('reg_fee_notice_date')))
        new_id = cur.lastrowid
        record_status_change(db,'trademark',new_id,None,tm_status,'创建案件')
    return ok({"id": new_id})

@app.route('/api/trademarks/<int:tid>', methods=['GET','PUT','DELETE','OPTIONS'])
def trademark_detail(tid):
    if request.method == 'OPTIONS': return ok()
    if request.method == 'GET':
        with get_db() as db: row = db.execute("SELECT * FROM trademarks WHERE id=?",(tid,)).fetchone()
        return ok(row_to_dict(row)) if row else err("not found",404)
    if request.method == 'PUT':
        d = _json_payload()
        if not str(d.get('name') or '').strip():
            return err('商标名称不能为空', 400)
        tm_type = norm_tm_type(d.get('type','文字'))
        tm_status = norm_tm_status(d.get('status','已受理'))
        tm_app_no = str(d.get('app_no') or '').strip() or str(d.get('reg_no') or '').strip()
        tm_reg_date = d.get('reg_date')
        tm_renewal_date = sanitize_tm_renewal_date(tm_status, tm_reg_date, d.get('renewal_date'))
        with get_db() as db:
            old = db.execute("SELECT status, type, logo_filename FROM trademarks WHERE id=?",(tid,)).fetchone()
            if not old:
                return err("商标不存在", 404)
            old_status = old['status'] if old else None
            if tm_type == '图形':
                db.execute("""UPDATE trademarks SET name=?,app_no=?,reg_no=?,type=?,classes=?,goods_services=?,country=?,jurisdiction=?,authority=?,filing_route=?,status=?,
                    app_date=?,reg_date=?,renewal_date=?,owner=?,agent=?,initial_review_notice_no=?,reg_announcement_no=?,exclusive_right_period=?,notes=?,tags=?,rejection_date=?,pub_date=?,opposition_notice_date=?,reg_fee_notice_date=?,updated_at=? WHERE id=?""",
                    (d.get('name',''),tm_app_no,d.get('reg_no',''),tm_type,
                     d.get('classes',''),d.get('goods_services',''),d.get('country','中国'),d.get('jurisdiction') or d.get('country','中国'),d.get('authority') or 'CNIPA',d.get('filing_route') or '直接申请',tm_status,
                     d.get('app_date'),tm_reg_date,tm_renewal_date,
                     d.get('owner',''),d.get('agent',''),d.get('initial_review_notice_no',''),
                     d.get('reg_announcement_no',''),d.get('exclusive_right_period',''),d.get('notes',''),
                     json.dumps(d.get('tags',[])),d.get('rejection_date'),
                     d.get('pub_date'),d.get('opposition_notice_date'),d.get('reg_fee_notice_date'),
                     now_str(),tid))
            else:
                db.execute("""UPDATE trademarks SET name=?,app_no=?,reg_no=?,type=?,classes=?,goods_services=?,country=?,jurisdiction=?,authority=?,filing_route=?,status=?,
                    app_date=?,reg_date=?,renewal_date=?,owner=?,agent=?,initial_review_notice_no=?,reg_announcement_no=?,exclusive_right_period=?,notes=?,tags=?,rejection_date=?,pub_date=?,opposition_notice_date=?,reg_fee_notice_date=?,logo_filename='',updated_at=? WHERE id=?""",
                    (d.get('name',''),tm_app_no,d.get('reg_no',''),tm_type,
                     d.get('classes',''),d.get('goods_services',''),d.get('country','中国'),d.get('jurisdiction') or d.get('country','中国'),d.get('authority') or 'CNIPA',d.get('filing_route') or '直接申请',tm_status,
                     d.get('app_date'),tm_reg_date,tm_renewal_date,
                     d.get('owner',''),d.get('agent',''),d.get('initial_review_notice_no',''),
                     d.get('reg_announcement_no',''),d.get('exclusive_right_period',''),d.get('notes',''),
                     json.dumps(d.get('tags',[])),d.get('rejection_date'),
                     d.get('pub_date'),d.get('opposition_notice_date'),d.get('reg_fee_notice_date'),
                     now_str(),tid))
                if old and old['logo_filename']:
                    _trash_add(db, 'trademark_logo', tid, f"{d.get('name','')} · 商标图", {
                        'version': 1,
                        'trademark_id': tid,
                        'logo_filename': old['logo_filename'],
                    })
            record_status_change(db,'trademark',tid,old_status,tm_status,d.get('status_note',''))
        return ok()
    with get_db() as db:
        old = db.execute("SELECT logo_filename FROM trademarks WHERE id=?", (tid,)).fetchone()
        if not old:
            return err("商标不存在", 404)
        trash_id = _move_case_to_trash(db, 'trademark', tid)
    return ok({'trash_id': trash_id})

# ══════════════ COPYRIGHTS ══════════════
@app.route('/api/copyrights', methods=['GET','POST','OPTIONS'])
def copyrights_api():
    if request.method == 'OPTIONS': return ok()
    if request.method == 'GET':
        q = request.args.get('q','').strip()
        page  = max(1, request.args.get('page', 1, type=int))
        limit = min(5000, max(1, request.args.get('limit', 1000, type=int)))
        with get_db() as db:
            sql = "SELECT * FROM copyrights WHERE 1=1"; params = []
            if q:
                sql += " AND (name LIKE ? OR reg_no LIKE ? OR owner LIKE ?)"
                p = f'%{q}%'; params += [p,p,p]
            count_sql = sql.replace("SELECT *", "SELECT COUNT(*)", 1)
            total = db.execute(count_sql, params).fetchone()[0]
            rows = db.execute(sql+" ORDER BY created_at DESC LIMIT ? OFFSET ?", params + [limit, (page-1)*limit]).fetchall()
        return ok({'items': [copyright_row_to_dict(r) for r in rows], 'total': total, 'page': page, 'limit': limit, 'pages': max(1, math.ceil(total/limit))})
    d = _json_payload()
    if not str(d.get('name') or '').strip():
        return err('软件名称不能为空', 400)
    with get_db() as db:
        cur = db.execute("""INSERT INTO copyrights
            (name,version,reg_no,reg_date,completion_date,owner,type,language,jurisdiction,authority,filing_route,
             development_mode,acquisition_mode,owner_type,publication_status,
            first_publication_date,first_publication_place,death_date,registration_status,notes,tags)
            VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)""",
            (d.get('name',''),d.get('version',''),d.get('reg_no',''),d.get('reg_date'),
             d.get('completion_date'),d.get('owner',''),d.get('acquisition_mode',d.get('type','原始取得')),
             d.get('language',''),d.get('jurisdiction','中国'),d.get('authority','CPCC'),d.get('filing_route','直接登记'),d.get('development_mode','独立开发'),
             d.get('acquisition_mode','原始取得'),d.get('owner_type','法人或其他组织'),
             d.get('publication_status','未发表'),d.get('first_publication_date'),
             d.get('first_publication_place',''),d.get('death_date'),d.get('registration_status','已登记'),
             d.get('notes',''),json.dumps(d.get('tags',[]))))
        new_id = cur.lastrowid
    return ok({"id": new_id})

@app.route('/api/copyrights/<int:cid>', methods=['GET','PUT','DELETE','OPTIONS'])
def copyright_detail(cid):
    if request.method == 'OPTIONS': return ok()
    if request.method == 'GET':
        with get_db() as db: row = db.execute("SELECT * FROM copyrights WHERE id=?",(cid,)).fetchone()
        return ok(copyright_row_to_dict(row)) if row else err("not found",404)
    if request.method == 'PUT':
        d = _json_payload()
        if not str(d.get('name') or '').strip():
            return err('软件名称不能为空', 400)
        with get_db() as db:
            if not db.execute("SELECT 1 FROM copyrights WHERE id=?", (cid,)).fetchone():
                return err("软著不存在", 404)
            db.execute("""UPDATE copyrights SET name=?,version=?,reg_no=?,reg_date=?,completion_date=?,jurisdiction=?,authority=?,filing_route=?,
                owner=?,type=?,language=?,development_mode=?,acquisition_mode=?,owner_type=?,
                publication_status=?,first_publication_date=?,first_publication_place=?,death_date=?,
                registration_status=?,notes=?,tags=?,updated_at=? WHERE id=?""",
                (d.get('name',''),d.get('version',''),d.get('reg_no',''),d.get('reg_date'),
                 d.get('completion_date'),d.get('jurisdiction','中国'),d.get('authority','CPCC'),d.get('filing_route','直接登记'),d.get('owner',''),
                 d.get('acquisition_mode',d.get('type','原始取得')),d.get('language',''),
                 d.get('development_mode','独立开发'),d.get('acquisition_mode','原始取得'),
                 d.get('owner_type','法人或其他组织'),d.get('publication_status','未发表'),
                 d.get('first_publication_date'),d.get('first_publication_place',''),d.get('death_date'),
                 d.get('registration_status','已登记'),d.get('notes',''),
                 json.dumps(d.get('tags',[])),now_str(),cid))
        return ok()
    with get_db() as db:
        if not db.execute("SELECT 1 FROM copyrights WHERE id=?", (cid,)).fetchone():
            return err("软著不存在", 404)
        trash_id = _move_case_to_trash(db, 'copyright', cid)
    return ok({'trash_id': trash_id})

# ══════════════ 状态历史 ══════════════
def _auto_status_events(db, item_type, item_id, actual_records):
    """根据案件日期字段推导状态节点；只在读取时合并，不写入数据库。"""
    if item_type == 'patent':
        table = 'patents'
        milestones = [
            ('app_date', '已受理', '根据申请日自动生成'),
            ('pub_date', '已公开', '根据公开日自动生成'),
            ('oa_date', '审查意见', '根据审查意见日期自动生成'),
            ('grant_notice_date', '授权通知', '根据授权通知日期自动生成'),
            ('rejection_date', '已驳回', '根据驳回日期自动生成'),
            ('grant_date', '已授权', '根据授权日自动生成'),
        ]
    elif item_type == 'trademark':
        table = 'trademarks'
        milestones = [
            ('app_date', '已受理', '根据申请日自动生成'),
            ('pub_date', '初审公告', '根据初审公告日自动生成'),
            ('opposition_notice_date', '异议中', '根据异议通知日期自动生成'),
            ('reg_fee_notice_date', '注册缴费', '根据注册缴费通知日期自动生成'),
            ('rejection_date', '已驳回', '根据驳回日期自动生成'),
            ('reg_date', '已注册', '根据注册日自动生成'),
        ]
    else:
        return [dict(r) for r in actual_records]

    row = db.execute(f"SELECT * FROM {table} WHERE id=?", (item_id,)).fetchone()
    if not row:
        return [dict(r) for r in actual_records]
    item = dict(row)
    actual = [dict(r) for r in actual_records]
    existing_exact = {
        ((r.get('new_status') or '').strip(), (r.get('changed_at') or '')[:10])
        for r in actual
    }
    auto = []
    for field, status, note in milestones:
        raw_date = item.get(field)
        if not raw_date:
            continue
        if item_type == 'trademark' and field == 'pub_date' and item.get('initial_review_notice_no'):
            note = f"初审公告第{item['initial_review_notice_no']}期（根据初审公告日自动生成）"
        elif item_type == 'trademark' and field == 'reg_date':
            details = []
            if item.get('reg_announcement_no'):
                details.append(f"注册公告第{item['reg_announcement_no']}期")
            if item.get('exclusive_right_period'):
                details.append(f"专用权期间：{item['exclusive_right_period']}")
            if details:
                note = '；'.join(details) + '（根据注册公告日自动生成）'
        event_date = str(raw_date)[:10]
        if len(event_date) != 10 or (status, event_date) in existing_exact:
            continue
        auto.append({
            'id': f'auto:{item_type}:{item_id}:{field}',
            'item_type': item_type,
            'item_id': item_id,
            'old_status': '',
            'new_status': status,
            'note': note,
            'operator': '',
            'changed_at': event_date + ' 00:00:00',
            'auto_generated': True,
        })

    # 存在日期里程碑时，建档/导入只表示入库动作，不再重复显示为状态节点。
    if auto:
        actual = [
            r for r in actual
            if (r.get('note') or '').strip() not in ('创建案件', 'Excel导入', '批量导入')
        ]

    represented = {r.get('new_status') for r in actual + auto}
    current_status = item.get('status')
    if current_status and current_status not in represented:
        current_time = item.get('updated_at') or item.get('created_at') or now_str()
        auto.append({
            'id': f'auto:{item_type}:{item_id}:current',
            'item_type': item_type,
            'item_id': item_id,
            'old_status': '',
            'new_status': current_status,
            'note': '根据当前案件状态自动生成',
            'operator': '',
            'changed_at': current_time,
            'auto_generated': True,
        })

    merged = actual + auto
    merged.sort(key=lambda r: (r.get('changed_at') or '', str(r.get('id') or '')))
    previous = ''
    for event in merged:
        if not event.get('old_status') and previous and previous != event.get('new_status'):
            event['old_status'] = previous
        previous = event.get('new_status') or previous
    return merged


@app.route('/api/status-history/<item_type>/<int:item_id>', methods=['GET','OPTIONS'])
def get_status_history(item_type, item_id):
    if request.method == 'OPTIONS': return ok()
    with get_db() as db:
        rows = db.execute(
            "SELECT * FROM status_history WHERE item_type=? AND item_id=? ORDER BY changed_at ASC",
            (item_type, item_id)).fetchall()
        records = _auto_status_events(db, item_type, item_id, rows)
    return ok(records)

@app.route('/api/legal-events/<item_type>/<int:item_id>', methods=['GET','OPTIONS'])
def get_legal_events(item_type, item_id):
    if request.method == 'OPTIONS': return ok()
    if item_type not in RECORD_TABLE_BY_ITEM_TYPE:
        return err('案件类型无效', 400)
    with get_db() as db:
        rows = db.execute(
            "SELECT * FROM legal_events WHERE item_type=? AND item_id=? ORDER BY COALESCE(event_date,effective_date,created_at), id",
            (item_type, item_id)).fetchall()
    return ok([dict(row) for row in rows])

@app.route('/api/status-history/recent', methods=['GET','OPTIONS'])
def get_recent_status_history():
    if request.method == 'OPTIONS': return ok()
    limit = request.args.get('limit', 10, type=int)
    items = []
    with get_db() as db:
        # 1. 状态变更记录
        for r in db.execute(
            "SELECT sh.*, COALESCE("
            "CASE WHEN sh.item_type='patent' THEN p.title "
            "WHEN sh.item_type='trademark' THEN t.name "
            "WHEN sh.item_type='copyright' THEN c.name "
            "ELSE '' END, '') as item_name "
            "FROM status_history sh "
            "LEFT JOIN patents p ON sh.item_type='patent' AND sh.item_id=p.id "
            "LEFT JOIN trademarks t ON sh.item_type='trademark' AND sh.item_id=t.id "
            "LEFT JOIN copyrights c ON sh.item_type='copyright' AND sh.item_id=c.id "
            "ORDER BY sh.changed_at DESC LIMIT ?",
            (limit,)).fetchall():
            d = dict(r)
            d['event_type'] = 'status_change'
            d['event_time'] = d.get('changed_at', '')
            items.append(d)

        # 2. 最近修改的专利（排除刚创建的，只看真正修改过的）
        for r in db.execute(
            "SELECT id, 'patent' as item_type, title as item_name, app_no, status, updated_at as event_time "
            "FROM patents WHERE updated_at IS NOT NULL AND updated_at != created_at "
            "ORDER BY updated_at DESC LIMIT ?", (limit,)).fetchall():
            d = dict(r)
            d['event_type'] = 'record_updated'
            items.append(d)

        # 3. 最近修改的商标
        for r in db.execute(
            "SELECT id, 'trademark' as item_type, name as item_name, app_no, status, updated_at as event_time "
            "FROM trademarks WHERE updated_at IS NOT NULL AND updated_at != created_at "
            "ORDER BY updated_at DESC LIMIT ?", (limit,)).fetchall():
            d = dict(r)
            d['event_type'] = 'record_updated'
            items.append(d)

        # 4. 最近上传的附件
        for r in db.execute(
            "SELECT d.id, d.item_type, d.original_name as item_name, d.doc_type, d.uploaded_at as event_time, "
            "CASE WHEN d.item_type='patent' THEN p.title "
            "WHEN d.item_type='trademark' THEN t.name "
            "WHEN d.item_type='copyright' THEN c.name "
            "ELSE '' END as parent_name "
            "FROM documents d "
            "LEFT JOIN patents p ON d.item_type='patent' AND d.item_id=p.id "
            "LEFT JOIN trademarks t ON d.item_type='trademark' AND d.item_id=t.id "
            "LEFT JOIN copyrights c ON d.item_type='copyright' AND d.item_id=c.id "
            "ORDER BY d.uploaded_at DESC LIMIT ?", (limit,)).fetchall():
            d = dict(r)
            d['event_type'] = 'document_uploaded'
            items.append(d)

    # 按时间排序，取最近的
    items.sort(key=lambda x: x.get('event_time', '') or '', reverse=True)
    return ok(items[:limit])

@app.route('/api/status-history', methods=['POST','OPTIONS'])
def add_status_history():
    if request.method == 'OPTIONS': return ok()
    d = _json_payload()
    item_type = str(d.get('item_type') or '')
    item_id = d.get('item_id')
    if isinstance(item_id, dict):
        item_id = item_id.get('id')
    new_status = str(d.get('new_status') or '').strip()
    if item_type not in ('patent', 'trademark', 'copyright') or not new_status:
        return err('状态历史参数不完整', 400)
    with get_db() as db:
        table = {'patent': 'patents', 'trademark': 'trademarks', 'copyright': 'copyrights'}[item_type]
        row = db.execute(f"SELECT status FROM {table} WHERE id=?", (item_id,)).fetchone()
        if not row:
            return err('关联案件不存在', 404)
        old_status = row['status']
        normalized = (norm_patent_status(new_status) if item_type == 'patent'
                      else norm_tm_status(new_status) if item_type == 'trademark'
                      else new_status)
        db.execute(f"UPDATE {table} SET status=?,updated_at=? WHERE id=?", (normalized, now_str(), item_id))
        record_status_change(db, item_type, item_id, old_status, normalized,
                             d.get('note',''), d.get('operator',''))
        sync_deadline_tasks(db)
    return ok({"id": item_id, "old_status": old_status, "new_status": normalized})

@app.route('/api/status-history/<int:hid>', methods=['DELETE','OPTIONS'])
def delete_status_history(hid):
    if request.method == 'OPTIONS': return ok()
    # 状态历史是审计链的一部分，不允许物理删除；如需修正请走状态流转接口。
    if request.method == 'DELETE':
        return err('状态历史不可删除，请通过状态流转进行更正', 409)
    with get_db() as db:
        row = db.execute("SELECT * FROM status_history WHERE id=?", (hid,)).fetchone()
        if not row:
            return err('状态记录不存在', 404)
        record = dict(row)
        name = f"{record.get('old_status') or '初始状态'} → {record.get('new_status') or ''}"
        trash_id = _trash_add(db, 'status_history', hid, name, {'version': 1, 'record': record})
        db.execute("DELETE FROM status_history WHERE id=?", (hid,))
    return ok({'trash_id': trash_id})

@app.route('/api/cases/<item_type>/<int:item_id>/transition', methods=['POST','OPTIONS'])
def transition_case_status(item_type, item_id):
    """唯一业务状态流转入口：状态、历史、事件和期限任务同一事务提交。"""
    if request.method == 'OPTIONS': return ok()
    d = _json_payload()
    new_status = str(d.get('new_status') or '').strip()
    if item_type not in ('patent', 'trademark', 'copyright') or not new_status:
        return err('状态流转参数不完整', 400)
    with get_db() as db:
        table = {'patent':'patents','trademark':'trademarks','copyright':'copyrights'}[item_type]
        row = db.execute(f"SELECT status FROM {table} WHERE id=?", (item_id,)).fetchone()
        if not row: return err('关联案件不存在', 404)
        old_status = row['status']
        normalized = norm_patent_status(new_status) if item_type == 'patent' else norm_tm_status(new_status) if item_type == 'trademark' else new_status
        db.execute(f"UPDATE {table} SET status=?,updated_at=? WHERE id=?", (normalized, now_str(), item_id))
        record_status_change(db, item_type, item_id, old_status, normalized, d.get('reason') or d.get('note',''), d.get('source') or d.get('operator',''))
        sync_deadline_tasks(db)
    return ok({'id': item_id, 'old_status': old_status, 'new_status': normalized})

# ══════════════ 年费缴纳历史 ══════════════
@app.route('/api/fee-payments/<int:patent_id>', methods=['GET','OPTIONS'])
def get_fee_payments(patent_id):
    if request.method == 'OPTIONS': return ok()
    with get_db() as db:
        rows = db.execute(
            "SELECT * FROM fee_payments WHERE patent_id=? ORDER BY fee_year DESC, created_at DESC",
            (patent_id,)).fetchall()
    return ok([dict(r) for r in rows])

@app.route('/api/fee-payments', methods=['POST','OPTIONS'])
def create_fee_payment():
    if request.method == 'OPTIONS': return ok()
    d = _json_payload()
    patent_id = d.get('patent_id')
    with get_db() as db:
        patent = db.execute("SELECT * FROM patents WHERE id=?", (patent_id,)).fetchone()
        if not patent:
            return err('关联专利不存在', 404)
        try:
            fee_year = float(d.get('fee_year'))
            if fee_year.is_integer():
                fee_year = int(fee_year)
        except (TypeError, ValueError):
            return err('缴费年度无效', 400)
        paid_date = _to_date(d.get('paid_date'))
        if not paid_date:
            return err('缴费日期无效', 400)

        quote = None
        if _is_china(patent['country']):
            if not float(fee_year).is_integer():
                return err('中国专利年费年度必须为整数', 400)
            due = _add_years(_to_date(patent['app_date']), int(fee_year) - 1)
            quote = calculate_cn_annual_fee(
                patent['type'], fee_year, patent['fee_entity'] or '无费减',
                patent['app_date'], patent['grant_date'], due, paid_date,
                owner=patent['owner'],
                fee_reduction_approved=patent['fee_reduction_approved'],
                fee_reduction_status=patent['fee_reduction_status'],
                fee_reduction_ratio=patent['fee_reduction_ratio'])
            if not quote['base']:
                return err('缴费年度已超出该专利的有效年限', 400)
            standard_amount = quote['base']
            paid_amount = d.get('paid_amount', quote['total_due'])
        else:
            standard_amount = d.get('standard_amount', 0)
            paid_amount = d.get('paid_amount', 0)
        try:
            standard_amount = max(0, int(float(standard_amount or 0)))
            paid_amount = max(0, int(float(paid_amount or 0)))
        except (TypeError, ValueError):
            return err('缴费金额无效', 400)
        cur = db.execute("""INSERT INTO fee_payments
            (patent_id,fee_year,standard_amount,paid_amount,paid_date,payer,agent,note)
            VALUES (?,?,?,?,?,?,?,?)""",
            (patent_id,fee_year,standard_amount,
             paid_amount,paid_date.isoformat(),d.get('payer',''),
             d.get('agent',''),d.get('note','')))

        # 录入当期或更后年度的实际缴费后，同步推进案件的下期计划。
        try:
            recorded_stage = float(patent['current_year'] or 0)
        except (TypeError, ValueError):
            recorded_stage = 0
        if float(fee_year) >= recorded_stage:
            next_stage = next_patent_fee_stage(
                patent['country'], fee_year, patent['type'], patent['app_date'],
                patent['fee_route'])
            current_due = (
                _add_years(_to_date(patent['app_date']), int(fee_year) - 1).isoformat()
                if _is_china(patent['country']) and _to_date(patent['app_date']) else
                patent['next_fee_date']
            )
            next_date = next_patent_fee_date_after_payment(
                patent['country'], patent['app_date'], patent['grant_date'],
                fee_year, current_due, patent['type'], patent['fee_route'])
            stored_stage = next_stage if next_stage is not None else (
                patent_term_years(patent['type'], patent['app_date']) + 1
                if _is_china(patent['country']) else fee_year)
            db.execute(
                "UPDATE patents SET current_year=?,next_fee_date=?,updated_at=? WHERE id=?",
                (stored_stage, next_date, now_str(), patent_id))
    return ok({"id": cur.lastrowid, "quote": quote})

@app.route('/api/fee-payments/<int:pay_id>/receipt', methods=['POST','OPTIONS'])
def upload_receipt(pay_id):
    if request.method == 'OPTIONS': return ok()
    if 'file' not in request.files: return err("未选择文件")
    file = request.files['file']
    ext = Path(file.filename).suffix.lower()
    if ext not in ALLOWED_EXT: return err(f"不支持的文件类型: {ext}")
    ts = datetime.now().strftime("%Y%m%d_%H%M%S")
    safe = "".join(c for c in f"receipt_{pay_id}_{ts}_{file.filename}" if c.isalnum() or c in '._-')
    with get_db() as db:
        old = db.execute("SELECT * FROM fee_payments WHERE id=?",(pay_id,)).fetchone()
    if not old:
        return err("缴费记录不存在", 404)
    save_path = UPLOAD_DIR / safe
    file.save(str(save_path))
    size = save_path.stat().st_size
    with get_db() as db:
        if old and old['receipt_filename']:
            _trash_add(db, 'fee_receipt', pay_id, old['receipt_original_name'] or '缴费凭证', {
                'version': 1,
                'payment_id': pay_id,
                'receipt_filename': old['receipt_filename'],
                'receipt_original_name': old['receipt_original_name'],
                'receipt_size': old['receipt_size'],
            })
        db.execute("UPDATE fee_payments SET receipt_filename=?,receipt_original_name=?,receipt_size=? WHERE id=?",
                   (safe, file.filename, size, pay_id))
    return ok({"filename": safe, "original_name": file.filename, "size": size})

@app.route('/api/fee-payments/<int:pay_id>/receipt/download')
def download_receipt(pay_id):
    with get_db() as db: row = db.execute("SELECT * FROM fee_payments WHERE id=?",(pay_id,)).fetchone()
    if not row or not row['receipt_filename']: return err("无凭证",404)
    f = UPLOAD_DIR / row['receipt_filename']
    if not f.exists(): return err("文件已删除",404)
    return send_file(str(f), download_name=row['receipt_original_name'], as_attachment=True)

@app.route('/api/fee-payments/<int:pay_id>/receipt/preview')
def preview_receipt(pay_id):
    with get_db() as db: row = db.execute("SELECT * FROM fee_payments WHERE id=?",(pay_id,)).fetchone()
    if not row or not row['receipt_filename']: return err("无凭证",404)
    f = UPLOAD_DIR / row['receipt_filename']
    if not f.exists(): return err("文件已删除",404)
    mime = mimetypes.guess_type(row['receipt_original_name'])[0] or 'application/octet-stream'
    return send_file(str(f), mimetype=mime)

@app.route('/api/fee-payments/<int:pay_id>', methods=['DELETE','OPTIONS'])
def delete_fee_payment(pay_id):
    if request.method == 'OPTIONS': return ok()
    with get_db() as db:
        row = db.execute("SELECT * FROM fee_payments WHERE id=?",(pay_id,)).fetchone()
        if not row:
            return err('缴费记录不存在', 404)
        record = dict(row)
        trash_id = _trash_add(
            db, 'fee_payment', pay_id,
            f"第{record.get('fee_year') or '-'}年年费 · {record.get('paid_date') or ''}",
            {'version': 1, 'record': record},
        )
        db.execute("DELETE FROM fee_payments WHERE id=?",(pay_id,))
    return ok({'trash_id': trash_id})

@app.route('/api/fee-payments/batch-download', methods=['POST','OPTIONS'])
def batch_download_receipts():
    if request.method == 'OPTIONS': return ok()
    ids = _json_payload().get('ids', [])
    if not ids: return err("请选择要下载的记录")
    buf = BytesIO()
    count = 0
    with get_db() as db:
        with zipfile.ZipFile(buf, 'w', zipfile.ZIP_DEFLATED) as zf:
            for pay_id in ids:
                row = db.execute("SELECT * FROM fee_payments WHERE id=?",(pay_id,)).fetchone()
                if not row or not row['receipt_filename']: continue
                f = UPLOAD_DIR / row['receipt_filename']
                if not f.exists(): continue
                # 文件名：第X年_缴费日期_原始文件名
                yr = f"第{row['fee_year']}年" if row['fee_year'] else '未知年度'
                dt = (row['paid_date'] or '').replace('-','')[:8]
                arcname = f"{yr}_{dt}_{row['receipt_original_name']}"
                zf.write(str(f), arcname)
                count += 1
    if count == 0: return err("所选记录均无凭证文件")
    buf.seek(0)
    return send_file(buf, mimetype='application/zip', as_attachment=True,
                     download_name=f'缴费凭证_{date.today()}.zip')

# ══════════════ DOCUMENTS ══════════════
DOCUMENT_FIELD_LABELS = {
    'patent': {
        'title': '专利名称', 'app_no': '申请号', 'pub_no': '公开号',
        'grant_no': '授权号', 'status': '案件状态', 'app_date': '申请日',
        'pub_date': '公开日', 'grant_date': '授权日', 'inventors': '发明人',
        'owner': '权利人', 'ipc': 'IPC分类号', 'oa_date': '审查意见收到日',
        'rejection_date': '驳回决定收到日', 'grant_notice_date': '授权通知日',
    },
    'trademark': {
        'name': '商标名称', 'app_no': '申请号', 'reg_no': '注册号',
        'classes': '尼斯分类', 'status': '案件状态', 'app_date': '申请日',
        'reg_date': '注册日', 'owner': '权利人', 'rejection_date': '驳回通知收到日',
        'pub_date': '初审公告日', 'initial_review_notice_no': '初审公告期号',
        'reg_announcement_no': '注册公告期号', 'exclusive_right_period': '专用权期间',
        'goods_services': '商品/服务项目', 'opposition_notice_date': '异议通知收到日',
    },
    'copyright': {
        'name': '软件名称', 'version': '版本号', 'reg_no': '登记号',
        'reg_date': '登记日期', 'owner': '著作权人',
    },
}

DOCUMENT_ALLOWED_UPDATES = {
    item_type: set(fields)
    for item_type, fields in DOCUMENT_FIELD_LABELS.items()
}

DOCUMENT_RECORD_META = {
    'patent': ('patents', 'title'),
    'trademark': ('trademarks', 'name'),
    'copyright': ('copyrights', 'name'),
}


def _document_values_equal(field, current, suggested):
    current = '' if current is None else str(current).strip()
    suggested = '' if suggested is None else str(suggested).strip()
    if current == suggested:
        return True
    if field in ('app_no', 'pub_no', 'grant_no', 'reg_no'):
        def normalize_number(value):
            value = unicodedata.normalize('NFKC', value).upper()
            value = re.sub(r'^(CN|ZL)', '', value)
            return re.sub(r'[^A-Z0-9]', '', value)
        return bool(current and suggested and normalize_number(current) == normalize_number(suggested))
    return False


def _extract_labeled_document_date(text):
    """Extract only a clearly labelled document date; never guess from arbitrary dates."""
    if not text:
        return '', ''
    flat = re.sub(r'\s+', ' ', text.replace('\xa0', ' ').replace('　', ' '))
    labels = [
        '通知书发文日', '通知书日期', '决定日期', '决定日', '公告日期',
        '公告日', '颁证日期', '颁证日', '登记日期', '发文日期', '发文日',
    ]
    date_pattern = r'(\d{4})\s*(?:年|[-/.])\s*(\d{1,2})\s*(?:月|[-/.])\s*(\d{1,2})\s*日?'
    for label in labels:
        m = re.search(re.escape(label) + r'\s*[:：]?\s*' + date_pattern, flat)
        if m:
            try:
                value = date(int(m.group(1)), int(m.group(2)), int(m.group(3))).isoformat()
                return value, label
            except ValueError:
                continue
    return '', ''


def _suggest_document_anchor(item_type, doc_type, document_date):
    """Map a labelled date to the field used by the existing deadline engine."""
    if not document_date:
        return None
    doc_type = str(doc_type or '')
    if item_type == 'patent':
        if '审查意见' in doc_type:
            return 'oa_date'
        if '驳回' in doc_type:
            return 'rejection_date'
        if '授权通知' in doc_type or '办理登记' in doc_type:
            return 'grant_notice_date'
        if '申请公布' in doc_type or '公开' in doc_type:
            return 'pub_date'
        if '专利证书' in doc_type:
            return 'grant_date'
    elif item_type == 'trademark':
        if '驳回' in doc_type:
            return 'rejection_date'
        if '初审公告' in doc_type:
            return 'pub_date'
        if '异议' in doc_type:
            return 'opposition_notice_date'
        if '注册证' in doc_type or '注册公告' in doc_type:
            return 'reg_date'
    elif item_type == 'copyright' and ('登记证书' in doc_type or '著作权登记' in doc_type):
        return 'reg_date'
    return None


def _document_deadline_preview(item_type, merged):
    """Explain which existing alert will be generated after applying the review."""
    status = merged.get('status') or ''
    previews = []

    def add_from(field, kind, **context):
        info = calculate_legal_deadline(kind, merged.get(field), **context)
        if info:
            info['source_field'] = field
            previews.append(info)

    if item_type == 'patent':
        if status in ('实审中', '审查中'):
            add_from('oa_date', 'patent_oa_response', oa_round=merged.get('oa_round'))
        if status == '已驳回':
            add_from('rejection_date', 'patent_rejection_review')
        if status in ('待登记', '已授权', '授权') and not merged.get('grant_date'):
            add_from('grant_notice_date', 'patent_grant_pay')
    elif item_type == 'trademark':
        if status == '已驳回':
            add_from('rejection_date', 'tm_rejection_review')
        if status == '复审中':
            if not merged.get('review_simple_submitted_date'):
                add_from('rejection_date', 'tm_rejection_simple')
            elif not merged.get('review_complete_submitted_date'):
                add_from('rejection_date', 'tm_rejection_complete')
        if status == '初审公告':
            add_from('pub_date', 'tm_opposition_period')
        if status == '异议中':
            add_from('opposition_notice_date', 'tm_opposition_response')
    return previews


def _build_document_review(db, document, text):
    item_type = document['item_type']
    item_id = document['item_id']
    meta = DOCUMENT_RECORD_META.get(item_type)
    if not meta:
        return None, '暂不支持该附件类型的案件更新'
    table, name_field = meta
    record_row = db.execute(f"SELECT * FROM {table} WHERE id=?", (item_id,)).fetchone()
    if not record_row:
        return None, '关联案件不存在'
    record = row_to_dict(record_row)
    analysis = analyze_doc_text(text, item_type) or {}
    detected_doc_type = analysis.get('doc_type') or ''
    existing_doc_type = document['doc_type'] or ''
    name_doc_type = _doc_type_from_name(document['original_name'], item_type)
    if name_doc_type != '其他':
        doc_type = name_doc_type
    elif detected_doc_type in ('', '其他', '其他文书', '非PDF文件') and existing_doc_type not in ('', '其他', '其他文书'):
        doc_type = existing_doc_type
    else:
        doc_type = detected_doc_type or existing_doc_type or '其他'
    extracted = extract_doc_fields(text, item_type, document['original_name'])
    if analysis.get('suggested_status'):
        extracted['status'] = analysis['suggested_status']

    document_date, date_label = _extract_labeled_document_date(text)
    anchor_field = _suggest_document_anchor(item_type, doc_type, document_date)
    if anchor_field and anchor_field not in extracted:
        extracted[anchor_field] = document_date

    labels = DOCUMENT_FIELD_LABELS[item_type]
    changes = []
    for field, new_value in extracted.items():
        if field not in DOCUMENT_ALLOWED_UPDATES[item_type] or new_value in (None, ''):
            continue
        current = record.get(field)
        current_text = '' if current is None else str(current)
        new_text = str(new_value)
        if _document_values_equal(field, current_text, new_text):
            continue
        source = '文书正文'
        caution = ''
        if field == 'status':
            source = '文书类型推断'
            caution = '文书类型不等于最终法律结论，状态变更必须人工确认'
        elif field == anchor_field:
            source = date_label or '文书日期'
            if field in ('oa_date', 'rejection_date', 'grant_notice_date', 'opposition_notice_date'):
                caution = '文书日期不一定等于实际收到日，请核对后采用'
        sensitive = field in {
            'status', 'oa_date', 'rejection_date', 'grant_notice_date',
            'opposition_notice_date',
        }
        changes.append({
            'field': field,
            'label': labels.get(field, field),
            'current': current_text,
            'suggested': new_text,
            'source': source,
            'caution': caution,
            'default_selected': bool(not current_text and not sensitive),
            'requires_confirmation': sensitive,
            'conflict': bool(current_text),
        })

    merged = dict(record)
    selected_fields = set()
    for change in changes:
        if change['default_selected']:
            merged[change['field']] = change['suggested']
            selected_fields.add(change['field'])
    deadline_preview = _document_deadline_preview(item_type, merged)
    if selected_fields:
        deadline_preview = [
            item for item in deadline_preview
            if item.get('source_field') in selected_fields or 'status' in selected_fields
        ]
    else:
        deadline_preview = []
    review = {
        'document_id': document['id'],
        'document_name': document['original_name'],
        'doc_type': doc_type,
        'item_type': item_type,
        'item_id': item_id,
        'item_name': record.get(name_field) or '',
        'item_no': record.get('app_no') or record.get('reg_no') or '',
        'confidence': analysis.get('confidence', 0),
        'snippet': analysis.get('snippet', ''),
        'text_length': len(text),
        'document_date': document_date,
        'document_date_label': date_label,
        'changes': changes,
        'deadline_preview': deadline_preview,
    }
    return review, None


def _analyze_and_store_document(db, doc_id):
    document = db.execute("SELECT * FROM documents WHERE id=?", (doc_id,)).fetchone()
    if not document:
        return None, '附件不存在'
    path = UPLOAD_DIR / document['filename']
    if not path.exists():
        return None, '附件文件已删除'
    text = extract_document_text(path)
    review, review_error = _build_document_review(db, document, text)
    if review_error:
        return None, review_error
    review_status = 'no_text' if not review['text_length'] else ('pending' if review['changes'] else 'confirmed')
    review['review_status'] = review_status
    db.execute(
        """UPDATE documents
           SET doc_type=?, analysis_json=?, review_status=?,
               reviewed_at=CASE WHEN ?='confirmed' THEN ? ELSE reviewed_at END
           WHERE id=?""",
        (
            review['doc_type'],
            json.dumps(review, ensure_ascii=False),
            review_status,
            review_status,
            now_str(),
            doc_id,
        ),
    )
    return review, None


def _apply_review_updates(db, item_type, item_id, updates, document_name,
                          source_document_id=None):
    """Apply only user-confirmed review fields and refresh dependent deadlines."""
    meta = DOCUMENT_RECORD_META.get(item_type)
    if not meta:
        raise ValueError('暂不支持该附件类型')
    table, _ = meta
    record_row = db.execute(f"SELECT * FROM {table} WHERE id=?", (item_id,)).fetchone()
    if not record_row:
        raise ValueError('关联案件不存在')
    old_record = row_to_dict(record_row)
    allowed = DOCUMENT_ALLOWED_UPDATES[item_type]
    clean_updates = {}
    for field, value in (updates or {}).items():
        if field not in allowed or value is None:
            continue
        value = str(value).strip()
        if value:
            clean_updates[field] = value

    if 'status' in clean_updates:
        if item_type == 'patent':
            clean_updates['status'] = norm_patent_status(clean_updates['status'])
        elif item_type == 'trademark':
            clean_updates['status'] = norm_tm_status(clean_updates['status'])

    if clean_updates:
        assignments = [f"{field}=?" for field in clean_updates]
        assignments.append("updated_at=?")
        values = list(clean_updates.values()) + [now_str(), item_id]
        db.execute(f"UPDATE {table} SET {', '.join(assignments)} WHERE id=?", values)

        if item_type == 'patent':
            refreshed = row_to_dict(db.execute(
                "SELECT * FROM patents WHERE id=?", (item_id,)
            ).fetchone())
            current_year = calc_patent_current_year(
                refreshed.get('country'), refreshed.get('app_date'),
                refreshed.get('grant_date'), refreshed.get('current_year'),
                refreshed.get('next_fee_date'), refreshed.get('type'),
                fee_route=refreshed.get('fee_route'),
            )
            next_fee_date = calc_patent_next_fee_date(
                refreshed.get('country'), refreshed.get('app_date'),
                refreshed.get('grant_date'),
                current_year if current_year is not None else refreshed.get('current_year'),
                refreshed.get('next_fee_date'), refreshed.get('type'),
                refreshed.get('fee_route'),
            )
            db.execute(
                "UPDATE patents SET current_year=?, next_fee_date=? WHERE id=?",
                (current_year, next_fee_date, item_id),
            )

        new_status = clean_updates.get('status')
        old_status = old_record.get('status')
        if new_status and new_status != old_status:
            record_status_change(
                db, item_type, item_id, old_status, new_status,
                f"依据文书《{document_name}》核对更新",
                '待关联文件核对',
            )

        for field, value in clean_updates.items():
            db.execute(
                """INSERT INTO field_provenance
                   (item_type,item_id,field,value,source_document_id,confidence,extraction_method,confirmed_by,confirmed_at)
                   VALUES (?,?,?,?,?,?,'document_review','人工文书复核',?)""",
                (item_type, item_id, field, value, source_document_id, 1.0, now_str()),
            )
            if field not in {
                'status', 'oa_date', 'rejection_date', 'grant_notice_date',
                'opposition_notice_date', 'pub_date', 'grant_date', 'reg_date',
            }:
                continue
            db.execute(
                """INSERT INTO legal_events
                   (item_type,item_id,event_type,event_date,effective_date,
                    source_document_id,review_status,details,operator,confirmed_at)
                   VALUES (?,?,?,?,?,?, 'confirmed',?,?,?)""",
                (item_type, item_id, f'document_confirmed_{field}',
                 value if field != 'status' else None,
                 value if field in ('grant_date','reg_date') else None,
                 source_document_id,
                 json.dumps({
                     'field': field,
                     'old_value': old_record.get(field),
                     'new_value': value,
                     'document_name': document_name,
                     'rule_version': RULESET_VERSION,
                 }, ensure_ascii=False),
                 '人工文书复核', now_str()),
            )

    refreshed = row_to_dict(db.execute(
        f"SELECT * FROM {table} WHERE id=?", (item_id,)
    ).fetchone())
    changed_fields = set(clean_updates)
    deadlines = [
        item for item in _document_deadline_preview(item_type, refreshed)
        if item.get('source_field') in changed_fields or 'status' in changed_fields
    ]
    return clean_updates, deadlines


@app.route('/api/field-provenance/<item_type>/<int:item_id>', methods=['GET','OPTIONS'])
def field_provenance(item_type, item_id):
    if request.method == 'OPTIONS': return ok()
    with get_db() as db:
        rows = db.execute("""SELECT p.*, d.original_name AS source_document_name
                            FROM field_provenance p LEFT JOIN documents d ON d.id=p.source_document_id
                            WHERE p.item_type=? AND p.item_id=? ORDER BY p.confirmed_at DESC, p.id DESC""",
                          (item_type, item_id)).fetchall()
    return ok([dict(r) for r in rows])


@app.route('/api/documents/<item_type>/<int:item_id>', methods=['GET','OPTIONS'])
def list_docs(item_type, item_id):
    if request.method == 'OPTIONS': return ok()
    with get_db() as db:
        rows = db.execute(
            "SELECT * FROM documents WHERE item_type=? AND item_id=? ORDER BY uploaded_at DESC",
            (item_type, item_id)).fetchall()
    return ok([dict(r) for r in rows])

EVIDENCE_TYPES = ['销售合同','销售发票','商业宣传材料','广告合同','实物照片','展会参展证明',
                  '媒体报道','获奖证书','海关进出口证明','其他使用证据']

@app.route('/api/trademarks/<int:tid>/review-stage', methods=['POST','OPTIONS'])
def trademark_review_stage(tid):
    """推进商标驳回复审办理阶段，不改变案件的“复审中”状态。"""
    if request.method == 'OPTIONS': return ok()
    d = _json_payload()
    stage = str(d.get('stage') or '').strip()
    event_date = str(d.get('event_date') or date.today().isoformat())[:10]
    if stage not in ('simple', 'complete'):
        return err('无效的复审阶段', 400)
    try:
        date.fromisoformat(event_date)
    except ValueError:
        return err('办理日期格式不正确', 400)
    with get_db() as db:
        row = db.execute('SELECT * FROM trademarks WHERE id=?', (tid,)).fetchone()
        if not row: return err('商标不存在', 404)
        if row['status'] != '复审中': return err('请先将案件状态改为“复审中”', 400)
        if not row['rejection_date']: return err('请先填写驳回通知收文日', 400)
        if stage == 'complete' and not row['review_simple_submitted_date']:
            return err('请先确认已提交简单理由', 400)
        field = 'review_simple_submitted_date' if stage == 'simple' else 'review_complete_submitted_date'
        if row[field]: return err('该阶段已经确认提交', 400)
        db.execute(f'UPDATE trademarks SET {field}=?, updated_at=? WHERE id=?', (event_date, now_str(), tid))
        note = '确认提交' + ('简单理由' if stage == 'simple' else '完整复审理由')
        db.execute('INSERT INTO status_history (item_type,item_id,old_status,new_status,note,operator) VALUES (?,?,?,?,?,?)',
                   ('trademark', tid, '复审中', '复审中', note, str(d.get('operator') or '')))
        db.execute("""INSERT INTO legal_events
                   (item_type,item_id,event_type,event_date,effective_date,details,operator,confirmed_at)
                   VALUES (?,?,?,?,?,?,?,?)""",
                   ('trademark', tid, 'review_stage_submitted', event_date, event_date,
                    json.dumps({'stage': stage, 'note': note}, ensure_ascii=False),
                    str(d.get('operator') or ''), now_str()))
        sync_deadline_tasks(db)
        return ok({'id': tid, 'stage': stage, field: event_date, 'status': '复审中'})

@app.route('/api/trademarks/<int:tid>/evidence', methods=['GET','OPTIONS'])
def trademark_evidence_list(tid):
    if request.method == 'OPTIONS': return ok()
    with get_db() as db:
        rows = db.execute(
            "SELECT * FROM documents WHERE item_type='trademark_evidence' AND item_id=? ORDER BY uploaded_at DESC",(tid,)).fetchall()
    return ok([dict(r) for r in rows])

@app.route('/api/trademarks/<int:tid>/evidence-package', methods=['POST','OPTIONS'])
def trademark_evidence_package(tid):
    """打包商标使用证据，并附带可追溯清单。"""
    if request.method == 'OPTIONS': return ok()
    with get_db() as db:
        tm = db.execute('SELECT * FROM trademarks WHERE id=?', (tid,)).fetchone()
        if not tm: return err('商标不存在', 404)
        docs = [dict(r) for r in db.execute("SELECT * FROM documents WHERE item_type='trademark_evidence' AND item_id=? ORDER BY doc_type, uploaded_at", (tid,)).fetchall()]
    if not docs: return err('暂无可打包的使用证据', 400)
    buf = BytesIO()
    manifest = {'package_version': 'tm-evidence-1', 'generated_at': now_str(), 'trademark': {'id': tid, 'name': tm['name'], 'app_no': tm['app_no'], 'reg_no': tm['reg_no'], 'classes': tm['classes'], 'owner': tm['owner']}, 'files': []}
    with zipfile.ZipFile(buf, 'w', zipfile.ZIP_DEFLATED) as zf:
        for idx, doc in enumerate(docs, 1):
            path = UPLOAD_DIR / doc['filename']
            if not path.exists():
                manifest['files'].append({'document_id': doc['id'], 'name': doc['original_name'], 'missing': True})
                continue
            safe_name = _clean_filename(doc['original_name'] or doc['filename'])
            arc = f"{idx:02d}_{doc['doc_type']}_{safe_name}"
            zf.write(str(path), arc)
            manifest['files'].append({'document_id': doc['id'], 'name': doc['original_name'], 'archive_name': arc, 'evidence_type': doc['doc_type'], 'description': doc['description'], 'received_date': doc['received_date']})
        zf.writestr('证据清单.json', json.dumps(manifest, ensure_ascii=False, indent=2))
    buf.seek(0)
    return send_file(buf, mimetype='application/zip', as_attachment=True, download_name=f"商标使用证据包_{_clean_filename(tm['name'])}_{tid}.zip")

@app.route('/api/trademarks/<int:tid>/logo', methods=['POST','OPTIONS'])
def upload_logo(tid):
    if request.method == 'OPTIONS': return ok()
    if 'file' not in request.files: return err("未选择文件")
    file = request.files['file']
    with get_db() as db:
        row = db.execute("SELECT name,type,logo_filename FROM trademarks WHERE id=?", (tid,)).fetchone()
    if not row:
        return err("not found", 404)
    if norm_tm_type(row['type']) != '图形':
        return err("仅图形商标可设置商标图")
    ext = Path(file.filename).suffix.lower()
    if ext not in {'.png','.jpg','.jpeg','.gif','.webp','.svg'}: return err("仅支持图片格式")
    ts = datetime.now().strftime("%Y%m%d_%H%M%S")
    safe = f"logo_{tid}_{ts}{ext}"
    save_path = UPLOAD_DIR / safe
    file.save(str(save_path))
    with get_db() as db:
        if row['logo_filename'] and row['logo_filename'] != safe:
            _trash_add(db, 'trademark_logo', tid, f"{row['name']} · 商标图", {
                'version': 1,
                'trademark_id': tid,
                'logo_filename': row['logo_filename'],
            })
        db.execute("UPDATE trademarks SET logo_filename=?,updated_at=? WHERE id=?",(safe,now_str(),tid))
    return ok({"logo_filename": safe})

@app.route('/api/trademarks/<int:tid>/logo', methods=['DELETE','OPTIONS'])
def delete_logo(tid):
    if request.method == 'OPTIONS': return ok()
    with get_db() as db:
        row = db.execute("SELECT name,logo_filename FROM trademarks WHERE id=?", (tid,)).fetchone()
        if not row:
            return err('商标不存在', 404)
        if not row['logo_filename']:
            return err('商标图不存在', 404)
        trash_id = _trash_add(db, 'trademark_logo', tid, f"{row['name']} · 商标图", {
            'version': 1,
            'trademark_id': tid,
            'logo_filename': row['logo_filename'],
        })
        db.execute("UPDATE trademarks SET logo_filename='',updated_at=? WHERE id=?", (now_str(), tid))
    return ok({'trash_id': trash_id})

@app.route('/api/uploads/<path:filename>')
def serve_upload(filename):
    return send_from_directory(str(UPLOAD_DIR), filename)


@app.route('/api/documents/upload', methods=['POST','OPTIONS'])
def upload_doc():
    if request.method == 'OPTIONS': return ok()
    if 'file' not in request.files: return err("未选择文件")
    file = request.files['file']
    item_type = request.form.get('item_type'); item_id = request.form.get('item_id')
    doc_type = request.form.get('doc_type','其他'); description = request.form.get('description','')
    received_date = str(request.form.get('received_date','') or '').strip()
    if not file.filename or not item_type or not item_id: return err("参数缺失")
    if received_date and not _valid_iso_date_or_empty(received_date):
        return err('官文收文日期格式无效，应为 YYYY-MM-DD', 400)
    with get_db() as db:
        if not _record_exists(db, item_type, item_id):
            return err("关联案件不存在或类型无效", 404)
    ext = Path(file.filename).suffix.lower()
    if ext not in ALLOWED_EXT: return err(f"不支持: {ext}")
    tmp_dir = UPLOAD_DIR / 'tmp' / 'single'
    tmp_dir.mkdir(parents=True, exist_ok=True)
    tmp_path = tmp_dir / f"{uuid.uuid4().hex}_{_clean_filename(file.filename)}"
    file.save(str(tmp_path))
    analysis = None
    with get_db() as db:
        stored = _store_document_source(db, tmp_path, file.filename, item_type, item_id, move=True)
        cur = db.execute(
            """INSERT INTO documents
               (item_type,item_id,filename,original_name,file_size,mime_type,doc_type,description,received_date,file_hash)
               VALUES (?,?,?,?,?,?,?,?,?,?)""",
             (item_type, int(item_id), stored['filename'], file.filename, stored['file_size'],
             stored['mime_type'], doc_type, description, received_date or None, stored['file_hash']))
        doc_id = cur.lastrowid
        anchor_field = _suggest_document_anchor(item_type, doc_type, received_date)
        if anchor_field:
            table = DOCUMENT_RECORD_META.get(item_type, (None,))[0]
            if table:
                db.execute(
                    f"UPDATE {table} SET {anchor_field}=?, updated_at=? WHERE id=?",
                    (received_date, now_str(), int(item_id)),
                )
        # 上传完成后立即尝试一次 OCR/文书分析。结果只写入附件的待确认状态，
        # 不自动改动案件字段；前端可直接展示差异并由用户勾选应用。
        analysis, _ = _analyze_and_store_document(db, doc_id)
    return ok({"id":doc_id,"filename":stored['filename'],"original_name":file.filename,
               "file_size":stored['file_size'],"reused":stored['reused'],
               "analysis": analysis, "received_date": received_date})

@app.route('/api/documents/<int:doc_id>/analyze', methods=['GET','OPTIONS'])
def analyze_doc(doc_id):
    """Analyze an attachment and return a reviewable diff against its linked case."""
    if request.method == 'OPTIONS': return ok()
    with get_db() as db:
        review, review_error = _analyze_and_store_document(db, doc_id)
        if review_error:
            return err(review_error, 404 if '不存在' in review_error or '删除' in review_error else 400)
    return ok(review)


@app.route('/api/documents/<int:doc_id>/apply-analysis', methods=['POST','OPTIONS'])
def apply_document_analysis(doc_id):
    """Apply user-confirmed extracted fields to the linked case and close the review."""
    if request.method == 'OPTIONS':
        return ok()
    payload = request.get_json(force=True, silent=True) or {}
    updates = payload.get('updates') or {}
    action = payload.get('action', 'apply')
    if action not in ('apply', 'confirm'):
        return err('不支持的复核操作', 400)

    with get_db() as db:
        document = db.execute("SELECT * FROM documents WHERE id=?", (doc_id,)).fetchone()
        if not document:
            return err('附件不存在', 404)
        item_type = document['item_type']
        meta = DOCUMENT_RECORD_META.get(item_type)
        if not meta:
            return err('暂不支持该附件类型', 400)
        table, _ = meta
        try:
            clean_updates, deadlines = _apply_review_updates(
                db, item_type, document['item_id'],
                updates if action == 'apply' else {},
                document['original_name'],
                doc_id,
            )
        except ValueError as exc:
            return err(str(exc), 404 if '不存在' in str(exc) else 400)

        doc_type = str(payload.get('doc_type') or document['doc_type'] or '其他')
        db.execute(
            """UPDATE documents
               SET doc_type=?, review_status='applied', reviewed_at=?
               WHERE id=?""",
            (doc_type, now_str(), doc_id),
        )
    return ok({
        'updated_fields': list(clean_updates),
        'updated_count': len(clean_updates),
        'deadline_preview': deadlines,
        'review_status': 'applied',
    })


@app.route('/api/documents/<int:doc_id>/download')
def download_doc(doc_id):
    with get_db() as db: row = db.execute("SELECT * FROM documents WHERE id=?",(doc_id,)).fetchone()
    if not row: return err("不存在",404)
    f = UPLOAD_DIR/row['filename']
    if not f.exists(): return err("已删除",404)
    return send_file(str(f), download_name=row['original_name'], as_attachment=True)

@app.route('/api/documents/<int:doc_id>/preview')
def preview_doc(doc_id):
    with get_db() as db: row = db.execute("SELECT * FROM documents WHERE id=?",(doc_id,)).fetchone()
    if not row: return err("不存在",404)
    f = UPLOAD_DIR/row['filename']
    if not f.exists(): return err("已删除",404)
    return send_file(str(f), mimetype=row['mime_type'] or 'application/octet-stream')

@app.route('/api/documents/<int:doc_id>', methods=['GET','PUT','DELETE','OPTIONS'])
def delete_doc(doc_id):
    if request.method == 'OPTIONS': return ok()
    if request.method == 'PUT':
        d = request.get_json(force=True, silent=True) or {}
        with get_db() as db:
            if not db.execute("SELECT 1 FROM documents WHERE id=?", (doc_id,)).fetchone():
                return err("不存在", 404)
            try:
                db.execute("UPDATE documents SET doc_type=?, description=? WHERE id=?",
                           [d.get('doc_type','其他'), d.get('description',''), doc_id])
            except Exception:
                db.execute("UPDATE documents SET doc_type=? WHERE id=?",
                           [d.get('doc_type','其他'), doc_id])
        return ok({'updated': 1})
    with get_db() as db:
        row = db.execute("SELECT * FROM documents WHERE id=?",(doc_id,)).fetchone()
        if not row: return err("不存在",404)
        result = _delete_document_rows(db, [doc_id])
    return ok(result)

# ══════════════ 多维度 Excel 导出 ══════════════
ALL_FIELDS = {
    'patents': [('title','发明名称'),('app_no','申请号'),('pub_no','公开号'),('grant_no','授权号'),('type','专利类型'),('country','国家/地区'),('status','状态'),('app_date','申请日'),('pub_date','公开日'),('grant_date','授权日'),('inventors','发明人'),('owner','权利人'),('agent','代理机构'),('ipc','技术方向'),('next_fee_date','下次年费日'),('current_year','当前年度'),('fee_entity','费减主体'),('fee_reduction_approved','费减已获批准'),('fee_route','涉外续展路线'),('notes','备注')],
    'trademarks': [('name','商标名称'),('app_no','申请号'),('reg_no','注册号'),('type','商标类型'),('classes','尼斯分类'),('goods_services','商品/服务项目'),('country','国家/地区'),('status','状态'),('app_date','申请日'),('pub_date','初审公告日'),('initial_review_notice_no','初审公告期号'),('reg_announcement_no','注册公告期号'),('reg_date','注册公告日'),('exclusive_right_period','专用权日期'),('renewal_date','续展截止日'),('owner','权利人'),('agent','代理机构'),('notes','备注')],
    'copyrights': [('name','软件名称'),('version','版本号'),('reg_no','登记号'),('reg_date','登记日期'),('completion_date','完成日期'),('owner','著作权人'),('development_mode','开发方式'),('acquisition_mode','权利取得方式'),('owner_type','著作权人主体'),('publication_status','发表状态'),('first_publication_date','首次发表日'),('first_publication_place','首次发表地'),('registration_status','登记状态'),('language','开发语言'),('notes','备注')],
}

def _build_excel(title, field_defs, rows):
    try: import openpyxl; from openpyxl.styles import Font,PatternFill,Alignment,Border,Side
    except: return None
    wb=openpyxl.Workbook(); ws=wb.active; ws.title=title
    hf=Font(bold=True,color='FFFFFF',size=11); hfill=PatternFill('solid',fgColor='1E40AF')
    ha=Alignment(horizontal='center',vertical='center',wrap_text=True)
    thin=Border(left=Side(style='thin'),right=Side(style='thin'),top=Side(style='thin'),bottom=Side(style='thin'))
    afill=PatternFill('solid',fgColor='EFF6FF')
    for ci,(k,l) in enumerate(field_defs,1):
        c=ws.cell(row=1,column=ci,value=l); c.font=hf; c.fill=hfill; c.alignment=ha; c.border=thin
    for ri,row in enumerate(rows,2):
        for ci,(key,_) in enumerate(field_defs,1):
            val=row.get(key,'')
            if isinstance(val,list): val=', '.join(str(v) for v in val)
            if key=='current_year' and val: val=f"第{val}年"
            c=ws.cell(row=ri,column=ci,value=str(val) if val is not None else '')
            c.alignment=Alignment(vertical='center'); c.border=thin
            if ri%2==0: c.fill=afill
    for col in ws.columns:
        ml=max((len(str(c.value or '')) for c in col),default=8)
        ws.column_dimensions[col[0].column_letter].width=min(ml+4,45)
    ws.row_dimensions[1].height=28; ws.freeze_panes='A2'
    buf=BytesIO(); wb.save(buf); buf.seek(0); return buf

@app.route('/api/export/excel', methods=['POST','OPTIONS'])
def export_excel():
    if request.method == 'OPTIONS': return ok()
    d = request.get_json(silent=True) or {}
    if not isinstance(d, dict):
        return err('请求参数格式错误', 400)
    data_type=d.get('type','patents'); columns=d.get('columns',[]); filters=d.get('filters',{})
    if data_type not in ALL_FIELDS:
        return err('不支持的导出类型', 400)
    if columns is not None and not isinstance(columns, list):
        return err('columns 必须是数组', 400)
    if not isinstance(filters, dict):
        return err('filters 必须是对象', 400)
    all_fm={k:l for k,l in ALL_FIELDS.get(data_type,[])}
    all_keys=[k for k,_ in ALL_FIELDS.get(data_type,[])]
    field_defs=[(k,all_fm[k]) for k in all_keys if k in (columns or all_keys) and k in all_fm]
    with get_db() as db:
        def flike(v): return f'%{v}%'
        def status_sql_clause(status_value):
            if isinstance(status_value, list):
                vals = [str(x).strip() for x in status_value if str(x).strip()]
                if not vals:
                    return '', []
                return f" IN ({','.join('?' * len(vals))})", vals
            if status_value:
                return "=?", [status_value]
            return '', []
        if data_type=='patents':
            sql="SELECT * FROM patents WHERE 1=1"; params=[]
            q=filters.get('q','').strip()
            if q:
                sql+=" AND (title LIKE ? OR app_no LIKE ? OR pub_no LIKE ? OR grant_no LIKE ? OR inventors LIKE ? OR owner LIKE ? OR ipc LIKE ?)"
                params+=[flike(q)]*7
            sc, sp = status_sql_clause(filters.get('status'))
            if sc: sql+=f" AND status{sc}"; params+=sp
            if filters.get('type'):    sql+=" AND type=?"; params.append(filters['type'])
            if filters.get('country'): sql+=" AND country=?"; params.append(filters['country'])
            if filters.get('owner'):   sql+=" AND owner LIKE ?"; params.append(flike(filters['owner']))
            if filters.get('inventor'):sql+=" AND inventors LIKE ?"; params.append(flike(filters['inventor']))
            if filters.get('fee_entity'): sql+=" AND fee_entity=?"; params.append(filters['fee_entity'])
            if filters.get('app_date_from'): sql+=" AND app_date>=?"; params.append(filters['app_date_from'])
            if filters.get('app_date_to'):   sql+=" AND app_date<=?"; params.append(filters['app_date_to'])
            if filters.get('grant_date_from'): sql+=" AND grant_date>=?"; params.append(filters['grant_date_from'])
            if filters.get('grant_date_to'):   sql+=" AND grant_date<=?"; params.append(filters['grant_date_to'])
            if filters.get('year_from'): sql+=" AND current_year>=?"; params.append(int(filters['year_from']))
            if filters.get('year_to'):   sql+=" AND current_year<=?"; params.append(int(filters['year_to']))
            today=date.today().isoformat(); fd=filters.get('fee_due','')
            if fd=='overdue': sql+=" AND next_fee_date IS NOT NULL AND next_fee_date<?"; params.append(today)
            elif fd=='7':  sql+=" AND next_fee_date IS NOT NULL AND next_fee_date>=? AND next_fee_date<=date(?,'+'||'7 days')"; params+=[today,today]
            elif fd=='30': sql+=" AND next_fee_date IS NOT NULL AND next_fee_date>=? AND next_fee_date<=date(?,'+'||'30 days')"; params+=[today,today]
            elif fd=='90': sql+=" AND next_fee_date IS NOT NULL AND next_fee_date>=? AND next_fee_date<=date(?,'+'||'90 days')"; params+=[today,today]
            rows=[row_to_dict(r) for r in db.execute(sql+" ORDER BY next_fee_date,created_at DESC",params).fetchall()]
        elif data_type=='trademarks':
            sql="SELECT * FROM trademarks WHERE 1=1"; params=[]
            q=filters.get('q','').strip()
            if q:
                sql+=" AND (name LIKE ? OR app_no LIKE ? OR reg_no LIKE ? OR owner LIKE ? OR classes LIKE ?)"
                params+=[flike(q)]*5
            sc, sp = status_sql_clause(filters.get('status'))
            if sc: sql+=f" AND status{sc}"; params+=sp
            if filters.get('type'):     sql+=" AND type=?"; params.append(filters['type'])
            if filters.get('country'):  sql+=" AND country=?"; params.append(filters['country'])
            if filters.get('owner'):    sql+=" AND owner LIKE ?"; params.append(flike(filters['owner']))
            if filters.get('classes'):  sql+=" AND classes LIKE ?"; params.append(flike(filters['classes']))
            if filters.get('app_date_from'): sql+=" AND app_date>=?"; params.append(filters['app_date_from'])
            if filters.get('app_date_to'):   sql+=" AND app_date<=?"; params.append(filters['app_date_to'])
            if filters.get('reg_date_from'):     sql+=" AND reg_date>=?"; params.append(filters['reg_date_from'])
            if filters.get('reg_date_to'):       sql+=" AND reg_date<=?"; params.append(filters['reg_date_to'])
            if filters.get('renewal_date_from'): sql+=" AND renewal_date>=?"; params.append(filters['renewal_date_from'])
            if filters.get('renewal_date_to'):   sql+=" AND renewal_date<=?"; params.append(filters['renewal_date_to'])
            rows=[row_to_dict(r) for r in db.execute(sql+" ORDER BY created_at DESC",params).fetchall()]
        else:
            sql="SELECT * FROM copyrights WHERE 1=1"; params=[]
            q=filters.get('q','').strip()
            if q:
                sql+=" AND (name LIKE ? OR reg_no LIKE ? OR owner LIKE ?)"; params+=[flike(q)]*3
            if filters.get('type'):  sql+=" AND type=?"; params.append(filters['type'])
            if filters.get('owner'): sql+=" AND owner LIKE ?"; params.append(flike(filters['owner']))
            if filters.get('reg_date_from'): sql+=" AND reg_date>=?"; params.append(filters['reg_date_from'])
            if filters.get('reg_date_to'):   sql+=" AND reg_date<=?"; params.append(filters['reg_date_to'])
            if filters.get('completion_date_from'): sql+=" AND completion_date>=?"; params.append(filters['completion_date_from'])
            if filters.get('completion_date_to'):   sql+=" AND completion_date<=?"; params.append(filters['completion_date_to'])
            rows=[row_to_dict(r) for r in db.execute(sql+" ORDER BY created_at DESC",params).fetchall()]
    if not rows: return err("没有符合条件的记录")
    FNAMES={'patents':f'专利导出_{date.today()}.xlsx','trademarks':f'商标导出_{date.today()}.xlsx','copyrights':f'软著导出_{date.today()}.xlsx'}
    buf=_build_excel({'patents':'专利列表','trademarks':'商标列表','copyrights':'软著列表'}.get(data_type,'数据'),field_defs,rows)
    if not buf: return err("openpyxl 未安装")
    return send_file(buf,mimetype='application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
                     as_attachment=True,download_name=FNAMES.get(data_type,'export.xlsx'))

# ══════════════ 全局搜索 ══════════════
@app.route('/api/search', methods=['GET','OPTIONS'])
def global_search():
    if request.method == 'OPTIONS': return ok()
    q = request.args.get('q','').strip()
    if len(q) < 1: return ok({'patents':[],'trademarks':[],'copyrights':[],'total':0})
    p = f'%{q}%'
    with get_db() as db:
        patents = [row_to_dict(r) for r in db.execute(
            "SELECT id,title,app_no,pub_no,grant_no,status,type,country,owner,inventors,app_date FROM patents "
            "WHERE title LIKE ? OR app_no LIKE ? OR grant_no LIKE ? OR pub_no LIKE ? OR inventors LIKE ? OR owner LIKE ? OR ipc LIKE ? "
            "ORDER BY updated_at DESC LIMIT 10", [p]*7).fetchall()]
        trademarks = [row_to_dict(r) for r in db.execute(
            "SELECT id,name,app_no,reg_no,status,type,classes,country,owner,app_date FROM trademarks "
            "WHERE name LIKE ? OR app_no LIKE ? OR reg_no LIKE ? OR owner LIKE ? OR classes LIKE ? "
            "ORDER BY updated_at DESC LIMIT 10", [p]*5).fetchall()]
        copyrights = [row_to_dict(r) for r in db.execute(
            "SELECT id,name,reg_no,owner,type,version,reg_date FROM copyrights "
            "WHERE name LIKE ? OR reg_no LIKE ? OR owner LIKE ? "
            "ORDER BY updated_at DESC LIMIT 8", [p]*3).fetchall()]
    total = len(patents) + len(trademarks) + len(copyrights)
    return ok({'patents':patents,'trademarks':trademarks,'copyrights':copyrights,'total':total})

# ══════════════ EXCEL 批量导入 ══════════════
IMPORT_FIELD_MAP = {
    'patents': {
        # 名称
        '发明名称':['title'],'名称':['title'],'专利名称':['title'],'标题':['title'],
        # 申请号
        '申请号':['app_no'],'申请号码':['app_no'],
        # 公开号
        '公开号':['pub_no'],'公告号':['pub_no'],'公开公告号':['pub_no'],
        # 授权号
        '授权号':['grant_no'],'专利号':['grant_no'],'证书号':['grant_no'],
        # 类型
        '专利类型':['type'],'类型':['type'],'案件类型':['type'],
        # 国家
        '国家':['country'],'国家/地区':['country'],'地区':['country'],'申请国':['country'],
        # 状态
        '状态':['status'],'案件状态':['status'],'当前状态':['status'],
        # 日期
        '申请日':['app_date'],'申请日期':['app_date'],'提交日':['app_date'],
        '公开日':['pub_date'],'公开日期':['pub_date'],'公布日':['pub_date'],
        '授权日':['grant_date'],'授权日期':['grant_date'],'授权公告日':['grant_date'],
        # 人员
        '发明人':['inventors'],'发明人/设计人':['inventors'],'设计人':['inventors'],'创作人':['inventors'],
        '权利人/申请人':['owner'],'权利人':['owner'],'申请人':['owner'],'专利权人':['owner'],'持有人':['owner'],
        '代理机构':['agent'],'代理事务所':['agent'],'代理人':['agent'],
        # 技术
        'IPC分类号':['ipc'],'IPC':['ipc'],'IPC分类':['ipc'],'分类号':['ipc'],'国际分类':['ipc'],'技术方向':['ipc'],
        # 年费
        '下次年费日':['next_fee_date'],'年费截止日':['next_fee_date'],'年费日':['next_fee_date'],'缴费截止日':['next_fee_date'],
        '费减主体类型':['fee_entity'],'费减类型':['fee_entity'],'费减主体':['fee_entity'],'费减':['fee_entity'],
        '费减已获批准':['fee_reduction_approved'],'费减批准':['fee_reduction_approved'],
        '涉外续展路线':['fee_route'],'续展路线':['fee_route'],
        # 其他
        '备注':['notes'],'说明':['notes'],'备注说明':['notes'],
        '标签':['tags'],
    },
    'trademarks': {
        # 名称
        '商标名称':['name'],'商标名':['name'],'名称':['name'],'商标':['name'],'品牌名称':['name'],
        # 号码
        '申请号':['app_no'],'商标申请号':['app_no'],
        '注册号':['reg_no'],'商标注册号':['reg_no'],'证书号':['reg_no'],
        # 类型
        '商标类型':['type'],'类型':['type'],'标志类型':['type'],
        # 分类
        '尼斯分类':['classes'],'商品类别':['classes'],'类别':['classes'],'分类':['classes'],'尼斯类别':['classes'],
        # 服务项
        '商品/服务项':['goods_services'],'商品服务项目':['goods_services'],'商品服务':['goods_services'],'服务项':['goods_services'],'商品及服务项目':['goods_services'],'商品服务说明':['goods_services'],
        # 地区
        '国家':['country'],'国家/地区':['country'],'申请国':['country'],'地区':['country'],
        # 状态
        '状态':['status'],'案件状态':['status'],'商标状态':['status'],
        # 日期
        '申请日':['app_date'],'申请日期':['app_date'],
        '初审公告日':['pub_date'],'初审公告日期':['pub_date'],
        '初审公告期号':['initial_review_notice_no'],
        '注册日':['reg_date'],'注册日期':['reg_date'],'注册公告日':['reg_date'],'注册公告日期':['reg_date'],
        '注册公告期号':['reg_announcement_no'],
        '专用权日期':['exclusive_right_period'],'专用权期间':['exclusive_right_period'],
        '续展截止日':['renewal_date'],'续展日期':['renewal_date'],'有效期至':['renewal_date'],'到期日':['renewal_date'],
        # 权利人
        '权利人/申请人':['owner'],'权利人':['owner'],'申请人':['owner'],'申请人中文':['owner'],'商标权人':['owner'],'持有人':['owner'],
        '代理机构':['agent'],'代理事务所':['agent'],'代理人':['agent'],
        # 其他
        '备注':['notes'],'说明':['notes'],
        '标签':['tags'],
    },
    'copyrights': {
        # 名称
        '软件名称':['name'],'名称':['name'],'软件全称':['name'],'作品名称':['name'],
        # 版本
        '版本号':['version'],'版本':['version'],'软件版本':['version'],
        # 号码
        '登记号':['reg_no'],'著作权登记号':['reg_no'],'软著登记号':['reg_no'],'证书号':['reg_no'],
        # 日期
        '完成日期':['completion_date'],'开发完成日':['completion_date'],'创作完成日期':['completion_date'],
        '登记日期':['reg_date'],'登记日':['reg_date'],'发证日期':['reg_date'],
        # 权利人
        '著作权人':['owner'],'权利人':['owner'],'申请人':['owner'],'所有人':['owner'],
        # 类型
        '著作权类型':['type'],'类型':['type'],'软件类型':['type'],
        '开发方式':['development_mode'],'权利取得方式':['acquisition_mode'],
        '著作权人主体':['owner_type'],'发表状态':['publication_status'],
        '首次发表日':['first_publication_date'],'首次发表地':['first_publication_place'],
        '登记状态':['registration_status'],
        # 技术
        '开发语言':['language'],'语言':['language'],'编程语言':['language'],
        '开发工具':['notes'],'源代码行数':['notes'],
        # 其他
        '备注':['notes'],'说明':['notes'],
    }
}

IMPORT_DATE_FIELDS = {
    'app_date', 'pub_date', 'grant_date', 'next_fee_date', 'reg_date',
    'renewal_date', 'completion_date', 'first_publication_date',
}
IMPORT_IDENTIFIER_FIELDS = {'app_no', 'pub_no', 'grant_no', 'reg_no'}
IMPORT_MAX_ROWS = 10000
IMPORT_MAX_BYTES = 25 * 1024 * 1024


def _normalize_import_value(value):
    if value is None:
        return ''
    if isinstance(value, (datetime, date)):
        return value.strftime('%Y-%m-%d')
    if isinstance(value, float) and value.is_integer():
        return str(int(value))
    return str(value).strip()


def _valid_iso_date_or_empty(value):
    if value in (None, ''):
        return True
    return _to_date(value) is not None and len(str(value).strip()) >= 10


def _validate_import_record(dtype, record):
    errors = []
    required = 'title' if dtype == 'patents' else 'name'
    if not str(record.get(required) or '').strip():
        errors.append('缺少专利名称' if dtype == 'patents' else '缺少名称')
    for field in IMPORT_DATE_FIELDS:
        if field in record and not _valid_iso_date_or_empty(record.get(field)):
            errors.append(f'{field} 日期格式无效，应为 YYYY-MM-DD')
    if dtype == 'trademarks' and record.get('classes'):
        for part in re.split(r'[,，;；\s/]+', str(record['classes'])):
            if not part:
                continue
            digits = re.sub(r'\D', '', part)
            if not digits or not 1 <= int(digits) <= 45:
                errors.append(f'尼斯分类无效：{part}')
                break
    return errors

@app.route('/api/import/preview', methods=['POST','OPTIONS'])
def import_preview():
    """解析上传的Excel，返回字段映射和预览行"""
    if request.method == 'OPTIONS': return ok()
    if 'file' not in request.files: return err("未选择文件")
    file = request.files['file']
    dtype = request.form.get('type','patents')
    ext = Path(file.filename).suffix.lower()
    if ext not in ('.xlsx','.csv'):
        return err("仅支持 xlsx/csv；旧版 xls 请先在表格软件中另存为 xlsx")

    try:
        import openpyxl, io
        content_bytes = file.read()
        if len(content_bytes) > IMPORT_MAX_BYTES:
            return err('导入文件不能超过25MB')
        if ext == '.csv':
            import csv
            try:
                content = content_bytes.decode('utf-8-sig')
            except UnicodeDecodeError:
                return err('CSV 必须使用 UTF-8 编码')
            reader = csv.DictReader(io.StringIO(content))
            raw_rows = [
                {str(k or '').strip(): _normalize_import_value(v) for k, v in dict(r).items()}
                for r in reader
            ]
            if len(raw_rows) > IMPORT_MAX_ROWS:
                return err(f'单次最多导入 {IMPORT_MAX_ROWS} 行，请拆分文件')
            headers = list(raw_rows[0].keys()) if raw_rows else []
        else:
            wb = openpyxl.load_workbook(io.BytesIO(content_bytes), data_only=True, read_only=True)
            ws = wb.active
            # 部分商标查询导出文件会把 worksheet 的 dimension 错写为 A1；
            # 重置后按真实 XML 行读取，避免只导入表头。
            ws.reset_dimensions()
            rows = ws.iter_rows(values_only=True)
            first_row = next(rows, None)
            if not first_row: return err("Excel 文件为空")
            headers = [str(h).strip() if h is not None else '' for h in first_row]
            raw_rows = []
            for row in rows:
                if any(v is not None and str(v).strip() for v in row):
                    raw_rows.append({headers[i]: _normalize_import_value(v) for i,v in enumerate(row) if i < len(headers)})
                if len(raw_rows) > IMPORT_MAX_ROWS:
                    return err(f'单次最多导入 {IMPORT_MAX_ROWS} 行，请拆分文件')
    except Exception as e:
        return err(f"解析失败: {str(e)}")

    fmap = IMPORT_FIELD_MAP.get(dtype, {})
    mapping = {}
    for h in headers:
        if not h: continue
        hc = h.strip()
        if hc in fmap: mapping[hc] = fmap[hc][0]

    mapped_rows = []
    warnings = []
    for index, raw in enumerate(raw_rows, 2):
        record = {
            db_field: raw.get(header, '')
            for header, db_field in mapping.items()
            if raw.get(header, '') not in (None, '')
        }
        mapped_rows.append(record)
        row_errors = _validate_import_record(dtype, record)
        if row_errors and len(warnings) < 100:
            warnings.append({'row': index, 'errors': row_errors})
        for header, db_field in mapping.items():
            value = raw.get(header, '')
            if db_field in IMPORT_IDENTIFIER_FIELDS and isinstance(value, str) and re.search(r'[eE][+-]?\d+$', value):
                warnings.append({'row': index, 'errors': [f'{header} 疑似科学计数法，原始编号可能已丢失精度']})
                break

    preview = raw_rows[:5]
    return ok({'headers': headers, 'mapping': mapping, 'preview': preview,
               'total': len(raw_rows), 'raw_rows': raw_rows,
               'validation_warnings': warnings,
               'validation_warning_count': sum(
                   bool(_validate_import_record(dtype, row)) for row in mapped_rows),
               'sheet_name': getattr(ws, 'title', '') if ext == '.xlsx' else ''})

@app.route('/api/import/confirm', methods=['POST','OPTIONS'])
def import_confirm():
    """根据字段映射将数据写入数据库"""
    if request.method == 'OPTIONS': return ok()
    d = _json_payload()
    dtype  = d.get('type','patents')
    rows   = d.get('rows', [])
    mapping = d.get('mapping', {})  # {excel_header: db_field}
    if dtype not in ('patents','trademarks','copyrights'):
        return err('导入类型无效')
    if not rows: return err("无数据")
    if len(rows) > IMPORT_MAX_ROWS:
        return err(f'单次最多导入 {IMPORT_MAX_ROWS} 行')

    def map_row(raw):
        r = {}
        for h, dbf in mapping.items():
            v = raw.get(h,'')
            if v not in (None, ''):
                r[dbf] = _normalize_import_value(v)
        return r

    inserted = 0
    updated = 0
    skipped  = 0
    duplicates = 0
    row_errors = []
    first_error = None
    with get_db() as db:
        for row_number, raw in enumerate(rows, 2):
            r = map_row(raw)
            try:
                validation_errors = _validate_import_record(dtype, r)
                if validation_errors:
                    skipped += 1
                    row_errors.append({'row': row_number, 'errors': validation_errors})
                    if first_error is None:
                        first_error = '；'.join(validation_errors)
                    continue
                if dtype == 'patents':
                    # 重复检测：相同申请号已存在则跳过
                    app_no = r.get('app_no','').strip()
                    if app_no and db.execute("SELECT 1 FROM patents WHERE app_no=?", (app_no,)).fetchone():
                        duplicates += 1; continue
                    app_date = r.get('app_date')
                    country = _normalize_country(r.get('country', '中国'))
                    p_type = norm_patent_type(r.get('type','发明'))
                    fee_route = _safe_patent_fee_route(country, p_type, r.get('fee_route','auto'))
                    cy = calc_patent_current_year(
                        country, app_date, r.get('grant_date'),
                        r.get('current_year'), r.get('next_fee_date'), p_type,
                        fee_route=fee_route)
                    next_fee_date = calc_patent_next_fee_date(
                        country, app_date, r.get('grant_date'),
                        cy if cy is not None else r.get('current_year'),
                        r.get('next_fee_date'), p_type, fee_route)
                    _p_all = {
                        'title': r.get('title',''), 'app_no': app_no, 'pub_no': r.get('pub_no',''),
                        'grant_no': r.get('grant_no',''), 'type': p_type,
                        'country': country, 'status': norm_patent_status(r.get('status','已受理')),
                        'app_date': app_date, 'pub_date': r.get('pub_date'),
                        'grant_date': r.get('grant_date'), 'inventors': r.get('inventors',''),
                        'owner': r.get('owner',''), 'agent': r.get('agent',''), 'ipc': r.get('ipc',''),
                        'next_fee_date': next_fee_date, 'current_year': cy,
                        'fee_entity': r.get('fee_entity','无费减'),
                        'fee_reduction_approved': 1 if _as_bool(r.get('fee_reduction_approved')) else 0,
                        'fee_route': fee_route,
                        'fee_deadline_verified': 1 if _as_bool(r.get('fee_deadline_verified')) else 0,
                        'notes': r.get('notes',''), 'tags': json.dumps([])
                    }
                    _p_cols = {row[1] for row in db.execute('PRAGMA table_info(patents)').fetchall()}
                    _p_ins = {k: v for k, v in _p_all.items() if k in _p_cols}
                    cur = db.execute(
                        'INSERT INTO patents ({}) VALUES ({})'.format(
                            ','.join(_p_ins.keys()), ','.join('?'*len(_p_ins))),
                        list(_p_ins.values()))
                    record_status_change(db,'patent',cur.lastrowid,None,_p_all['status'],'Excel导入')
                elif dtype == 'trademarks':
                    app_no = str(r.get('app_no') or '').strip()
                    reg_no = str(r.get('reg_no') or '').strip()
                    classes = str(r.get('classes') or '').strip()
                    existing = None
                    if app_no:
                        existing = db.execute(
                            "SELECT id FROM trademarks WHERE app_no=? AND COALESCE(classes,'')=?",
                            (app_no, classes),
                        ).fetchone()
                    if not existing and reg_no:
                        existing = db.execute(
                            "SELECT id FROM trademarks WHERE reg_no=? AND COALESCE(classes,'')=?",
                            (reg_no, classes),
                        ).fetchone()
                    _tm_status = norm_tm_status(r.get('status','已受理'))
                    _tm_reg_date = r.get('reg_date')
                    _tm_all = {
                        'name': r.get('name',''), 'app_no': app_no or reg_no,
                        'reg_no': r.get('reg_no',''), 'type': norm_tm_type(r.get('type','文字')),
                        'classes': r.get('classes',''), 'goods_services': r.get('goods_services',''),
                        'country': r.get('country','中国'), 'status': _tm_status,
                        'app_date': r.get('app_date'), 'pub_date': r.get('pub_date'),
                        'initial_review_notice_no': r.get('initial_review_notice_no',''),
                        'reg_announcement_no': r.get('reg_announcement_no',''),
                        'reg_date': _tm_reg_date,
                        'exclusive_right_period': r.get('exclusive_right_period',''),
                        'renewal_date': sanitize_tm_renewal_date(
                            _tm_status, _tm_reg_date, r.get('renewal_date')),
                        'owner': r.get('owner',''),
                        'agent': r.get('agent',''), 'notes': r.get('notes',''), 'tags': json.dumps([])
                    }
                    # 同一申请号/类别再次导入时，把表格中明确提供的商标公告、
                    # 专用权及服务项数据回填到原案件，而非整条跳过。这样既能补齐
                    # 历史记录，又不会覆盖用户未在本次表格中提供的其他字段。
                    if existing:
                        enrichment_fields = (
                            'app_date', 'pub_date', 'initial_review_notice_no',
                            'reg_announcement_no', 'reg_date',
                            'exclusive_right_period', 'goods_services',
                        )
                        updates = {
                            field: _tm_all[field]
                            for field in enrichment_fields
                            if _tm_all.get(field) not in (None, '')
                        }
                        if updates:
                            current = db.execute(
                                "SELECT {} FROM trademarks WHERE id=?".format(','.join(updates)),
                                (existing['id'],),
                            ).fetchone()
                            updates = {
                                field: value for field, value in updates.items()
                                if (current[field] or '') != value
                            }
                        if updates:
                            assignments = ','.join(f"{field}=?" for field in updates)
                            db.execute(
                                f"UPDATE trademarks SET {assignments},updated_at=? WHERE id=?",
                                list(updates.values()) + [now_str(), existing['id']],
                            )
                            updated += 1
                        else:
                            duplicates += 1
                        continue
                    _tm_cols = {row[1] for row in db.execute('PRAGMA table_info(trademarks)').fetchall()}
                    _tm_ins = {k: v for k, v in _tm_all.items() if k in _tm_cols}
                    cur = db.execute(
                        'INSERT INTO trademarks ({}) VALUES ({})'.format(
                            ','.join(_tm_ins.keys()), ','.join('?'*len(_tm_ins))),
                        list(_tm_ins.values()))
                    record_status_change(db,'trademark',cur.lastrowid,None,_tm_all['status'],'Excel导入')
                else:
                    # 软著：相同登记号已存在则跳过
                    reg_no = r.get('reg_no','').strip()
                    if reg_no and db.execute("SELECT 1 FROM copyrights WHERE reg_no=?", (reg_no,)).fetchone():
                        duplicates += 1; continue
                    db.execute("""INSERT INTO copyrights
                        (name,version,reg_no,reg_date,completion_date,owner,type,language,
                         development_mode,acquisition_mode,owner_type,publication_status,
                         first_publication_date,first_publication_place,registration_status,
                         notes,tags)
                        VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)""",
                        (r.get('name',''),r.get('version',''),reg_no,
                         r.get('reg_date'),r.get('completion_date'),
                         r.get('owner',''),r.get('acquisition_mode',r.get('type','原始取得')),
                         r.get('language',''),r.get('development_mode','独立开发'),
                         r.get('acquisition_mode','原始取得'),r.get('owner_type','法人或其他组织'),
                         r.get('publication_status','未发表'),r.get('first_publication_date'),
                         r.get('first_publication_place',''),r.get('registration_status','已登记'),
                         r.get('notes',''),json.dumps([])))
                inserted += 1
            except Exception as e:
                import traceback as _tb
                err_msg = str(e)
                full_err = _tb.format_exc()
                print(f"[import_confirm] row error ({dtype}): {full_err}")
                skipped += 1
                row_errors.append({'row': row_number, 'errors': [err_msg]})
                if first_error is None:
                    first_error = err_msg + ' | row: ' + str({k:v for k,v in list(r.items())[:3]})
    return ok({'inserted': inserted, 'updated': updated, 'skipped': skipped, 'duplicates': duplicates,
               'first_error': first_error, 'row_errors': row_errors[:200]})

@app.route('/api/import/template/<dtype>')
def import_template(dtype):
    """下载导入模板（含全字段 + 说明 + 枚举值）"""
    if dtype not in ('patents', 'trademarks', 'copyrights'):
        return err('不支持的模板类型', 400)
    try:
        import openpyxl
        from openpyxl.styles import Font, PatternFill, Alignment, Border, Side, Protection
        from openpyxl.comments import Comment
    except: return err("openpyxl未安装")

    wb = openpyxl.Workbook()
    ws = wb.active

    # ── 字段定义：(列头, 说明注释, 示例值, 列宽) ────────────────
    if dtype == 'patents':
        ws.title = '专利导入'
        fields = [
            ('发明名称',       '必填。专利申请时的名称',                                      '一种基于深度学习的图像识别方法',   30),
            ('申请号',         '格式: CN202410000001.0 / PCT/CN2024/000001',                  'CN202410000001.0',                 22),
            ('公开号',         '格式: CN115000000A（申请公布号）',                            'CN115000000A',                     18),
            ('授权号',         '格式: CN115000000B（授权公告号）',                            'CN115000000B',                     18),
            ('专利类型',       '枚举: 发明 / 实用新型 / 外观设计',                           '发明',                             14),
            ('国家/地区',      '枚举: 中国 / 美国 / 欧洲 / 日本 / 韩国 / PCT / 其他',       '中国',                             14),
            ('状态',           '枚举: 已受理/已公开/实审中/已授权/复审中/已驳回/主动撤回/失效','已受理',                          14),
            ('申请日',         '格式: YYYY-MM-DD',                                           '2024-01-15',                       14),
            ('公开日',         '格式: YYYY-MM-DD，申请公布日期',                              '2024-07-15',                       14),
            ('授权日',         '格式: YYYY-MM-DD，授权公告日期',                              '',                                 14),
            ('发明人',         '多人用逗号分隔，如: 张三,李四,王五',                         '张三,李四',                        20),
            ('权利人/申请人',  '专利权人或申请人全称；多个权利人用顿号或逗号分隔',              'XX科技有限公司',                   22),
            ('代理机构',       '代理事务所全称（可为空）',                                    '北京XX专利代理有限公司',           24),
            ('代理人',         '代理人姓名（可为空）',                                        '张代理',                           14),
            ('技术方向',       '格式: G06F 40/00，多个用逗号分隔，用于统计分析',              'G06F 40/00,G06N 3/08',             20),
            ('下次年费日',     '格式: YYYY-MM-DD，下次需缴年费的截止日',                     '2025-01-15',                       16),
            ('费减主体',       '无费减 / 小型企业 / 个人等；仅作申请信息记录',              '无费减',                           14),
            ('费减已获批准',   '是/否。按备案资格和权利人数量直接计算应缴年费',             '否',                               14),
            ('涉外续展路线',   'auto / manual / unitary_patent / ep_validated / epo_application', 'manual', 20),
            ('备注',           '其他说明信息（可为空）',                                      '',                                 20),
        ]
        samples = {f[0]: f[2] for f in fields}

    elif dtype == 'trademarks':
        ws.title = '商标导入'
        fields = [
            ('商标名称',       '必填。商标的文字或图形名称',                                  '示例商标',                         20),
            ('申请号',         '格式: 48000001（8位纯数字）',                                 '48000001',                         16),
            ('注册号',         '已注册商标的注册号（未注册可为空）',                          '48000001',                         16),
            ('商标类型',       '枚举: 文字 / 图形 / 组合 / 立体 / 颜色组合 / 声音',          '文字',                             14),
            ('尼斯分类',       '第几类，如: 9 或 9,42（多类用逗号分隔）',                    '9',                                12),
            ('商品/服务项',    '具体商品或服务项目描述（可较长）',                            '计算机软件；人工智能软件',          30),
            ('国家/地区',      '枚举: 中国 / 美国 / 欧盟 / 日本 / 马德里 / 其他',           '中国',                             14),
            ('状态',           '枚举: 已受理/初审公告/已注册/复审中/异议中/撤三中/无效中',   '已受理',                           18),
            ('申请日',         '格式: YYYY-MM-DD',                                           '2024-01-15',                       14),
            ('初审公告日',     '格式: YYYY-MM-DD（初审公告时填写）',                         '',                                 14),
            ('初审公告期号',   '初审公告的期号（可为空）',                                  '',                                 14),
            ('注册公告期号',   '注册公告的期号（已注册时填写）',                            '',                                 14),
            ('注册公告日',     '格式: YYYY-MM-DD（已注册时填写）',                          '',                                 14),
            ('专用权日期',     '专用权起止期间，例如：2024-01-15至2034-01-14',               '',                                 28),
            ('续展截止日',     '格式: YYYY-MM-DD，商标有效期10年',                           '',                                 16),
            ('权利人/申请人',  '商标权利人全称',                                             'XX科技有限公司',                   22),
            ('代理机构',       '商标代理机构名称（可为空）',                                  'XX商标代理有限公司',               22),
            ('备注',           '其他说明信息（可为空）',                                      '',                                 20),
        ]
        samples = {f[0]: f[2] for f in fields}

    else:  # copyrights
        ws.title = '软著导入'
        fields = [
            ('软件名称',       '必填。软件全名称（含版本号）',                                '智能管理系统V1.0',                 26),
            ('版本号',         '软件版本，如: V1.0 / 2.3.1',                                 'V1.0',                             12),
            ('登记号',         '国家版权局登记号，如: 2024SR000001（未登记可为空）',         '2024SR000001',                     20),
            ('完成日期',       '格式: YYYY-MM-DD，软件开发完成日期',                         '2023-12-01',                       14),
            ('登记日期',       '格式: YYYY-MM-DD，版权局登记日期',                           '2024-03-01',                       14),
            ('著作权人',       '著作权所有人全称',                                           'XX科技有限公司',                   22),
            ('著作权类型',     '枚举: 软件著作权 / 美术作品 / 文字作品 / 其他',             '软件著作权',                       16),
            ('开发方式',       '独立开发 / 委托开发 / 合作开发等',                          '独立开发',                         16),
            ('权利取得方式',   '原始取得 / 继受取得',                                       '原始取得',                         16),
            ('著作权人主体',   '自然人 / 法人或其他组织',                                   '法人或其他组织',                   18),
            ('发表状态',       '未发表 / 已发表',                                           '未发表',                           14),
            ('首次发表日',     '已发表时填写 YYYY-MM-DD',                                   '',                                 14),
            ('首次发表地',     '已发表时填写国家或地区',                                   '',                                 16),
            ('登记状态',       '已登记 / 未登记 / 申请中',                                 '已登记',                           16),
            ('开发语言',       '主要编程语言，如: Python / Java / C++ / Go / Vue',           'Python',                           14),
            ('开发工具',       '主要开发工具或框架（可为空）',                               'PyCharm, Django',                  18),
            ('源代码行数',     '源程序行数（可为空）',                                        '50000',                            14),
            ('备注',           '其他说明信息（可为空）',                                      '',                                 20),
        ]
        samples = {f[0]: f[2] for f in fields}

    # ── 样式 ─────────────────────────────────────────────────────
    hf    = Font(bold=True, color='FFFFFF', size=11)
    hfill = PatternFill('solid', fgColor='1E40AF')
    cfill = PatternFill('solid', fgColor='DBEAFE')  # 说明行淡蓝
    sfill = PatternFill('solid', fgColor='DCFCE7')  # 示例行淡绿
    ha    = Alignment(horizontal='center', vertical='center', wrap_text=True)
    la    = Alignment(horizontal='left',   vertical='center', wrap_text=True)
    thin  = Border(left=Side(style='thin'),right=Side(style='thin'),
                   top=Side(style='thin'), bottom=Side(style='thin'))
    gray_font  = Font(color='374151', size=9, italic=True)
    green_font = Font(color='166534', size=10)

    # 第1行：字段名（标题）
    for ci, (h, _desc, _sample, _w) in enumerate(fields, 1):
        c = ws.cell(row=1, column=ci, value=h)
        c.font = hf; c.fill = hfill; c.alignment = ha; c.border = thin
        ws.column_dimensions[c.column_letter].width = _w

    # 第2行：说明（灰色斜体）
    for ci, (_h, desc, _s, _w) in enumerate(fields, 1):
        c = ws.cell(row=2, column=ci, value=desc)
        c.font = gray_font; c.fill = cfill; c.alignment = la; c.border = thin

    # 第3行：示例数据（绿色）
    for ci, (h, _d, sample, _w) in enumerate(fields, 1):
        c = ws.cell(row=3, column=ci, value=sample)
        c.font = green_font; c.fill = sfill; c.alignment = la; c.border = thin

    # 第4行起：空白数据行（可直接填写）
    for ri in range(4, 9):
        for ci in range(1, len(fields)+1):
            c = ws.cell(row=ri, column=ci, value='')
            c.border = thin
            if ri % 2 == 0:
                c.fill = PatternFill('solid', fgColor='F9FAFB')

    # 行高
    ws.row_dimensions[1].height = 22
    ws.row_dimensions[2].height = 36
    ws.row_dimensions[3].height = 18
    ws.freeze_panes = 'A4'

    # 加一个说明sheet
    ws2 = wb.create_sheet('填写说明')
    notes = {
        'patents': [
            ['字段名',     '必填', '格式/枚举值',                                    '说明'],
            ['发明名称',   '是',   '自由文本',                                        '与申请书一致'],
            ['申请号',     '否',   'CN202410000001.0',                               '国内专利格式，PCT另有格式'],
            ['专利类型',   '否',   '发明 / 实用新型 / 外观设计',                     '默认：发明'],
            ['国家/地区',  '否',   '中国 / 美国 / 欧洲 / 日本 / 韩国 / PCT / 其他', '默认：中国'],
            ['状态',       '否',   '已受理/已公开/实审中/已授权/复审中/已驳回/主动撤回/失效', '默认：已受理'],
            ['申请日',     '否',   'YYYY-MM-DD',                                     '用于自动计算当前年度'],
            ['发明人',     '否',   '张三,李四（逗号分隔）',                          '多人用英文逗号分隔'],
            ['权利人/申请人','否',  '单个全称；多个用顿号或逗号分隔',              '1个权利人减缴85%，2个及以上减缴70%'],
            ['技术方向',   '否',   'G06F 40/00',                                    '用于统计分析，格式如 G06F 40/00'],
        ],
        'trademarks': [
            ['字段名',     '必填', '格式/枚举值',                                    '说明'],
            ['商标名称',   '是',   '自由文本',                                        '商标名称或图形描述'],
            ['申请号',     '否',   '48000001（8位）',                                '中国商标申请号格式'],
            ['商标类型',   '否',   '文字/图形/组合/立体/颜色组合/声音',             '默认：文字'],
            ['尼斯分类',   '否',   '9 或 9,42',                                      '第几类，多类用英文逗号'],
            ['国家/地区',  '否',   '中国/美国/欧盟/日本/马德里/其他',               '默认：中国'],
            ['状态',       '否',   '已受理/初审公告/已注册/复审中/异议中/撤三中/无效中','默认：已受理'],
            ['申请日',     '否',   'YYYY-MM-DD',                                     ''],
            ['续展截止日', '否',   'YYYY-MM-DD',                                     '注册后10年，到期需续展'],
        ],
        'copyrights': [
            ['字段名',     '必填', '格式/枚举值',                          '说明'],
            ['软件名称',   '是',   '自由文本，通常含版本号',               '与登记证书名称一致'],
            ['版本号',     '否',   'V1.0',                                ''],
            ['登记号',     '否',   '2024SR000001',                        '国家版权局分配'],
            ['完成日期',   '否',   'YYYY-MM-DD',                          '开发完成日期'],
            ['登记日期',   '否',   'YYYY-MM-DD',                          '版权局登记日期'],
            ['著作权人',   '否',   '自由文本',                            '公司或个人全称'],
            ['著作权类型', '否',   '软件著作权/美术作品/文字作品/其他',   '默认：软件著作权'],
            ['开发语言',   '否',   'Python / Java / C++',                 ''],
        ],
    }.get(dtype, [])

    ws2.column_dimensions['A'].width = 16
    ws2.column_dimensions['B'].width = 8
    ws2.column_dimensions['C'].width = 42
    ws2.column_dimensions['D'].width = 28
    for ri, row in enumerate(notes, 1):
        for ci, val in enumerate(row, 1):
            c = ws2.cell(row=ri, column=ci, value=val)
            c.border = thin
            if ri == 1:
                c.font = Font(bold=True, color='FFFFFF')
                c.fill = PatternFill('solid', fgColor='1E40AF')
                c.alignment = ha
            else:
                c.alignment = la
                if ri % 2 == 0: c.fill = PatternFill('solid', fgColor='F9FAFB')

    buf = BytesIO(); wb.save(buf); buf.seek(0)
    fnames = {'patents':'专利导入模板.xlsx','trademarks':'商标导入模板.xlsx','copyrights':'软著导入模板.xlsx'}
    return send_file(buf, mimetype='application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
                     as_attachment=True, download_name=fnames.get(dtype,'导入模板.xlsx'))

# ══════════════ 缴费计划 API（全量） ══════════════
@app.route('/api/fees/schedule', methods=['GET','OPTIONS'])
def fees_schedule():
    """返回所有已授权专利的年费计划，不限截止日。支持提前缴费规划。"""
    if request.method == 'OPTIONS': return ok()
    today = date.today()
    items = []
    with get_db() as db:
        sync_deadline_tasks(db)
        thresholds = alert_thresholds_for_db(db)
        fee_tasks = {t['item_id']: t for t in db.execute("SELECT * FROM deadline_tasks WHERE kind='patent_fee' AND status NOT IN ('completed','superseded') ORDER BY id")}
        for p in db.execute("SELECT * FROM patents WHERE status IN ('已授权','授权')", []).fetchall():
            r = row_to_dict(p)
            cy = calc_patent_current_year(
                r.get('country'), r.get('app_date'), r.get('grant_date'),
                r.get('current_year'), r.get('next_fee_date'), r.get('type'),
                fee_route=r.get('fee_route'))
            if cy is None:
                continue
            task = fee_tasks.get(r['id'])
            deadline = task['deadline'] if task else None
            if not deadline:
                continue
            try:
                days = (date.fromisoformat(deadline[:10]) - today).days
            except:
                continue
            # 国外专利费用标准因国家而异，无法统一计算；仅计算国内专利
            if _is_china(r.get('country')):
                quote = calculate_cn_annual_fee(
                    r.get('type','发明'), cy,
                    r.get('fee_entity','无费减'),
                    r.get('app_date'), r.get('grant_date'), deadline, today,
                    owner=r.get('owner'),
                    fee_reduction_approved=r.get('fee_reduction_approved'),
                    fee_reduction_status=r.get('fee_reduction_status'),
                    fee_reduction_ratio=r.get('fee_reduction_ratio'))
            else:
                quote = {
                    'base': 0, 'annual_fee': 0, 'late_fee': 0,
                    'total_due': 0, 'late_rate': 0,
                    'reduction_eligible': False,
                    'owner_count': 0, 'owner_reduction_rate': 0,
                    'requires_grant_date': False, 'grace_expired': False,
                    'term_year': 0,
                }
            # 判断状态标签
            level = alert_level_for_days(days, thresholds)
            if level == 'upcoming':
                level = 'normal'
            items.append({
                'id': r['id'], 'title': r.get('title',''), 'app_no': r.get('app_no',''),
                'type': r.get('type',''), 'country': r.get('country',''), 'owner': r.get('owner',''),
                'current_year': cy, 'fee_entity': r.get('fee_entity',''),
                'deadline': deadline, 'days': days, 'level': level,
                'base_fee': quote['base'], 'reduced_fee': quote['total_due'],
                'annual_fee': quote['annual_fee'], 'late_fee': quote['late_fee'],
                'late_rate': quote['late_rate'],
                'reduction_eligible': quote['reduction_eligible'],
                'owner_count': quote['owner_count'],
                'owner_reduction_rate': quote['owner_reduction_rate'],
                'requires_grant_date': quote['requires_grant_date'],
                'grace_expired': quote['grace_expired'],
                'term_year': quote['term_year'],
                'amount_estimate_only': False,
                'deadline_verified': bool(r.get('fee_deadline_verified')),
                'requires_verification': not bool(r.get('fee_deadline_verified')),
                'fee_rule': (
                    {'country': '中国', 'rule_version': RULESET_VERSION,
                     'source_url': CNIPA_PATENT_LAW_URL,
                     'note': '申请日周年规则；金额按费减标准计算'}
                    if _is_china(r.get('country')) else
                    foreign_patent_rule_summary(
                        r.get('country'), r.get('type'), r.get('fee_route'))
                ),
            })
    items.sort(key=lambda x: x['days'])
    # 统计
    total = len(items)
    overdue_count = sum(1 for x in items if x['level'] == 'overdue')
    urgent_count = sum(1 for x in items if x['level'] in ('overdue','urgent'))
    total_reduced = sum(x['reduced_fee'] for x in items)
    return ok({'items': items, 'total': total, 'overdue': overdue_count,
               'urgent': urgent_count, 'total_reduced': total_reduced,
               'thresholds': thresholds})

# ══════════════ 到期预警 API ══════════════
@app.route('/api/alerts/upcoming', methods=['GET','OPTIONS'])
def alerts_upcoming():
    """返回结构化的到期预警数据"""
    if request.method == 'OPTIONS': return ok()
    return ok(collect_alerts(request.args.get('days'), request.args.get('tm_days')))


def collect_alerts(days_arg=None, tm_days_arg=None, db=None):
    with (nullcontext(db) if db is not None else get_db()) as settings_db:
        settings_map = {
            row['key']: row['value']
            for row in settings_db.execute(
                "SELECT key,value FROM settings WHERE key IN "
                "('alert_default_window','alert_urgent_days','alert_soon_days',"
                "'alert_trademark_renewal')"
            ).fetchall()
        }
    def _safe_setting_int(key, fallback, minimum=1, maximum=3650):
        try:
            return max(minimum, min(maximum, int(settings_map.get(key, fallback))))
        except (TypeError, ValueError):
            return fallback
    days = _safe_setting_int('alert_default_window', 90)
    if days_arg is not None:
        try:
            days = max(1, min(3650, int(days_arg)))
        except (TypeError, ValueError):
            pass
    thresholds = _alert_thresholds_from_settings(settings_map)
    urgent_days = thresholds['urgent']
    soon_days = thresholds['soon']
    # 商标续展采用独立的提前期配置（默认 365/180/30 天）。
    # 普通预警窗口不能把续展提醒压缩掉，否则默认 90 天时会完全看不到一年内
    # 即将到期的商标。用户显式扩大普通窗口时仍然自然兼容。
    renewal_windows = []
    for token in str(settings_map.get('alert_trademark_renewal', '365,180,30')).split(','):
        try:
            value = int(token.strip())
            if value > 0:
                renewal_windows.append(min(value, 3650))
        except (TypeError, ValueError):
            pass
    renewal_days = max(max(renewal_windows or [365]), days)
    # 前端在“默认查看范围”下会显式传入商标续展窗口；用户切换期限按钮后，
    # 则按所选期限筛选，避免按钮显示 30 天却仍展示一年后的续展事项。
    if tm_days_arg is not None:
        try:
            renewal_days = max(1, min(3650, int(tm_days_arg)))
        except (TypeError, ValueError):
            pass
    today = date.today().isoformat()
    cutoff = (date.today() + __import__('datetime').timedelta(days=days)).isoformat()
    renewal_cutoff = (date.today() + __import__('datetime').timedelta(days=renewal_days)).isoformat()
    result = {'overdue': [], 'urgent': [], 'soon': [], 'upcoming': []}

    def classify(deadline, item, rule_info=None):
        if not deadline: return
        diff = (date.fromisoformat(deadline) - date.today()).days
        payload = {**item, 'days': diff, 'deadline': deadline}
        if rule_info:
            payload['rule'] = rule_info
            payload['requires_verification'] = not rule_info.get('verified', False)
        if diff < 0:    result['overdue'].append(payload)
        elif diff <= urgent_days: result['urgent'].append(payload)
        elif diff <= soon_days: result['soon'].append(payload)
        else:            result['upcoming'].append(payload)

    # 统一来源：预警、日历和首页都消费 deadline_tasks，不再各自重算案件期限。
    with (nullcontext(db) if db is not None else get_db()) as task_db:
        task_rows = deadline_tasks_for_response(task_db, max(days, renewal_days))
        for task in task_rows:
            deadline = task['deadline'][:10]
            if task['kind'] == 'tm_renewal' and deadline > renewal_cutoff:
                continue
            if task['kind'] != 'tm_renewal' and deadline > cutoff:
                continue
            payload = task.get('payload') or {}
            rule = payload.get('rule') or {}
            classify(deadline, {
                'id': task['item_id'], 'task_id': task['id'], 'kind': task['kind'],
                'title': task['title'], 'app_no': payload.get('app_no'),
                'owner': payload.get('owner'), 'classes': payload.get('classes'),
                'type': payload.get('type'), 'country': payload.get('country'),
                'current_year': payload.get('current_year'), 'fee_entity': payload.get('fee_entity'),
                'task_status': task['status'],
            }, rule if rule else None)
    for lst in result.values(): lst.sort(key=lambda x: x['days'])
    result['total'] = sum(len(v) for v in result.values())
    result['thresholds'] = {'urgent': urgent_days, 'soon': soon_days}
    return result

    with (nullcontext(db) if db is not None else get_db()) as db:
        # 专利年费
        for p in db.execute("SELECT * FROM patents WHERE status IN ('已授权','授权')", []).fetchall():
            r = row_to_dict(p)
            cy = calc_patent_current_year(
                r.get('country'), r.get('app_date'), r.get('grant_date'),
                r.get('current_year'), r.get('next_fee_date'), r.get('type'),
                fee_route=r.get('fee_route'))
            deadline = calc_patent_next_fee_date(
                r.get('country'), r.get('app_date'), r.get('grant_date'),
                cy if cy is not None else r.get('current_year'),
                r.get('next_fee_date'), r.get('type'), r.get('fee_route'))
            if deadline and deadline <= cutoff:
                fee_rule = {
                    'rule_version': RULESET_VERSION,
                    'source_url': CNIPA_PATENT_LAW_URL if _is_china(r.get('country')) else '',
                    'verified': bool(r.get('fee_deadline_verified')),
                    'verification_note': '以官方缴费通知或官方账户显示的截止日为准',
                }
                if not _is_china(r.get('country')):
                    fee_rule.update(foreign_patent_rule_summary(
                        r.get('country'), r.get('type'), r.get('fee_route')))
                classify(deadline, {'id':r['id'],'kind':'patent_fee','title':r['title'],'app_no':r['app_no'],'owner':r['owner'],'type':r['type'],'country':r['country'],'current_year':cy,'fee_entity':r['fee_entity']}, fee_rule)
        # 商标续展
        for t in db.execute("SELECT * FROM trademarks WHERE status IN ('已注册','注册') AND renewal_date IS NOT NULL AND renewal_date<=?", (renewal_cutoff,)).fetchall():
            r = row_to_dict(t)
            classify(r['renewal_date'], {'id':r['id'],'kind':'tm_renewal','title':r['name'],'app_no':r['app_no'],'owner':r['owner'],'classes':r['classes'],'country':r['country']})
        # 商标驳回：未选择复审时提示简单理由期限；选择“复审中”后同时提示
        # 简单理由（15天）和完整理由（自驳回日起3个月）。起算日必须是人工填写的收文日。
        for t in db.execute("SELECT * FROM trademarks WHERE status='已驳回' AND rejection_date IS NOT NULL").fetchall():
            r = row_to_dict(t)
            try:
                info = calculate_legal_deadline('tm_rejection_review', r['rejection_date'])
                deadline = info['deadline']
                if deadline <= cutoff:
                    classify(deadline, {'id':r['id'],'kind':'tm_rejection_review','title':r['name'],'app_no':r['app_no'],'owner':r['owner'],'classes':r['classes'],'country':r['country']}, info)
            except: pass
        for t in db.execute("SELECT * FROM trademarks WHERE status='复审中' AND rejection_date IS NOT NULL AND COALESCE(review_complete_submitted_date,'')='' AND COALESCE(review_simple_submitted_date,'')=''").fetchall():
            r = row_to_dict(t)
            try:
                info = calculate_legal_deadline('tm_rejection_simple', r['rejection_date'])
                if info['deadline'] <= cutoff:
                    classify(info['deadline'], {'id':r['id'],'kind':'tm_rejection_simple','title':r['name'],'app_no':r['app_no'],'owner':r['owner'],'classes':r['classes'],'country':r['country']}, info)
            except: pass
        for t in db.execute("SELECT * FROM trademarks WHERE status='复审中' AND rejection_date IS NOT NULL AND review_simple_submitted_date IS NOT NULL AND COALESCE(review_complete_submitted_date,'')=''").fetchall():
            r = row_to_dict(t)
            try:
                info = calculate_legal_deadline('tm_rejection_complete', r['rejection_date'])
                if info['deadline'] <= cutoff:
                    classify(info['deadline'], {'id':r['id'],'kind':'tm_rejection_complete','title':r['name'],'app_no':r['app_no'],'owner':r['owner'],'classes':r['classes'],'country':r['country']}, info)
            except: pass
        # ─── 专利确权期限 ───
        # 国内专利答复审查意见：首次4个月，再次2个月。
        for p in db.execute("SELECT * FROM patents WHERE country IN ('中国','中华人民共和国','CN','China','CHINA','PRC','P.R.C.') AND status IN ('实审中','审查中') AND oa_date IS NOT NULL").fetchall():
            r = row_to_dict(p)
            try:
                info = calculate_legal_deadline('patent_oa_response', r['oa_date'], oa_round=r.get('oa_round'))
                deadline = info['deadline']
                if deadline <= cutoff:
                    classify(deadline, {'id':r['id'],'kind':'patent_oa_response','title':r['title'],'app_no':r['app_no'],'owner':r['owner'],'type':r['type'],'country':r['country']}, info)
            except: pass
        # 国内专利驳回复审：自实际收到日起3个月。
        for p in db.execute("SELECT * FROM patents WHERE country IN ('中国','中华人民共和国','CN','China','CHINA','PRC','P.R.C.') AND status='已驳回' AND rejection_date IS NOT NULL").fetchall():
            r = row_to_dict(p)
            try:
                info = calculate_legal_deadline('patent_rejection_review', r['rejection_date'])
                deadline = info['deadline']
                if deadline <= cutoff:
                    classify(deadline, {'id':r['id'],'kind':'patent_rejection_review','title':r['title'],'app_no':r['app_no'],'owner':r['owner'],'type':r['type'],'country':r['country']}, info)
            except: pass
        # 授权登记缴费（2个月）
        for p in db.execute("SELECT * FROM patents WHERE country IN ('中国','中华人民共和国','CN','China','CHINA','PRC','P.R.C.') AND status IN ('待登记','已授权','授权') AND grant_notice_date IS NOT NULL AND grant_date IS NULL").fetchall():
            r = row_to_dict(p)
            try:
                info = calculate_legal_deadline('patent_grant_pay', r['grant_notice_date'])
                deadline = info['deadline']
                if deadline <= cutoff:
                    classify(deadline, {'id':r['id'],'kind':'patent_grant_pay','title':r['title'],'app_no':r['app_no'],'owner':r['owner'],'type':r['type'],'country':r['country']}, info)
            except: pass
        # 实质审查请求（3年）
        for p in db.execute("SELECT * FROM patents WHERE country IN ('中国','中华人民共和国','CN','China','CHINA','PRC','P.R.C.') AND type='发明' AND status IN ('已受理','初审中','已公开','公开') AND app_date IS NOT NULL").fetchall():
            r = row_to_dict(p)
            try:
                info = calculate_legal_deadline('patent_exam_request', r['app_date'])
                deadline = info['deadline']
                if deadline <= cutoff:
                    classify(deadline, {'id':r['id'],'kind':'patent_exam_request','title':r['title'],'app_no':r['app_no'],'owner':r['owner'],'type':r['type'],'country':r['country']}, info)
            except: pass
        # 中国专利期限按申请日和权利类型计算。
        for p in db.execute("SELECT * FROM patents WHERE country IN ('中国','中华人民共和国','CN','China','CHINA','PRC','P.R.C.') AND status IN ('已授权','授权') AND app_date IS NOT NULL", []).fetchall():
            r = row_to_dict(p)
            try:
                info = calculate_legal_deadline('patent_expire', r['app_date'], patent_type=r['type'])
                expire = info['deadline']
                if expire <= cutoff:
                    classify(expire, {'id':r['id'],'kind':'patent_expire','title':r['title'],'app_no':r['app_no'],'owner':r['owner'],'type':r['type'],'country':r['country']}, info)
            except: pass
        # ─── 商标确权期限 ───
        # 初审公告异议期（3个月）
        for t in db.execute("SELECT * FROM trademarks WHERE status='初审公告' AND pub_date IS NOT NULL").fetchall():
            r = row_to_dict(t)
            try:
                info = calculate_legal_deadline('tm_opposition_period', r['pub_date'])
                deadline = info['deadline']
                if deadline <= cutoff:
                    classify(deadline, {'id':r['id'],'kind':'tm_opposition_period','title':r['name'],'app_no':r['app_no'],'owner':r['owner'],'classes':r['classes'],'country':r['country']}, info)
            except: pass
        # 异议答辩（30天）
        for t in db.execute("SELECT * FROM trademarks WHERE status='异议中' AND opposition_notice_date IS NOT NULL").fetchall():
            r = row_to_dict(t)
            try:
                info = calculate_legal_deadline('tm_opposition_response', r['opposition_notice_date'])
                deadline = info['deadline']
                if deadline <= cutoff:
                    classify(deadline, {'id':r['id'],'kind':'tm_opposition_response','title':r['name'],'app_no':r['app_no'],'owner':r['owner'],'classes':r['classes'],'country':r['country']}, info)
            except: pass

    for lst in result.values(): lst.sort(key=lambda x: x['days'])
    result['total'] = sum(len(v) for v in result.values())
    result['thresholds'] = {'urgent': urgent_days, 'soon': soon_days}
    return result

# ══════════════ SETTINGS / ALERTS / JSON EXPORT ══════════════
@app.route('/api/settings', methods=['GET','PUT','OPTIONS'])
def settings_api():
    if request.method == 'OPTIONS': return ok()
    if request.method == 'GET':
        with get_db() as db: rows=db.execute("SELECT key,value FROM settings").fetchall()
        return ok({r['key']:r['value'] for r in rows})
    d=_json_payload()
    allowed_keys = {
        'company', 'alert_patent_fee', 'alert_trademark_renewal', 'alert_pct_phase',
        'alert_tm_rejection_review', 'default_fee_entity', 'default_country',
        'alert_default_window', 'alert_urgent_days', 'alert_soon_days',
        'watch_folder_path', 'attachment_filters',
        'auto_backup_enabled', 'auto_backup_retention',
    }
    unknown = sorted(set(d) - allowed_keys)
    if unknown:
        return err('包含不支持的设置项：' + '、'.join(unknown), 400)
    if 'watch_folder_path' in d:
        raw_path = str(d.get('watch_folder_path') or '').strip()
        if raw_path:
            candidate = Path(raw_path).expanduser()
            if not candidate.is_absolute():
                return err('待关联文件夹必须使用完整路径', 400)
            try:
                candidate = candidate.resolve()
            except OSError:
                return err('无法读取待关联文件夹路径', 400)
            if not candidate.exists() or not candidate.is_dir():
                return err('待关联文件夹不存在，请重新选择', 400)
            if not os.access(candidate, os.R_OK | os.W_OK):
                return err('待关联文件夹需要读写权限', 400)
            d['watch_folder_path'] = str(candidate)
    if 'auto_backup_enabled' in d:
        d['auto_backup_enabled'] = '1' if _as_bool(d.get('auto_backup_enabled')) else '0'
    if 'auto_backup_retention' in d:
        try:
            retention = int(d.get('auto_backup_retention'))
        except (TypeError, ValueError):
            return err('自动备份保留份数必须是整数', 400)
        if not 1 <= retention <= 30:
            return err('自动备份保留份数应在 1–30 之间', 400)
        d['auto_backup_retention'] = str(retention)
    with get_db() as db:
        for k,v in d.items(): db.execute("INSERT OR REPLACE INTO settings(key,value) VALUES(?,?)",(k,str(v)))
    return ok()

@app.route('/api/data-health/marks', methods=['GET','PUT','DELETE','OPTIONS'])
def data_health_marks_api():
    """Persist data-health decisions as business data, never as browser state."""
    if request.method == 'OPTIONS':
        return ok()
    if request.method == 'GET':
        with get_db() as db:
            rows = db.execute("""
                SELECT issue_id,status,title,item_type,item_id,field,fingerprint,marked_at
                FROM data_health_marks
                ORDER BY updated_at DESC
            """).fetchall()
        return ok({
            r['issue_id']: {
                'status': r['status'],
                'at': r['marked_at'],
                'title': r['title'],
                'itemType': r['item_type'],
                'itemId': r['item_id'],
                'field': r['field'],
                'fingerprint': r['fingerprint'],
            }
            for r in rows
        })

    payload = request.get_json(silent=True) or {}
    if request.method == 'DELETE':
        issue_id = str(payload.get('issue_id') or '').strip()
        with get_db() as db:
            if issue_id:
                db.execute("DELETE FROM data_health_marks WHERE issue_id=?", (issue_id,))
            elif payload.get('all') is True:
                db.execute("DELETE FROM data_health_marks")
            else:
                return err('缺少要恢复的数据体检项目', 400)
        checkpoint_database()
        return ok({'issue_id': issue_id, 'cleared': not bool(issue_id)})

    issue_id = str(payload.get('issue_id') or '').strip()
    status = str(payload.get('status') or '').strip()
    if not issue_id or len(issue_id) > 1000:
        return err('数据体检项目标识无效', 400)
    if status not in ('confirmed', 'ignored'):
        return err('处理状态无效', 400)
    marked_at = str(payload.get('at') or datetime.now().astimezone().isoformat())
    with get_db() as db:
        db.execute("""
            INSERT INTO data_health_marks
                (issue_id,status,title,item_type,item_id,field,fingerprint,marked_at,updated_at)
            VALUES (?,?,?,?,?,?,?,?,datetime('now','localtime'))
            ON CONFLICT(issue_id) DO UPDATE SET
                status=excluded.status,
                title=excluded.title,
                item_type=excluded.item_type,
                item_id=excluded.item_id,
                field=excluded.field,
                fingerprint=excluded.fingerprint,
                marked_at=excluded.marked_at,
                updated_at=datetime('now','localtime')
        """, (
            issue_id,
            status,
            str(payload.get('title') or '')[:500],
            str(payload.get('item_type') or '')[:50],
            str(payload.get('item_id') or '')[:200],
            str(payload.get('field') or '')[:100],
            str(payload.get('fingerprint') or '')[:2000],
            marked_at,
        ))
    # Return success only after the commit has reached the main database file.
    checkpoint_database()
    return ok({
        'issue_id': issue_id,
        'status': status,
        'at': marked_at,
        'title': str(payload.get('title') or '')[:500],
    })

@app.route('/api/service/checkpoint', methods=['POST','OPTIONS'])
def service_checkpoint():
    if request.method == 'OPTIONS': return ok()
    if request.remote_addr not in ('127.0.0.1', '::1'):
        return err('仅允许本地访问', 403)
    checkpoint_database()
    return ok({'message': '数据已安全写入磁盘'})

@app.route('/api/alerts/workflow', methods=['GET', 'POST'])
def alert_workflow():
    if request.method == 'GET':
        with get_db() as db:
            rows = db.execute('SELECT * FROM alert_workflow ORDER BY id').fetchall()
        return ok([dict(row) for row in rows])
    payload = _json_payload()
    key = str(payload.get('alert_key') or '').strip()
    status = str(payload.get('status') or '')
    note = str(payload.get('note') or '').strip()
    if not re.fullmatch(r'[a-z_]+-\d+:\d{4}-\d{2}-\d{2}', key):
        return err('预警标识无效', 400)
    if status not in ('pending', 'processing', 'completed', 'ignored'):
        return err('处理状态无效', 400)
    if not note or len(note) > 2000:
        return err('请填写处理说明（最多 2000 字）', 400)
    with get_db() as db:
        db.execute('INSERT INTO alert_workflow(alert_key,status,note) VALUES(?,?,?)',
                   (key, status, note))
        row = db.execute('SELECT * FROM alert_workflow WHERE id=last_insert_rowid()').fetchone()
    return ok(dict(row))


@app.route('/api/alerts/dismissed', methods=['GET','POST','DELETE','OPTIONS'])
def alerts_dismissed():
    if request.method == 'OPTIONS': return ok()
    if request.method == 'GET':
        with get_db() as db: rows=db.execute("SELECT alert_id FROM alerts_dismissed").fetchall()
        return ok([r['alert_id'] for r in rows])
    if request.method == 'POST':
        alert_id = str(_json_payload().get('alert_id') or '').strip()
        if not alert_id:
            return err('缺少预警标识', 400)
        with get_db() as db: db.execute("INSERT OR IGNORE INTO alerts_dismissed(alert_id) VALUES(?)",(alert_id,))
        return ok()
    payload = _json_payload()
    alert_id = str(payload.get('alert_id') or '').strip()
    with get_db() as db:
        if alert_id:
            db.execute("DELETE FROM alerts_dismissed WHERE alert_id=?", (alert_id,))
        else:
            db.execute("DELETE FROM alerts_dismissed")
    return ok()


def _backup_watch_directory():
    watch_dir = _watch_dir()
    if watch_dir == BASE_DIR:
        raise ValueError('待关联目录不能设为整个数据目录，请先选择独立文件夹')
    return watch_dir


def _auto_backup_worker():
    """Create one local attachment-inclusive backup per day while the service runs."""
    backup_dir = BASE_DIR / 'Backups' / 'automatic'
    while True:
        try:
            with get_db() as db:
                settings = {row['key']: row['value'] for row in db.execute(
                    "SELECT key,value FROM settings WHERE key IN ('auto_backup_enabled','auto_backup_retention')"
                ).fetchall()}
            enabled = _as_bool(settings.get('auto_backup_enabled', '1'))
            retention = max(1, min(30, int(settings.get('auto_backup_retention', '7') or 7)))
            today = datetime.now().strftime('%Y%m%d')
            existing = list(backup_dir.glob(f'ipkeeper-auto-{today}-*.ipkeeperbackup')) if backup_dir.exists() else []
            if enabled and DB_PATH.exists() and not existing and BACKUP_OPERATION_LOCK.acquire(blocking=False):
                try:
                    backup_dir.mkdir(parents=True, exist_ok=True)
                    destination = backup_dir / f'ipkeeper-auto-{datetime.now():%Y%m%d-%H%M%S}.ipkeeperbackup'
                    _set_backup_status(True, 'auto_backup', 'creating')
                    checkpoint_database()
                    create_backup_archive(
                        DB_PATH, UPLOAD_DIR, None, destination,
                        include_attachments=True, include_watch=False,
                    )
                    backups = sorted(backup_dir.glob('ipkeeper-auto-*.ipkeeperbackup'), key=lambda p: p.stat().st_mtime, reverse=True)
                    for expired in backups[retention:]:
                        expired.unlink(missing_ok=True)
                    with get_db() as db:
                        db.execute("INSERT OR REPLACE INTO settings(key,value) VALUES('auto_backup_last',?)", (now_str(),))
                    _finish_backup_status('auto_backup')
                except Exception as exc:
                    try:
                        with get_db() as db:
                            db.execute("INSERT OR REPLACE INTO settings(key,value) VALUES('auto_backup_error',?)", (str(exc)[:500],))
                    except Exception:
                        pass
                    _finish_backup_status('auto_backup', str(exc))
                finally:
                    BACKUP_OPERATION_LOCK.release()
        except Exception:
            pass
        # A six-hour cadence ensures a daily backup after a long-running service,
        # while avoiding repeated work on every request.
        threading.Event().wait(6 * 60 * 60)


def _backup_summary_data():
    watch_dir = _watch_dir()
    attachments = directory_summary(UPLOAD_DIR, exclude_top_level={'tmp'})
    watch = directory_summary(watch_dir)
    try:
        watch_is_external = BASE_DIR not in watch_dir.parents and watch_dir != BASE_DIR
    except (OSError, ValueError):
        watch_is_external = True
    auto_dir = BASE_DIR / 'Backups' / 'automatic'
    auto_backups = sorted(auto_dir.glob('ipkeeper-auto-*.ipkeeperbackup'), key=lambda p: p.stat().st_mtime, reverse=True) if auto_dir.exists() else []
    with get_db() as db:
        auto_settings = {row['key']: row['value'] for row in db.execute(
            "SELECT key,value FROM settings WHERE key IN ('auto_backup_enabled','auto_backup_retention','auto_backup_last','auto_backup_error')"
        ).fetchall()}
    try:
        auto_retention = max(1, min(30, int(auto_settings.get('auto_backup_retention', '7') or 7)))
    except (TypeError, ValueError):
        auto_retention = 7
    return {
        'database_bytes': DB_PATH.stat().st_size if DB_PATH.exists() else 0,
        'attachments': attachments,
        'watch_folder': {
            **watch,
            'path': str(watch_dir),
            'external': watch_is_external,
        },
        'automatic_backup': {
            'enabled': _as_bool(auto_settings.get('auto_backup_enabled', '1')),
            'retention': auto_retention,
            'last': auto_settings.get('auto_backup_last', ''),
            'error': auto_settings.get('auto_backup_error', ''),
            'count': len(auto_backups),
            'latest': auto_backups[0].name if auto_backups else '',
        },
    }

def _set_backup_status(active, kind='', phase='idle'):
    with BACKUP_STATUS_LOCK:
        BACKUP_STATUS.update({
            'active': bool(active),
            'kind': str(kind or ''),
            'phase': str(phase or 'idle'),
        })
        if active:
            BACKUP_STATUS['error'] = ''


def _finish_backup_status(kind, error=''):
    with BACKUP_STATUS_LOCK:
        BACKUP_STATUS.update({
            'active': False,
            'kind': str(kind or ''),
            'phase': 'failed' if error else 'complete',
            'sequence': int(BACKUP_STATUS.get('sequence') or 0) + 1,
            'error': str(error or ''),
        })


def _available_temp_bytes():
    return shutil.disk_usage(tempfile.gettempdir()).free


def _ensure_backup_space(required_bytes, operation):
    reserve = 256 * 1024 * 1024
    required = max(int(required_bytes) + reserve, 512 * 1024 * 1024)
    available = _available_temp_bytes()
    if available < required:
        need_gb = required / 1024 / 1024 / 1024
        have_gb = available / 1024 / 1024 / 1024
        raise RuntimeError(
            f'{operation}需要约 {need_gb:.1f} GB 可用空间，当前仅 {have_gb:.1f} GB'
        )


def _remove_old_safety_backups(keep=3):
    backup_dir = BASE_DIR / 'Backups'
    backups = sorted(
        backup_dir.glob('pre-restore-*.ipkeeperbackup'),
        key=lambda path: path.stat().st_mtime,
        reverse=True,
    )
    for expired in backups[keep:]:
        expired.unlink(missing_ok=True)


def _create_pre_restore_backup():
    backup_dir = BASE_DIR / 'Backups'
    backup_dir.mkdir(parents=True, exist_ok=True)
    destination = backup_dir / (
        f"pre-restore-{datetime.now():%Y%m%d-%H%M%S-%f}.ipkeeperbackup"
    )
    create_backup_archive(
        DB_PATH,
        UPLOAD_DIR,
        _backup_watch_directory(),
        destination,
        include_attachments=True,
        include_watch=True,
    )
    _remove_old_safety_backups()
    return destination


def _remove_database_sidecars():
    for suffix in ('-wal', '-shm'):
        Path(str(DB_PATH) + suffix).unlink(missing_ok=True)


def _missing_restored_attachment_count():
    filenames = set()
    with get_db() as db:
        filenames.update(
            row['filename']
            for row in db.execute(
                "SELECT filename FROM documents WHERE COALESCE(filename,'')<>''"
            ).fetchall()
        )
        filenames.update(
            row['logo_filename']
            for row in db.execute(
                "SELECT logo_filename FROM trademarks WHERE COALESCE(logo_filename,'')<>''"
            ).fetchall()
        )
        filenames.update(
            row['receipt_filename']
            for row in db.execute(
                "SELECT receipt_filename FROM fee_payments WHERE COALESCE(receipt_filename,'')<>''"
            ).fetchall()
        )
    return sum(not (UPLOAD_DIR / filename).is_file() for filename in filenames)


def _atomic_restore_package(extracted):
    manifest = extracted['manifest']
    includes = manifest.get('includes') or {}
    restore_attachments = bool(includes.get('attachments'))
    restore_watch = bool(includes.get('watch_folder'))
    token = uuid.uuid4().hex

    incoming_database = BASE_DIR / f'.ipkeeper.db.restoring-{token}'
    previous_database = BASE_DIR / f'.ipkeeper.db.before-restore-{token}'
    incoming_uploads = BASE_DIR / f'.uploads-restoring-{token}'
    previous_uploads = BASE_DIR / f'.uploads-before-restore-{token}'
    incoming_watch = BASE_DIR / f'.watch-restoring-{token}'
    previous_watch = BASE_DIR / f'.watch-before-restore-{token}'

    shutil.copy2(extracted['database'], incoming_database)
    if restore_attachments:
        shutil.copytree(extracted['attachments'], incoming_uploads)
    if restore_watch:
        shutil.copytree(extracted['watch'], incoming_watch)

    database_swapped = False
    uploads_swapped = False
    uploads_had_previous = False
    watch_swapped = False
    watch_had_previous = False
    try:
        checkpoint_database()
        _remove_database_sidecars()
        os.replace(DB_PATH, previous_database)
        database_swapped = True
        os.replace(incoming_database, DB_PATH)

        if restore_attachments:
            if UPLOAD_DIR.exists():
                os.replace(UPLOAD_DIR, previous_uploads)
                uploads_had_previous = True
            os.replace(incoming_uploads, UPLOAD_DIR)
            uploads_swapped = True

        if restore_watch:
            if DEFAULT_WATCH_DIR.exists():
                os.replace(DEFAULT_WATCH_DIR, previous_watch)
                watch_had_previous = True
            os.replace(incoming_watch, DEFAULT_WATCH_DIR)
            watch_swapped = True

        init_db()
        if restore_watch:
            with get_db() as db:
                db.execute(
                    "INSERT INTO settings(key,value) VALUES('watch_folder_path','') "
                    "ON CONFLICT(key) DO UPDATE SET value=''"
                )
        checkpoint_database()
        if not backup_database_is_valid(DB_PATH):
            raise RuntimeError('恢复后的数据库完整性检查失败')

        missing_attachments = _missing_restored_attachment_count()
        if restore_attachments and missing_attachments:
            raise RuntimeError(
                f'恢复包缺少 {missing_attachments} 个数据库引用的附件'
            )
    except Exception:
        _remove_database_sidecars()
        if database_swapped and previous_database.exists():
            DB_PATH.unlink(missing_ok=True)
            os.replace(previous_database, DB_PATH)
        if restore_attachments:
            if uploads_swapped:
                shutil.rmtree(UPLOAD_DIR, ignore_errors=True)
            if uploads_had_previous and previous_uploads.exists():
                os.replace(previous_uploads, UPLOAD_DIR)
            elif not UPLOAD_DIR.exists():
                UPLOAD_DIR.mkdir(parents=True, exist_ok=True)
        if restore_watch:
            if watch_swapped:
                shutil.rmtree(DEFAULT_WATCH_DIR, ignore_errors=True)
            if watch_had_previous and previous_watch.exists():
                os.replace(previous_watch, DEFAULT_WATCH_DIR)
            elif not DEFAULT_WATCH_DIR.exists():
                DEFAULT_WATCH_DIR.mkdir(parents=True, exist_ok=True)
        init_db()
        raise
    finally:
        incoming_database.unlink(missing_ok=True)
        shutil.rmtree(incoming_uploads, ignore_errors=True)
        shutil.rmtree(incoming_watch, ignore_errors=True)

    previous_database.unlink(missing_ok=True)
    shutil.rmtree(previous_uploads, ignore_errors=True)
    shutil.rmtree(previous_watch, ignore_errors=True)
    return {
        'database_counts': manifest.get('database_counts') or {},
        'attachments_restored': (
            manifest.get('summary', {}).get('attachment_count', 0)
            if restore_attachments else 0
        ),
        'watch_files_restored': (
            manifest.get('summary', {}).get('watch_count', 0)
            if restore_watch else 0
        ),
        'included_attachments': restore_attachments,
        'included_watch_folder': restore_watch,
        'missing_attachments': missing_attachments,
    }


@app.route('/api/backup/summary', methods=['GET','OPTIONS'])
def backup_summary():
    if request.method == 'OPTIONS':
        return ok()
    return ok(_backup_summary_data())

@app.route('/api/backup/status', methods=['GET','OPTIONS'])
def backup_status():
    if request.method == 'OPTIONS':
        return ok()
    with BACKUP_STATUS_LOCK:
        return ok(dict(BACKUP_STATUS))


@app.route('/api/backup/full', methods=['GET','POST','OPTIONS'])
def backup_full():
    if request.method == 'OPTIONS':
        return ok()
    if not BACKUP_OPERATION_LOCK.acquire(blocking=False):
        return err('已有备份或恢复任务正在进行', 409)
    temporary_dir = Path(tempfile.mkdtemp(prefix='ipkeeper-backup-'))
    archive_path = temporary_dir / (
        f"知产管家完整备份-{datetime.now():%Y%m%d-%H%M%S}.ipkeeperbackup"
    )
    operation_error = ''
    try:
        summary = _backup_summary_data()
        expected = (
            summary['database_bytes']
            + summary['attachments']['bytes']
            + summary['watch_folder']['bytes']
        )
        _ensure_backup_space(expected, '完整备份')
        _set_backup_status(True, 'backup', 'creating')
        watch_dir = _backup_watch_directory()
        create_backup_archive(
            DB_PATH,
            UPLOAD_DIR,
            watch_dir,
            archive_path,
            include_attachments=True,
            include_watch=True,
        )
        _set_backup_status(True, 'backup', 'ready')
        response = send_file(
            archive_path,
            mimetype='application/octet-stream',
            as_attachment=True,
            download_name=archive_path.name,
        )
        response.call_on_close(
            lambda: shutil.rmtree(temporary_dir, ignore_errors=True)
        )
        return response
    except Exception as exc:
        operation_error = f'完整备份失败：{exc}'
        shutil.rmtree(temporary_dir, ignore_errors=True)
        return err(operation_error, 500)
    finally:
        _finish_backup_status('backup', operation_error)
        BACKUP_OPERATION_LOCK.release()


@app.route('/api/backup/restore', methods=['POST','OPTIONS'])
def backup_restore():
    global MAINTENANCE_MODE
    if request.method == 'OPTIONS':
        return ok()
    if 'file' not in request.files:
        return err('未选择完整备份包')
    if not BACKUP_OPERATION_LOCK.acquire(blocking=False):
        return err('已有备份或恢复任务正在进行', 409)

    temporary_dir = Path(tempfile.mkdtemp(prefix='ipkeeper-restore-'))
    archive_path = temporary_dir / 'uploaded.ipkeeperbackup'
    staging_dir = temporary_dir / 'staging'
    operation_error = ''
    try:
        _set_backup_status(True, 'restore', 'uploading')
        request.files['file'].save(str(archive_path))
        _ensure_backup_space(archive_path.stat().st_size * 3, '完整恢复')
        _set_backup_status(True, 'restore', 'validating')
        extracted = extract_and_validate_backup(archive_path, staging_dir)
        MAINTENANCE_MODE = True
        _set_backup_status(True, 'restore', 'restoring')
        safety_backup = _create_pre_restore_backup()
        result = _atomic_restore_package(extracted)
        result['safety_backup'] = safety_backup.name
        return ok(result)
    except BackupValidationError as exc:
        operation_error = f'备份包校验失败：{exc}'
        return err(operation_error, 400)
    except Exception as exc:
        operation_error = f'完整恢复失败，原数据已保留：{exc}'
        return err(operation_error, 500)
    finally:
        MAINTENANCE_MODE = False
        _finish_backup_status('restore', operation_error)
        BACKUP_OPERATION_LOCK.release()
        shutil.rmtree(temporary_dir, ignore_errors=True)


@app.route('/api/restore', methods=['POST','OPTIONS'])
def restore_json():
    """从旧版 JSON 导入基础记录（追加模式，跳过 app_no/reg_no 重复项）"""
    if request.method == 'OPTIONS': return ok()
    if 'file' not in request.files: return err("未选择文件")
    try:
        data = json.loads(request.files['file'].read().decode('utf-8'))
    except Exception as e:
        return err(f"JSON 解析失败: {e}")

    result = {'patents': 0, 'trademarks': 0, 'copyrights': 0,
              'skipped_patents': 0, 'skipped_trademarks': 0, 'skipped_copyrights': 0}
    with get_db() as db:
        for p in data.get('patents', []):
            try:
                if p.get('app_no') and db.execute("SELECT 1 FROM patents WHERE app_no=?",(p['app_no'],)).fetchone():
                    result['skipped_patents'] += 1; continue
                app_date = p.get('app_date')
                country = _normalize_country(p.get('country', '中国'))
                p_type = norm_patent_type(p.get('type','发明'))
                fee_route = _safe_patent_fee_route(country, p_type, p.get('fee_route','auto'))
                cy = calc_patent_current_year(
                    country, app_date, p.get('grant_date'),
                    p.get('current_year'), p.get('next_fee_date'), p_type,
                    fee_route=fee_route)
                next_fee_date = calc_patent_next_fee_date(
                    country, app_date, p.get('grant_date'),
                    cy if cy is not None else p.get('current_year'),
                    p.get('next_fee_date'), p_type, fee_route)
                cur = db.execute("""INSERT INTO patents
                    (title,app_no,pub_no,grant_no,type,country,status,app_date,pub_date,grant_date,
                     inventors,owner,agent,ipc,next_fee_date,current_year,fee_entity,
                     fee_reduction_approved,fee_route,fee_deadline_verified,notes,tags)
                    VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)""",
                    (p.get('title',''),p.get('app_no',''),p.get('pub_no',''),p.get('grant_no',''),
                     p_type,country,norm_patent_status(p.get('status','已受理')),
                     app_date,p.get('pub_date'),p.get('grant_date'),
                     p.get('inventors',''),p.get('owner',''),p.get('agent',''),p.get('ipc',''),
                     next_fee_date,cy,p.get('fee_entity','无费减'),
                     1 if _as_bool(p.get('fee_reduction_approved')) else 0,
                     fee_route,1 if _as_bool(p.get('fee_deadline_verified')) else 0,
                     p.get('notes',''),json.dumps(p.get('tags') or [])))
                record_status_change(db,'patent',cur.lastrowid,None,norm_patent_status(p.get('status','已受理')),'JSON恢复')
                result['patents'] += 1
            except Exception: result['skipped_patents'] += 1

        for t in data.get('trademarks', []):
            try:
                if t.get('app_no') and db.execute("SELECT 1 FROM trademarks WHERE app_no=?",(t['app_no'],)).fetchone():
                    result['skipped_trademarks'] += 1; continue
                tm_status = norm_tm_status(t.get('status','已受理'))
                tm_reg_date = t.get('reg_date')
                tm_renewal_date = sanitize_tm_renewal_date(
                    tm_status, tm_reg_date, t.get('renewal_date'))
                cur = db.execute("""INSERT INTO trademarks
                    (name,app_no,reg_no,type,classes,goods_services,country,status,
                     app_date,reg_date,renewal_date,owner,agent,notes,tags)
                    VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)""",
                    (t.get('name',''),t.get('app_no',''),t.get('reg_no',''),
                     norm_tm_type(t.get('type','文字')),t.get('classes',''),t.get('goods_services',''),
                     t.get('country','中国'),tm_status,
                     t.get('app_date'),tm_reg_date,tm_renewal_date,
                     t.get('owner',''),t.get('agent',''),t.get('notes',''),json.dumps(t.get('tags') or [])))
                record_status_change(db,'trademark',cur.lastrowid,None,tm_status,'JSON恢复')
                result['trademarks'] += 1
            except Exception: result['skipped_trademarks'] += 1

        for c in data.get('copyrights', []):
            try:
                if c.get('reg_no') and db.execute("SELECT 1 FROM copyrights WHERE reg_no=?",(c['reg_no'],)).fetchone():
                    result['skipped_copyrights'] += 1; continue
                db.execute("""INSERT INTO copyrights
                    (name,version,reg_no,reg_date,completion_date,owner,type,language,
                     development_mode,acquisition_mode,owner_type,publication_status,
                     first_publication_date,first_publication_place,registration_status,notes,tags)
                    VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)""",
                    (c.get('name',''),c.get('version',''),c.get('reg_no',''),
                     c.get('reg_date'),c.get('completion_date'),
                     c.get('owner',''),c.get('type',c.get('acquisition_mode','原始取得')),c.get('language',''),
                     c.get('development_mode','独立开发'),c.get('acquisition_mode','原始取得'),
                     c.get('owner_type','法人或其他组织'),c.get('publication_status','未发表'),
                     c.get('first_publication_date'),c.get('first_publication_place',''),
                     c.get('registration_status','已登记'),
                     c.get('notes',''),json.dumps(c.get('tags') or [])))
                result['copyrights'] += 1
            except Exception: result['skipped_copyrights'] += 1
    return ok(result)

@app.route('/api/export')
def export_json():
    with get_db() as db:
        patents=[row_to_dict(r) for r in db.execute("SELECT * FROM patents").fetchall()]
        trademarks=[row_to_dict(r) for r in db.execute("SELECT * FROM trademarks").fetchall()]
        copyrights=[row_to_dict(r) for r in db.execute("SELECT * FROM copyrights").fetchall()]
    data=json.dumps({"patents":patents,"trademarks":trademarks,"copyrights":copyrights,"exported_at":now_str()},ensure_ascii=False,indent=2)
    return send_file(BytesIO(data.encode()),mimetype='application/json',as_attachment=True,download_name=f'ip-backup-{date.today()}.json')

@app.route('/api/export-fees', methods=['POST','OPTIONS'])
def export_fees():
    """导出选中专利的年费缴费信息Excel（网上缴费模板格式）"""
    if request.method == 'OPTIONS': return ok()
    try:
        import openpyxl
        from openpyxl.styles import Font, PatternFill, Alignment
        from openpyxl.utils import get_column_letter
    except ImportError:
        return err('openpyxl未安装')
    try:
        data = request.get_json(force=True, silent=True) or {}
        ids = [int(x) for x in data.get('ids', [])]
        if not ids:
            return err('请先选择要导出的专利', 400)
        with get_db() as db:
            ph = ','.join('?'*len(ids))
            rows = db.execute(
                "SELECT id,title,app_no,type,country,app_date,grant_date,next_fee_date,"
                "current_year,fee_entity,fee_reduction_approved,fee_route,owner "
                "FROM patents WHERE id IN ({})".format(ph),
                ids
            ).fetchall()
            patents = [row_to_dict(r) for r in rows]
        id_order = {v:i for i,v in enumerate(ids)}
        patents.sort(key=lambda p: id_order.get(p['id'], 999))

        OWNER   = '北京至真健康科技股份有限公司'
        CREDIT  = '91110108MA002L8738'
        HEADERS = ['序号', '申请号/专利号/国际申请号/海牙转交编号', '业务类型',
                   '票据抬头', '统一社会信用代码', '费用种类', '外币金额',
                   '费用金额（人民币）', '备注']

        wb = openpyxl.Workbook()
        ws = wb.active
        ws.title = '网上缴费'

        col_widths = [6, 30, 12, 26, 22, 28, 10, 16, 12]
        for i, w in enumerate(col_widths, 1):
            ws.column_dimensions[get_column_letter(i)].width = w
        ws.row_dimensions[1].height = 28

        ws.append(HEADERS)
        hdr_fill = PatternFill(fill_type='solid', fgColor='1F4E79')
        for c in range(1, len(HEADERS) + 1):
            cell = ws.cell(1, c)
            cell.font = Font(bold=True, color='FFFFFF', name='Arial', size=10)
            cell.fill = hdr_fill
            cell.alignment = Alignment(horizontal='center', vertical='center', wrap_text=True)

        alt_fill = PatternFill(fill_type='solid', fgColor='EBF3FB')
        for i, p in enumerate(patents, 1):
            p_type  = p.get('type') or '发明'
            computed_year = calc_patent_current_year(
                p.get('country'), p.get('app_date'), p.get('grant_date'),
                p.get('current_year'), p.get('next_fee_date'), p_type,
                fee_route=p.get('fee_route'))
            yr      = int(computed_year or p.get('current_year') or 1)
            entity  = p.get('fee_entity') or '无费减'
            if _is_china(p.get('country')):
                quote = calculate_cn_annual_fee(
                    p_type, yr, entity, p.get('app_date'), p.get('grant_date'),
                    p.get('next_fee_date'), date.today(), owner=p.get('owner'),
                    fee_reduction_approved=p.get('fee_reduction_approved'),
                    fee_reduction_status=p.get('fee_reduction_status'),
                    fee_reduction_ratio=p.get('fee_reduction_ratio'))
                # 已超过专利保护期限的旧年度不应进入网上缴费模板。
                if not quote['base']:
                    continue
                fee = quote['total_due']
                notes = []
                if quote['late_fee']:
                    notes.append(f"含滞纳金{quote['late_fee']}元")
                if quote['reduction_eligible']:
                    notes.append(
                        f"{quote['owner_count']}个权利人，"
                        f"减免{int(quote['owner_reduction_rate'] * 100)}%")
                elif not quote['reduction_approved']:
                    notes.append('未启用费减，按标准年费计算')
                elif not quote['reduction_eligible']:
                    notes.append('未满足费减条件，按标准年费计算')
                note = '；'.join(notes)
            else:
                fee = ''
                note = '国外案件请按当地规则核对'
            fee_kind = f'{p_type}专利第{yr}年年费'
            ws.append([i, p.get('app_no', ''), p_type, OWNER, CREDIT, fee_kind, '', fee, note])
            ri = i + 1
            for c in range(1, 10):
                cell = ws.cell(ri, c)
                cell.font = Font(name='Arial', size=10)
                cell.alignment = Alignment(
                    horizontal='right' if c == 8 else ('left' if c == 2 else 'center'),
                    vertical='center')
                if i % 2 == 0:
                    cell.fill = alt_fill

        ws.freeze_panes = 'A2'
        buf = BytesIO()
        wb.save(buf)
        buf.seek(0)
        fname = f'网上缴费_{date.today().isoformat()}.xlsx'
        return send_file(
            buf,
            mimetype='application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
            as_attachment=True,
            download_name=fname
        )
    except Exception as e:
        import traceback
        traceback.print_exc()
        return err(f'导出失败: {str(e)}', 500)


@app.route('/api/documents/all', methods=['GET','OPTIONS'])
def docs_all():
    """获取所有附件（含所属知产名称），支持筛选"""
    if request.method == 'OPTIONS': return ok()
    item_type = request.args.get('item_type','').strip()
    doc_type  = request.args.get('doc_type','').strip()
    date_from = request.args.get('date_from','').strip()
    date_to   = request.args.get('date_to','').strip()
    q         = request.args.get('q','').strip()
    with get_db() as db:
        sql = """
            SELECT d.id, d.item_type, d.item_id, d.filename, d.original_name,
                   d.file_size, d.mime_type, d.doc_type, COALESCE(d.file_hash, '') AS file_hash,
                   COALESCE(d.description, '') AS description,
                   COALESCE(d.review_status, '') AS review_status,
                   COALESCE(d.analysis_json, '') AS analysis_json,
                   d.reviewed_at,
                   d.uploaded_at,
                   (SELECT COUNT(*) FROM documents d2 WHERE d2.filename=d.filename) AS shared_count,
                   COALESCE(p.title, t.name, c.name, '') AS item_name,
                   COALESCE(t.classes, '') AS item_class,
                   COALESCE(p.app_no, t.app_no, c.reg_no, '') AS item_app_no,
                   COALESCE(t.reg_no, '') AS item_reg_no,
                   COALESCE(p.country, t.country, '') AS item_country,
                   COALESCE(p.owner, t.owner, c.owner, '') AS item_owner
            FROM documents d
            LEFT JOIN patents    p ON d.item_type='patent'    AND d.item_id=p.id
            LEFT JOIN trademarks t ON d.item_type='trademark' AND d.item_id=t.id
            LEFT JOIN copyrights c ON d.item_type='copyright' AND d.item_id=c.id
            WHERE 1=1
        """
        params = []
        if item_type: sql += " AND d.item_type=?"; params.append(item_type)
        if doc_type:  sql += " AND d.doc_type=?";  params.append(doc_type)
        if date_from: sql += " AND d.uploaded_at>=?"; params.append(date_from)
        if date_to:   sql += " AND d.uploaded_at<=?"; params.append(date_to + ' 23:59:59')
        if q:
            p2 = f'%{q}%'
            sql += " AND (d.original_name LIKE ? OR d.filename LIKE ? OR COALESCE(p.title,t.name,c.name,'') LIKE ? OR d.doc_type LIKE ?)"
            params += [p2,p2,p2,p2]
        sql += " ORDER BY d.uploaded_at DESC"
        rows = [dict(r) for r in db.execute(sql, params).fetchall()]
    return ok(rows)

@app.route('/api/documents/count', methods=['GET','OPTIONS'])
def docs_count():
    """返回附件总数"""
    if request.method == 'OPTIONS': return ok()
    with get_db() as db:
        row = db.execute("SELECT COUNT(*) AS c FROM documents").fetchone()
    return ok({'count': row['c'] if row else 0})

@app.route('/api/documents/duplicates', methods=['GET','OPTIONS'])
def docs_duplicates():
    """按文件内容扫描重复附件。"""
    if request.method == 'OPTIONS': return ok()
    with get_db() as db:
        _ensure_document_hashes(db, limit=2000)
        rows = db.execute("""
            SELECT d.id, d.item_type, d.item_id, d.filename, d.original_name,
                   d.file_size, d.mime_type, d.doc_type, d.uploaded_at,
                   COALESCE(d.file_hash, '') AS file_hash,
                   (SELECT COUNT(*) FROM documents d2 WHERE d2.filename=d.filename) AS shared_count,
                   COALESCE(p.title, t.name, c.name, '') AS item_name,
                   COALESCE(t.classes, '') AS item_class,
                   COALESCE(p.app_no, t.app_no, c.reg_no, '') AS item_app_no,
                   COALESCE(t.reg_no, '') AS item_reg_no,
                   COALESCE(p.country, t.country, '') AS item_country,
                   COALESCE(p.owner, t.owner, c.owner, '') AS item_owner
            FROM documents d
            LEFT JOIN patents    p ON d.item_type='patent'    AND d.item_id=p.id
            LEFT JOIN trademarks t ON d.item_type='trademark' AND d.item_id=t.id
            LEFT JOIN copyrights c ON d.item_type='copyright' AND d.item_id=c.id
            ORDER BY d.uploaded_at DESC
        """).fetchall()
    groups = build_duplicate_groups(rows, UPLOAD_DIR)
    return ok({'groups': groups, 'group_count': len(groups),
               'duplicate_count': sum(max(0, g['count'] - 1) for g in groups)})


@app.route('/api/documents/merge-duplicates', methods=['POST','OPTIONS'])
def docs_merge_duplicates():
    """Merge duplicate attachment content by sharing one file, or delete duplicate rows."""
    if request.method == 'OPTIONS': return ok()
    d = request.get_json(silent=True) or {}
    if not isinstance(d, dict):
        return err('请求参数格式错误', 400)
    try:
        raw_keep_id = d.get('keep_id')
        if isinstance(raw_keep_id, bool) or raw_keep_id in (None, ''):
            raise ValueError
        keep_id = int(raw_keep_id)
        raw_merge_ids = d.get('merge_ids', [])
        if not isinstance(raw_merge_ids, list):
            raise ValueError
        merge_ids = []
        for value in raw_merge_ids:
            if isinstance(value, bool):
                raise ValueError
            item_id = int(value)
            if item_id <= 0:
                raise ValueError
            if item_id != keep_id and item_id not in merge_ids:
                merge_ids.append(item_id)
    except (TypeError, ValueError, OverflowError):
        return err('附件 ID 必须是正整数，且 merge_ids 必须是数组', 400)
    mode = d.get('mode', 'share')
    if not keep_id or not merge_ids:
        return err('请选择保留附件和需要处理的附件', 400)
    if mode not in ('share', 'delete_rows'):
        return err('处理方式不支持', 400)

    with get_db() as db:
        _ensure_document_hashes(db, limit=2000)
        keep = db.execute("SELECT * FROM documents WHERE id=?", (keep_id,)).fetchone()
        if not keep:
            return err('保留附件不存在', 404)
        placeholders = ",".join("?" * len(merge_ids))
        rows = db.execute(f"SELECT * FROM documents WHERE id IN ({placeholders})", merge_ids).fetchall()
        if len(rows) != len(merge_ids):
            return err('部分附件不存在，请刷新后重试', 404)

        keep_hash = keep["file_hash"] or ""
        if not keep_hash and (UPLOAD_DIR / keep["filename"]).exists():
            keep_hash = file_sha256(UPLOAD_DIR / keep["filename"])
            db.execute("UPDATE documents SET file_hash=? WHERE id=?", (keep_hash, keep_id))
        if not keep_hash:
            return err('保留附件文件不存在，无法合并', 400)

        for row in rows:
            row_hash = row["file_hash"] or ""
            if not row_hash and (UPLOAD_DIR / row["filename"]).exists():
                row_hash = file_sha256(UPLOAD_DIR / row["filename"])
                db.execute("UPDATE documents SET file_hash=? WHERE id=?", (row_hash, row["id"]))
            if row_hash != keep_hash:
                return err('只能处理内容完全一致的附件', 400)

        if mode == 'delete_rows':
            result = _delete_document_rows(db, merge_ids)
            return ok({'mode': mode, **result})

        old_filenames = [row["filename"] for row in rows]
        db.execute(f"""
            UPDATE documents
            SET filename=?, file_size=?, mime_type=?, file_hash=?
            WHERE id IN ({placeholders})
        """, [keep["filename"], keep["file_size"], keep["mime_type"], keep_hash, *merge_ids])
        removed = sum(1 for filename in set(old_filenames) if filename != keep["filename"] and _unlink_if_unreferenced(db, filename))
    return ok({'mode': mode, 'updated': len(rows), 'files_removed': removed})

@app.route('/api/documents/bulk-download', methods=['POST','OPTIONS'])
def docs_bulk_download():
    """批量下载附件（打包ZIP）"""
    if request.method == 'OPTIONS': return ok()
    try:
        ids = [int(x) for x in (request.json or {}).get('ids', [])]
        if not ids: return err('请选择要下载的附件', 400)
        with get_db() as db:
            ph = ','.join('?'*len(ids))
            docs = [dict(r) for r in db.execute(
                f"SELECT filename, original_name FROM documents WHERE id IN ({ph})", ids
            ).fetchall()]
        buf = BytesIO()
        name_count = {}
        with zipfile.ZipFile(buf, 'w', zipfile.ZIP_DEFLATED) as zf:
            for d in docs:
                fpath = UPLOAD_DIR / d['filename']
                if not fpath.exists(): continue
                oname = d['original_name'] or d['filename']
                # Handle duplicate filenames in zip
                base, ext = os.path.splitext(oname)
                if oname in name_count:
                    name_count[oname] += 1
                    oname = f"{base}_{name_count[oname]}{ext}"
                else:
                    name_count[oname] = 0
                zf.write(fpath, oname)
        buf.seek(0)
        fname = f'附件打包_{date.today().isoformat()}.zip'
        return send_file(buf, mimetype='application/zip', as_attachment=True, download_name=fname)
    except Exception as e:
        import traceback; traceback.print_exc()
        return err(f'打包失败: {str(e)}', 500)


# ══════════ 批量上传附件 ══════════════════════════════════════

def _match_record_by_hint(db, hint):
    """通过文件名或文件夹名提取申请号/名称，匹配知产记录"""
    if not hint: return None, None, None, None
    import re

    # ① 专利申请号: CN20xx...   PCT/...  ZL...
    for pat in [r'(CN[\d]{9,14}[.\d]*)', r'(PCT/[A-Z]{2}[\d]{4}/[\d]+)', r'(ZL[\d]{10,14})']:
        m = re.search(pat, hint, re.IGNORECASE)
        if m:
            val = m.group(1).upper()
            row = db.execute("SELECT id,title,app_no FROM patents WHERE UPPER(app_no) LIKE ? OR UPPER(pub_no) LIKE ? OR UPPER(grant_no) LIKE ?",
                             [f'%{val}%']*3).fetchone()
            if row: return 'patent', row['id'], row['title'], row['app_no']

    # ② 商标申请号: 7-9位纯数字
    m = re.search(r'(?<![0-9])([0-9]{7,9})(?![0-9])', hint)
    if m:
        val = m.group(1)
        row = db.execute("SELECT id,name,app_no FROM trademarks WHERE app_no=? OR reg_no=?", [val, val]).fetchone()
        if row: return 'trademark', row['id'], row['name'], row['app_no']

    # ③ 软著登记号: 2020SR...
    m = re.search(r'([0-9]{4}SR[0-9]+)', hint, re.IGNORECASE)
    if m:
        val = m.group(1).upper()
        row = db.execute("SELECT id,name,reg_no FROM copyrights WHERE UPPER(reg_no) LIKE ?", [f'%{val}%']).fetchone()
        if row: return 'copyright', row['id'], row['name'], row['reg_no']

    # ④ 模糊名称匹配（去除扩展名和常见前缀后取前10字）
    clean = re.sub(r'[.](pdf|jpg|jpeg|png|docx|doc|xlsx|xls|zip|rar|ofd)$', '', hint, flags=re.IGNORECASE)
    clean = re.sub(r'[_ \t-]', ' ', clean).strip()
    words = [w for w in clean.split() if len(w) >= 2][:3]
    for w in words:
        lk = f'%{w}%'
        row = db.execute("SELECT id,title AS name,app_no FROM patents WHERE title LIKE ? LIMIT 1", [lk]).fetchone()
        if row: return 'patent', row['id'], row['name'], row['app_no']
        row = db.execute("SELECT id,name,app_no FROM trademarks WHERE name LIKE ? LIMIT 1", [lk]).fetchone()
        if row: return 'trademark', row['id'], row['name'], row['app_no']
        row = db.execute("SELECT id,name,reg_no FROM copyrights WHERE name LIKE ? LIMIT 1", [lk]).fetchone()
        if row: return 'copyright', row['id'], row['name'], row['reg_no']

    return None, None, None, None


@app.route('/api/documents/batch-parse', methods=['POST','OPTIONS'])
def docs_batch_parse():
    """
    批量上传并自动匹配：
    - 支持直接上传多个文件 (files[])
    - 支持上传 ZIP 包（含目录结构：<申请号>/<文件名>）
    临时保存在 UPLOAD_DIR/tmp/，返回匹配预览
    """
    if request.method == 'OPTIONS': return ok()
    import uuid, shutil

    TEMP_DIR = UPLOAD_DIR / 'tmp'
    TEMP_DIR.mkdir(exist_ok=True)
    batch_id = uuid.uuid4().hex[:12]
    batch_dir = TEMP_DIR / batch_id
    batch_dir.mkdir()

    results = []
    files_to_process = []  # (temp_path, original_name, hint_from_folder)

    try:
        uploaded = request.files.getlist('files[]') or request.files.getlist('files')
        if not uploaded:
            return err('请选择要上传的文件', 400)

        for uf in uploaded:
            if not uf.filename: continue
            ext = Path(uf.filename).suffix.lower()
            # 如果是 ZIP，解压后处理
            if ext == '.zip':
                zip_path = batch_dir / '__upload__.zip'
                uf.save(str(zip_path))
                try:
                    with zipfile.ZipFile(str(zip_path), 'r') as zf:
                        for zi in zf.infolist():
                            if zi.is_dir(): continue
                            zname = zi.filename
                            # 跳过 macOS 元数据
                            if '__MACOSX' in zname or zname.startswith('.') or '/.'  in zname: continue
                            parts = Path(zname).parts
                            folder_hint = parts[-2] if len(parts) >= 2 else ''
                            fname = parts[-1]
                            if Path(fname).suffix.lower() not in ALLOWED_EXT: continue
                            dest = batch_dir / f'{len(files_to_process):04d}_{fname}'
                            with zf.open(zi) as src, open(str(dest), 'wb') as dst:
                                dst.write(src.read())
                            files_to_process.append((dest, fname, folder_hint or fname))
                except Exception as ze:
                    return err(f'ZIP解压失败: {ze}', 400)
                finally:
                    zip_path.unlink(missing_ok=True)
            else:
                if ext not in ALLOWED_EXT: continue
                dest = batch_dir / f'{len(files_to_process):04d}_{uf.filename}'
                uf.save(str(dest))
                files_to_process.append((dest, uf.filename, uf.filename))

        if not files_to_process:
            shutil.rmtree(str(batch_dir), ignore_errors=True)
            return err('未找到可处理的文件', 400)

        with get_db() as db:
            for tmp_path, orig_name, hint in files_to_process:
                item_type, item_id, item_name, item_no = _match_record_by_hint(db, hint)
                detected_type = item_type or _guess_type_from_content(tmp_path)
                detected_text = extract_document_text(tmp_path) if detected_type else ''
                detected_analysis = analyze_doc_text(detected_text, detected_type) if detected_type else None
                name_doc_type = _doc_type_from_name(orig_name, detected_type)
                resolved_doc_type = name_doc_type if name_doc_type != '其他' else ((detected_analysis or {}).get('doc_type') or name_doc_type)
                results.append({
                    'tmp': tmp_path.name,            # 服务器临时文件名
                    'original_name': orig_name,
                    'size': tmp_path.stat().st_size,
                    'item_type':  item_type or detected_type or '',
                    'item_id':    item_id   or '',
                    'item_name':  item_name or '',
                    'item_no':    item_no or '',
                    'matched':    bool(item_type and item_id),
                    # 文件名是用户可见、可核对的明确线索；当它能识别出具体类型时，
                    # 不让 OCR/正文的泛化分析覆盖它。
                    'doc_type':   resolved_doc_type,
                    'suggested_status': _suggested_status_for_doc_type(detected_type, resolved_doc_type) or (detected_analysis or {}).get('suggested_status'),
                    # 默认采用识别建议；用户可在上传预览中改选，确认后统一同步案件。
                    'case_status': _suggested_status_for_doc_type(detected_type, resolved_doc_type) or (detected_analysis or {}).get('suggested_status') or '',
                    'type_source': 'record' if item_type else ('content' if detected_type else ''),
                    'type_confidence': (detected_analysis or {}).get('confidence', 0),
                    'extracted_fields': extract_doc_fields(detected_text, detected_type, orig_name) if detected_type else {},
                    'description': '',
                })
    except Exception as e:
        import traceback; traceback.print_exc()
        return err(f'解析失败: {e}', 500)

    return ok({'batch_id': batch_id, 'files': results})


@app.route('/api/documents/batch-commit', methods=['POST','OPTIONS'])
def docs_batch_commit():
    """
    确认批量上传：将临时文件永久存储并建立关联
    Body: {batch_id, files: [{tmp, original_name, item_type, item_id, doc_type}]}
    """
    if request.method == 'OPTIONS': return ok()
    import shutil

    d = request.json or {}
    batch_id = str(d.get('batch_id') or '').strip()
    files = d.get('files', [])
    if not re.fullmatch(r'[0-9a-f]{12}', batch_id):
        return err('上传批次无效，请重新选择附件', 400)
    if not isinstance(files, list) or not files:
        return err('请选择要上传的附件', 400)
    if any(not f.get('tmp') or not f.get('item_type') or not f.get('item_id') for f in files):
        return err('每个附件都必须关联具体案件', 400)

    TEMP_DIR = UPLOAD_DIR / 'tmp' / batch_id
    if not TEMP_DIR.exists(): return err('批次已过期，请重新上传', 400)

    saved = 0; skipped = 0; anchors_updated = 0; status_updated = 0; errors = []
    with get_db() as db:
        for f in files:
            tmp_name = f.get('tmp', '')
            item_type = f.get('item_type', '').strip()
            item_id   = f.get('item_id', '')
            orig_name = f.get('original_name', tmp_name)
            doc_type  = f.get('doc_type', '其他')
            description = str(f.get('description') or '').strip()[:500]
            received_date = str(f.get('received_date') or '').strip()
            case_status = str(f.get('case_status') or '').strip()

            if not tmp_name or not item_type or not item_id:
                skipped += 1; continue
            if received_date and not _valid_iso_date_or_empty(received_date):
                errors.append(f'{orig_name}: 官文收文日期格式无效')
                skipped += 1; continue

            tmp_path = TEMP_DIR / tmp_name
            if not tmp_path.exists(): skipped += 1; continue

            try:
                ext = Path(orig_name).suffix.lower()
                stored = _store_document_source(db, tmp_path, orig_name, item_type, item_id, move=True)
                cur = db.execute(
                    """INSERT INTO documents
                       (item_type,item_id,filename,original_name,file_size,mime_type,doc_type,description,received_date,file_hash)
                       VALUES (?,?,?,?,?,?,?,?,?,?)""",
                    (item_type, int(item_id), stored['filename'], orig_name, stored['file_size'],
                     stored['mime_type'], doc_type, description or '附件中心上传',
                     received_date or None, stored['file_hash']))
                anchor_field = _suggest_document_anchor(item_type, doc_type, received_date)
                if anchor_field:
                    table = DOCUMENT_RECORD_META.get(item_type, (None,))[0]
                    if table:
                        db.execute(
                            f"UPDATE {table} SET {anchor_field}=?, updated_at=? WHERE id=?",
                            (received_date, now_str(), int(item_id)),
                        )
                        anchors_updated += 1
                if case_status and item_type in ('patent', 'trademark'):
                    table = 'patents' if item_type == 'patent' else 'trademarks'
                    normalized_status = (
                        norm_patent_status(case_status)
                        if item_type == 'patent' else norm_tm_status(case_status)
                    )
                    record = db.execute(f"SELECT status FROM {table} WHERE id=?", (int(item_id),)).fetchone()
                    if record and record['status'] != normalized_status:
                        db.execute(
                            f"UPDATE {table} SET status=?, updated_at=? WHERE id=?",
                            (normalized_status, now_str(), int(item_id)),
                        )
                        record_status_change(
                            db, item_type, int(item_id), record['status'], normalized_status,
                            f'附件上传：{doc_type}',
                        )
                        status_updated += 1
                saved += 1
            except Exception as e:
                errors.append(f'{orig_name}: {e}')
                skipped += 1

    # 清理临时目录
    import shutil as _sh
    _sh.rmtree(str(TEMP_DIR), ignore_errors=True)

    return ok({'saved': saved, 'skipped': skipped, 'anchors_updated': anchors_updated,
               'status_updated': status_updated, 'errors': errors[:5]})


@app.route('/api/documents/batch-cancel', methods=['POST','OPTIONS'])
def docs_batch_cancel():
    """取消批量上传，清理临时文件"""
    if request.method == 'OPTIONS': return ok()
    import shutil
    batch_id = str((request.json or {}).get('batch_id') or '').strip()
    if re.fullmatch(r'[0-9a-f]{12}', batch_id):
        TEMP_DIR = UPLOAD_DIR / 'tmp' / batch_id
        shutil.rmtree(str(TEMP_DIR), ignore_errors=True)
    return ok()


@app.route('/api/records/search', methods=['GET','OPTIONS'])
def records_search():
    """通用知产记录搜索（用于批量上传时手动匹配）"""
    if request.method == 'OPTIONS': return ok()
    q = request.args.get('q','').strip()
    if not q: return ok([])
    lk = f'%{q}%'
    with get_db() as db:
        patents = [dict(r) for r in db.execute(
            "SELECT id,'patent' AS item_type,title AS name,app_no FROM patents WHERE title LIKE ? OR app_no LIKE ? OR inventors LIKE ? LIMIT 10",
            [lk,lk,lk]).fetchall()]
        trademarks = [dict(r) for r in db.execute(
            "SELECT id,'trademark' AS item_type,name,app_no FROM trademarks WHERE name LIKE ? OR app_no LIKE ? LIMIT 10",
            [lk,lk]).fetchall()]
        copyrights = [dict(r) for r in db.execute(
            "SELECT id,'copyright' AS item_type,name,reg_no AS app_no FROM copyrights WHERE name LIKE ? OR reg_no LIKE ? LIMIT 10",
            [lk,lk]).fetchall()]
    return ok(patents + trademarks + copyrights)


# ══════════════ 待关联文件夹 ══════════════

def _watch_dir():
    """Return the persisted watch folder, falling back to the web data directory."""
    configured = ''
    try:
        with get_db() as db:
            row = db.execute(
                "SELECT value FROM settings WHERE key='watch_folder_path'"
            ).fetchone()
            configured = (row['value'] if row else '').strip()
    except sqlite3.Error:
        configured = ''
    if configured:
        return Path(configured).expanduser().resolve()
    DEFAULT_WATCH_DIR.mkdir(parents=True, exist_ok=True)
    return DEFAULT_WATCH_DIR.resolve()


def _watch_source(rel_path):
    """Resolve one file inside the watch folder without allowing path escape."""
    if not rel_path:
        return None
    try:
        base = _watch_dir()
        src = (base / rel_path).resolve()
        src.relative_to(base)
    except (OSError, ValueError):
        return None
    return src if src.is_file() else None


def _watch_file_analysis(fpath, item_type, type_source, name_doc_type):
    """Return cached OCR/classification results for one unchanged watch file."""
    if not item_type:
        return {}
    try:
        stat = fpath.stat()
        cache_key = (str(fpath.resolve()), stat.st_mtime_ns, stat.st_size, item_type)
    except OSError:
        return {}
    cached = WATCH_ANALYSIS_CACHE.get(cache_key)
    if cached is not None:
        return dict(cached)

    result = {}
    try:
        text = extract_document_text(fpath)
        analysis = analyze_doc_text(text, item_type)
        if analysis and analysis.get('doc_type') and analysis['doc_type'] != '其他文书':
            # 内容分析有结果，用内容结果覆盖文件名结果。
            result.update({
                'suggested_doc_type': analysis['doc_type'],
                'suggested_status': analysis.get('suggested_status'),
                'snippet': analysis.get('snippet', ''),
                'type_confidence': analysis.get('confidence', 0),
            })
        elif analysis:
            # 内容分析不明确，保留文件名结果，但补充状态和摘要。
            result.update({
                'suggested_doc_type': name_doc_type,
                'suggested_status': analysis.get('suggested_status'),
                'snippet': analysis.get('snippet', ''),
                'type_confidence': 0.55 if type_source == 'content' else 0.0,
            })
    except Exception:
        # 单个文件分析失败不应阻断整个待关联列表。
        result = {}

    if len(WATCH_ANALYSIS_CACHE) >= WATCH_ANALYSIS_CACHE_LIMIT:
        WATCH_ANALYSIS_CACHE.pop(next(iter(WATCH_ANALYSIS_CACHE)), None)
    WATCH_ANALYSIS_CACHE[cache_key] = dict(result)
    return result


@app.route('/api/watch/scan', methods=['GET','OPTIONS'])
def watch_scan():
    """扫描待关联文件夹，返回文件列表及自动匹配结果"""
    if request.method == 'OPTIONS': return ok()
    watch_dir = _watch_dir()
    if not watch_dir.exists() or not watch_dir.is_dir():
        return err('设置的待关联文件夹不存在，请在设置中重新选择', 400)
    # Collect all files (recursively, up to 1 level of subdir)
    candidates = []
    for item in sorted(watch_dir.rglob('*')):
        if item.is_file() and item.suffix.lower() in ALLOWED_EXT:
            rel = item.relative_to(watch_dir)
            candidates.append((item, str(rel)))

    with get_db() as db:
        results = []
        analysis_tasks = []
        for fpath, rel in candidates:
            item_type, record = _match_file(str(fpath), db)
            type_source = 'filename' if item_type else ''
            # 文件名没有类型线索时，使用正文/OCR判断。这样扫描件商标注册证
            # 也会默认落到“商标”，但仍保留前端手动改类型的能力。
            if not item_type:
                item_type = _guess_type_from_content(fpath)
                type_source = 'content' if item_type else ''
            stat = fpath.stat()
            entry = {
                'rel_path': rel,
                'filename': fpath.name,
                'size': stat.st_size,
                'mtime': datetime.fromtimestamp(stat.st_mtime).strftime('%Y-%m-%d %H:%M'),
                'item_type': item_type,
                'item_id': record['id'] if record else None,
                'item_name': (record.get('title') or record.get('name') or '') if record else '',
                'item_app_no': (record.get('app_no') or record.get('reg_no') or '') if record else '',
                'suggested_doc_type': _doc_type_from_name(fpath.name),
                'matched': record is not None,
                'type_source': type_source,
            }
            # 未匹配的文件：综合文件名+内容分析
            name_doc_type = _doc_type_from_name(fpath.name)
            entry['suggested_doc_type'] = name_doc_type
            analysis_tasks.append((fpath, item_type, type_source, name_doc_type))
            results.append(entry)
    # OCR/文本提取通常会调用外部工具，文件之间互不依赖，可以并行执行。
    # 这样首次扫描也不会被单个大文件串行阻塞；未变化文件仍由缓存直接返回。
    if analysis_tasks:
        from concurrent.futures import ThreadPoolExecutor
        worker_count = min(4, len(analysis_tasks))
        with ThreadPoolExecutor(max_workers=worker_count) as pool:
            analyses = list(pool.map(lambda task: _watch_file_analysis(*task), analysis_tasks))
        for entry, analysis in zip(results, analyses):
            entry.update(analysis)
    return ok({'files': results, 'watch_dir': str(watch_dir), 'total': len(results)})


@app.route('/api/watch/analyze', methods=['GET','OPTIONS'])
def watch_analyze():
    """分析待关联文件夹中的文件，返回识别结果（不创建记录）"""
    if request.method == 'OPTIONS': return ok()
    rel_path = request.args.get('path', '')
    if not rel_path:
        return err('缺少 path 参数', 400)
    src = _watch_source(rel_path)
    if not src:
        return err(f'文件不存在: {rel_path}', 404)

    # 判断类型
    item_type, _ = _match_file(str(src), None) if False else (None, None)
    # 从文件名推断类型
    name = src.name
    if any(k in name for k in ['商标', '注册证', '驳回通知书']):
        item_type = 'trademark'
    elif any(k in name for k in ['专利', '授权', '受理通知', '复审', '检索报告']):
        item_type = 'patent'
    elif any(k in name for k in ['软著', '登记证', '著作权']):
        item_type = 'copyright'
    if not item_type:
        item_type = _guess_type_from_content(src)

    text = extract_document_text(src)
    analysis = analyze_doc_text(text, item_type) if item_type else {}
    fields = extract_doc_fields(text, item_type, src.name) if item_type else {}

    return ok({
        'item_type': item_type,
        'type_confidence': (analysis or {}).get('confidence', 0) if item_type else 0,
        'doc_type': analysis.get('doc_type', _doc_type_from_name(src.name)),
        'suggested_status': analysis.get('suggested_status'),
        'snippet': analysis.get('snippet', ''),
        'extracted_fields': fields,
    })


@app.route('/api/watch/review', methods=['GET','OPTIONS'])
def watch_review():
    """Analyze a newly matched watch-folder file before it is imported."""
    if request.method == 'OPTIONS': return ok()
    rel_path = request.args.get('path', '')
    item_type = request.args.get('item_type', '').strip()
    item_id = request.args.get('item_id', type=int)
    doc_type = request.args.get('doc_type', '').strip() or '其他'
    src = _watch_source(rel_path)
    if not src:
        return err('待关联文件不存在或路径无效', 404)
    if item_type not in DOCUMENT_RECORD_META or not item_id:
        return err('请先选择要关联的案件', 400)

    with get_db() as db:
        text = extract_document_text(src)
        review, review_error = _build_document_review(db, {
            'id': 0,
            'item_type': item_type,
            'item_id': item_id,
            'original_name': src.name,
            'doc_type': doc_type,
        }, text)
        if review_error:
            return err(review_error, 404 if '不存在' in review_error else 400)
    review['rel_path'] = rel_path
    return ok(review)


@app.route('/api/watch/import', methods=['POST','OPTIONS'])
def watch_import():
    """核对待关联文件，确认后更新案件并导入附件。"""
    if request.method == 'OPTIONS': return ok()
    items = (request.json or {}).get('items', [])
    if not items: return err('未指定文件', 400)
    imported, failed, warnings, updated_count, deadline_preview = 0, [], [], 0, []
    imported_sources = []
    with get_db() as db:
        for it in items:
            stored = None
            try:
                rel_path = it.get('rel_path', '')
                src = _watch_source(rel_path)
                if not src:
                    failed.append(rel_path + ' (不存在或路径无效)'); continue
                if not it.get('item_id') or not it.get('item_type'):
                    failed.append(rel_path + ' (未指定关联目标)'); continue
                if not it.get('reviewed'):
                    failed.append(rel_path + ' (请先核对后再导入)'); continue

                item_type = it['item_type']
                item_id = int(it['item_id'])
                doc_type = it.get('doc_type', '其他')
                text = extract_document_text(src)
                review, review_error = _build_document_review(db, {
                    'id': 0,
                    'item_type': item_type,
                    'item_id': item_id,
                    'original_name': src.name,
                    'doc_type': doc_type,
                }, text)
                if review_error:
                    failed.append(rel_path + f' ({review_error})'); continue

                review_fields = {change['field'] for change in review.get('changes', [])}
                confirmed_updates = {
                    field: value
                    for field, value in (it.get('updates') or {}).items()
                    if field in review_fields
                }
                clean_updates, deadlines = _apply_review_updates(
                    db, item_type, item_id, confirmed_updates, src.name,
                )
                updated_count += len(clean_updates)
                deadline_preview.extend(deadlines)
                stored = _store_document_source(db, src, src.name, item_type, item_id, move=False)
                review['review_status'] = 'applied'
                review['applied_fields'] = list(clean_updates)
                db.execute(
                    """INSERT INTO documents
                       (item_type,item_id,filename,original_name,file_size,mime_type,doc_type,
                        description,file_hash,analysis_json,review_status,reviewed_at)
                       VALUES (?,?,?,?,?,?,?,?,?,?,?,?)""",
                    (
                        item_type, item_id, stored['filename'], src.name,
                        stored['file_size'], stored['mime_type'],
                        review.get('doc_type') or doc_type,
                        it.get('description', ''), stored['file_hash'],
                        json.dumps(review, ensure_ascii=False), 'applied', now_str(),
                    ),
                )
                imported += 1
                imported_sources.append(src)
            except Exception as e:
                if stored:
                    _unlink_if_unreferenced(db, stored.get('filename'))
                failed.append(it.get('rel_path', '') + f' ({e})')
    for source in imported_sources:
        try:
            source.unlink(missing_ok=True)
        except OSError:
            warnings.append(str(source.name) + '（已导入，但无法从待关联文件夹移除原文件）')
    return ok({
        'imported': imported,
        'failed': failed,
        'warnings': warnings,
        'updated_count': updated_count,
        'deadline_preview': deadline_preview,
    })


@app.route('/api/watch/preview', methods=['GET','OPTIONS'])
def watch_preview():
    """预览待关联文件夹中的文件"""
    if request.method == 'OPTIONS': return ok()
    rel_path = request.args.get('path', '')
    if not rel_path: return err('缺少path参数', 400)
    src = _watch_source(rel_path)
    if not src: return err('文件不存在或路径无效', 404)
    mime = mimetypes.guess_type(src.name)[0] or 'application/octet-stream'
    return send_file(str(src), mimetype=mime)


@app.route('/api/watch/path', methods=['GET','OPTIONS'])
def watch_path():
    """返回待关联文件夹的绝对路径"""
    if request.method == 'OPTIONS': return ok()
    watch_dir = _watch_dir()
    with get_db() as db:
        row = db.execute(
            "SELECT value FROM settings WHERE key='watch_folder_path'"
        ).fetchone()
    return ok({
        'path': str(watch_dir),
        'default_path': str(DEFAULT_WATCH_DIR.resolve()),
        'configured': bool(row and row['value'].strip()),
        'exists': watch_dir.exists() and watch_dir.is_dir(),
    })


@app.route('/api/analyze-document', methods=['POST','OPTIONS'])
def analyze_document():
    """分析上传的文档，提取字段用于自动填充。
    接收: multipart/form-data with 'file' and 'item_type'
    返回: {doc_type, suggested_status, extracted_fields, snippet}
    """
    if request.method == 'OPTIONS': return ok()
    if 'file' not in request.files:
        return err('未选择文件', 400)
    f = request.files['file']
    item_type = request.form.get('item_type', 'patent')
    if item_type not in ('patent', 'trademark', 'copyright'):
        return err('无效的类型', 400)

    # 保存到临时位置
    import tempfile
    ext = Path(f.filename).suffix.lower()
    with tempfile.NamedTemporaryFile(suffix=ext, delete=False) as tmp:
        f.save(tmp.name)
        tmp_path = Path(tmp.name)

    try:
        # 提取文本
        text = extract_document_text(tmp_path)

        # 分析文书类型和状态
        analysis = analyze_doc_text(text, item_type) or {}

        # 提取字段
        fields = extract_doc_fields(text, item_type, f.filename)

        return ok({
            'doc_type': analysis.get('doc_type', '其他'),
            'suggested_status': analysis.get('suggested_status'),
            'confidence': analysis.get('confidence', 0),
            'snippet': analysis.get('snippet', ''),
            'extracted_fields': fields,
            'text_length': len(text),
        })
    finally:
        tmp_path.unlink(missing_ok=True)


@app.route('/api/watch/create-and-import', methods=['POST','OPTIONS'])
def watch_create_and_import():
    """从待关联文件自动创建新知产记录并关联附件。
    接收: rel_path, item_type (patent/trademark/copyright)
    自动: 提取PDF文本 → 分析文书类型/状态 → 提取字段 → 创建记录 → 导入附件
    """
    if request.method == 'OPTIONS': return ok()
    d = request.json or {}
    rel_path = d.get('rel_path', '')
    item_type = d.get('item_type', '')
    if not rel_path or item_type not in ('patent', 'trademark', 'copyright'):
        return err('参数不完整：需要 rel_path 和 item_type (patent/trademark/copyright)', 400)

    src = _watch_source(rel_path)
    if not src:
        return err(f'文件不存在: {rel_path}', 404)

    # 1. 提取 PDF 文本
    text = extract_document_text(src)

    # 2. 分析文书类型和建议状态
    analysis = analyze_doc_text(text, item_type) or {}
    doc_type = analysis.get('doc_type', '其他')
    suggested_status = analysis.get('suggested_status')

    # 3. 优先使用前端传入的字段，否则从文本提取
    fields = d.get('fields') or extract_doc_fields(text, item_type, src.name)

    # 4. 创建记录
    with get_db() as db:
        if item_type == 'trademark':
            status = norm_tm_status(fields.get('status') or '已受理')
            tm_type = norm_tm_type(d.get('tm_type', '文字'))
            cur = db.execute("""INSERT INTO trademarks
                (name,app_no,reg_no,type,classes,goods_services,country,status,app_date,reg_date,renewal_date,owner,agent,notes,tags)
                VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)""",
                (fields.get('name', ''),
                 fields.get('app_no', ''),
                 fields.get('reg_no', ''),
                 tm_type,
                 fields.get('classes', ''),
                 d.get('goods_services', ''),
                 '中国',
                 status,
                 fields.get('app_date'),
                 None, None,
                 fields.get('owner', ''),
                 '', '', '[]'))
            new_id = cur.lastrowid
            record_status_change(db, 'trademark', new_id, None, status, '从待关联文件自动创建')

        elif item_type == 'patent':
            status = norm_patent_status(fields.get('status') or '已受理')
            p_type = norm_patent_type(d.get('p_type', '发明'))
            country = _normalize_country('中国')
            app_date = fields.get('app_date')
            current_year = calc_patent_current_year(
                country, app_date, None, None, None, p_type)
            next_fee_date = calc_patent_next_fee_date(
                country, app_date, None, current_year, None, p_type)
            cur = db.execute("""INSERT INTO patents
                (title,app_no,pub_no,grant_no,type,country,status,app_date,pub_date,grant_date,
                 inventors,owner,agent,ipc,next_fee_date,current_year,fee_entity,notes,tags)
                VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)""",
                (fields.get('title', ''),
                 fields.get('app_no', ''),
                 fields.get('pub_no', ''),
                 fields.get('grant_no', ''),
                 p_type, country, status,
                 app_date, None, None,
                 fields.get('inventors', ''),
                 fields.get('owner', ''),
                 '', fields.get('ipc', ''),
                 next_fee_date, current_year,
                 d.get('fee_entity', '无费减'),
                 '', '[]'))
            new_id = cur.lastrowid
            record_status_change(db, 'patent', new_id, None, status, '从待关联文件自动创建')

        elif item_type == 'copyright':
            cur = db.execute("""INSERT INTO copyrights
                (name,version,reg_no,reg_date,completion_date,owner,type,language,notes,tags)
                VALUES (?,?,?,?,?,?,?,?,?,?)""",
                (fields.get('name', ''),
                 fields.get('version', ''),
                 fields.get('reg_no', ''),
                 fields.get('reg_date'),
                 None,
                 fields.get('owner', ''),
                 '原始', '', '', '[]'))
            new_id = cur.lastrowid

        # 5. 将文件移入 uploads/ 并创建 document 关联记录
        stored = _store_document_source(db, src, src.name, item_type, new_id, move=False)
        db.execute("""INSERT INTO documents
                      (item_type,item_id,filename,original_name,file_size,mime_type,doc_type,description,file_hash)
                      VALUES (?,?,?,?,?,?,?,?,?)""",
                   (item_type, new_id, stored['filename'], src.name,
                    stored['file_size'], stored['mime_type'], doc_type, '', stored['file_hash']))

    src.unlink(missing_ok=True)
    return ok({
        'id': new_id,
        'item_type': item_type,
        'doc_type': doc_type,
        'suggested_status': suggested_status,
        'extracted_fields': fields,
    })


@app.route('/api/export/package', methods=['POST','OPTIONS'])
def export_package():
    """统一导出：Excel（+可选附件 ZIP）"""
    if request.method == 'OPTIONS': return ok()
    try:
        d = request.get_json(force=True, silent=True) or {}
        data_type       = d.get('type','patents')
        filters         = d.get('filters',{})
        columns         = d.get('columns',[])
        with_attach     = bool(d.get('with_attachments', False))
        attach_types    = d.get('attachment_types', [])  # empty = all types

        def flike(v): return f'%{v}%'
        def status_sql_clause(status_value):
            if isinstance(status_value, list):
                vals = [str(x).strip() for x in status_value if str(x).strip()]
                if not vals:
                    return '', []
                return f" IN ({','.join('?' * len(vals))})", vals
            if status_value:
                return "=?", [status_value]
            return '', []

        with get_db() as db:
            # ── Build query ──────────────────────────────────────────
            if data_type == 'patents':
                sql = "SELECT * FROM patents WHERE 1=1"; params = []
                q = filters.get('q','').strip()
                if q: sql += " AND (title LIKE ? OR app_no LIKE ? OR pub_no LIKE ? OR grant_no LIKE ? OR inventors LIKE ? OR owner LIKE ? OR ipc LIKE ?)"; params += [flike(q)]*7
                sc, sp = status_sql_clause(filters.get('status'))
                if sc: sql += f" AND status{sc}"; params += sp
                if filters.get('type'):           sql += " AND type=?";            params.append(filters['type'])
                if filters.get('country'):        sql += " AND country LIKE ?";    params.append(flike(filters['country']))
                if filters.get('owner'):          sql += " AND owner LIKE ?";      params.append(flike(filters['owner']))
                if filters.get('inventor'):       sql += " AND inventors LIKE ?";  params.append(flike(filters['inventor']))
                if filters.get('fee_entity'):     sql += " AND fee_entity=?";      params.append(filters['fee_entity'])
                if filters.get('agent'):          sql += " AND agent LIKE ?";      params.append(flike(filters['agent']))
                if filters.get('pub_no'):         sql += " AND pub_no LIKE ?";     params.append(flike(filters['pub_no']))
                if filters.get('grant_no'):       sql += " AND grant_no LIKE ?";   params.append(flike(filters['grant_no']))
                if filters.get('app_date_from'):  sql += " AND app_date>=?";       params.append(filters['app_date_from'])
                if filters.get('app_date_to'):    sql += " AND app_date<=?";       params.append(filters['app_date_to'])
                if filters.get('grant_date_from'):sql += " AND grant_date>=?";     params.append(filters['grant_date_from'])
                if filters.get('grant_date_to'):  sql += " AND grant_date<=?";     params.append(filters['grant_date_to'])
                if filters.get('next_fee_from'):  sql += " AND next_fee_date>=?";  params.append(filters['next_fee_from'])
                if filters.get('next_fee_to'):    sql += " AND next_fee_date<=?";  params.append(filters['next_fee_to'])
                if filters.get('year_from'):      sql += " AND current_year>=?";   params.append(int(filters['year_from']))
                if filters.get('year_to'):        sql += " AND current_year<=?";   params.append(int(filters['year_to']))
                today = date.today().isoformat(); fd = filters.get('fee_due','')
                if fd == 'overdue': sql += " AND next_fee_date IS NOT NULL AND next_fee_date<?"; params.append(today)
                elif fd in ('7','30','90'): sql += " AND next_fee_date IS NOT NULL AND next_fee_date>=? AND next_fee_date<=date(?,'+'||? ||' days')"; params += [today, today, fd]
                rows = [row_to_dict(r) for r in db.execute(sql + " ORDER BY app_date DESC", params).fetchall()]

            elif data_type == 'trademarks':
                sql = "SELECT * FROM trademarks WHERE 1=1"; params = []
                q = filters.get('q','').strip()
                if q: sql += " AND (name LIKE ? OR app_no LIKE ? OR reg_no LIKE ? OR owner LIKE ? OR classes LIKE ?)"; params += [flike(q)]*5
                sc, sp = status_sql_clause(filters.get('status'))
                if sc: sql += f" AND status{sc}"; params += sp
                if filters.get('type'):              sql += " AND type=?";               params.append(filters['type'])
                if filters.get('country'):           sql += " AND country LIKE ?";       params.append(flike(filters['country']))
                if filters.get('owner'):             sql += " AND owner LIKE ?";         params.append(flike(filters['owner']))
                if filters.get('classes'):           sql += " AND classes LIKE ?";       params.append(flike(filters['classes']))
                if filters.get('app_date_from'):     sql += " AND app_date>=?";          params.append(filters['app_date_from'])
                if filters.get('app_date_to'):       sql += " AND app_date<=?";          params.append(filters['app_date_to'])
                if filters.get('reg_date_from'):     sql += " AND reg_date>=?";          params.append(filters['reg_date_from'])
                if filters.get('reg_date_to'):       sql += " AND reg_date<=?";          params.append(filters['reg_date_to'])
                if filters.get('renewal_date_from'): sql += " AND renewal_date>=?";      params.append(filters['renewal_date_from'])
                if filters.get('renewal_date_to'):   sql += " AND renewal_date<=?";      params.append(filters['renewal_date_to'])
                rows = [row_to_dict(r) for r in db.execute(sql + " ORDER BY app_date DESC", params).fetchall()]

            else:  # copyrights
                sql = "SELECT * FROM copyrights WHERE 1=1"; params = []
                q = filters.get('q','').strip()
                if q: sql += " AND (name LIKE ? OR reg_no LIKE ? OR owner LIKE ?)"; params += [flike(q)]*3
                if filters.get('type'):               sql += " AND type=?";               params.append(filters['type'])
                if filters.get('owner'):              sql += " AND owner LIKE ?";         params.append(flike(filters['owner']))
                if filters.get('reg_date_from'):      sql += " AND reg_date>=?";          params.append(filters['reg_date_from'])
                if filters.get('reg_date_to'):        sql += " AND reg_date<=?";          params.append(filters['reg_date_to'])
                if filters.get('completion_date_from'):sql += " AND completion_date>=?";  params.append(filters['completion_date_from'])
                if filters.get('completion_date_to'): sql += " AND completion_date<=?";   params.append(filters['completion_date_to'])
                rows = [row_to_dict(r) for r in db.execute(sql + " ORDER BY reg_date DESC", params).fetchall()]

            if not rows:
                return err('筛选结果为空，请放宽条件', 404)

            # ── Build Excel ─────────────────────────────────────────
            import openpyxl as xl
            from openpyxl.styles import Font, PatternFill, Alignment
            from openpyxl.utils import get_column_letter
            wb = xl.Workbook(); ws = wb.active
            type_label = {'patents':'专利','trademarks':'商标','copyrights':'软著'}.get(data_type,'数据')
            ws.title = type_label
            all_flds = {k: l for k, l in ALL_FIELDS[data_type]}
            export_cols = columns if columns else list(all_flds.keys())
            headers = [all_flds.get(k, k) for k in export_cols]
            ws.append(headers)
            hfill = PatternFill(fill_type='solid', fgColor='1F4E79')
            for ci, h in enumerate(headers, 1):
                cell = ws.cell(1, ci); cell.value = h
                cell.font = Font(bold=True, color='FFFFFF', name='Arial', size=10)
                cell.fill = hfill
                cell.alignment = Alignment(horizontal='center', vertical='center')
                ws.column_dimensions[get_column_letter(ci)].width = max(12, min(35, len(h)*2+8))
            ws.row_dimensions[1].height = 26
            alt = PatternFill(fill_type='solid', fgColor='EBF3FB')
            for ri, row in enumerate(rows, 2):
                ws.append([row.get(k, '') for k in export_cols])
                for ci in range(1, len(export_cols)+1):
                    cell = ws.cell(ri, ci); cell.font = Font(name='Arial', size=10)
                    cell.alignment = Alignment(vertical='center')
                    if ri % 2 == 0: cell.fill = alt
            ws.freeze_panes = 'A2'
            excel_buf = BytesIO(); wb.save(excel_buf); excel_buf.seek(0)
            fname_base = f'{type_label}数据_{date.today().isoformat()}'

            # ── Attach documents if requested ────────────────────────
            if with_attach:
                item_type_key = {'patents':'patent','trademarks':'trademark','copyrights':'copyright'}[data_type]
                ids = [r['id'] for r in rows]
                if ids:
                    ph = ','.join('?'*len(ids))
                    dt_filter = ""
                    dt_params = list(ids)
                    if attach_types:
                        ph2 = ','.join('?'*len(attach_types))
                        dt_filter = f" AND doc_type IN ({ph2})"
                        dt_params += attach_types
                    docs = db.execute(
                        f"SELECT * FROM documents WHERE item_type=? AND item_id IN ({ph}){dt_filter} ORDER BY item_id, doc_type",
                        [item_type_key] + dt_params
                    ).fetchall()
                else:
                    docs = []

                if docs:
                    # Build id→name map for folder naming
                    id_to_name = {}
                    for r in rows:
                        n = r.get('title') or r.get('name') or ''
                        app_no = r.get('app_no') or r.get('reg_no') or ''
                        id_to_name[r['id']] = f"{app_no}_{n}"[:40].replace('/','-').replace('\\','-')

                    zip_buf = BytesIO()
                    with zipfile.ZipFile(zip_buf, 'w', zipfile.ZIP_DEFLATED) as zf:
                        # Add Excel
                        excel_buf.seek(0)
                        zf.writestr(f'{fname_base}.xlsx', excel_buf.read())
                        # Add attachments grouped by record
                        name_count = {}
                        for doc in docs:
                            doc = dict(doc)
                            src = UPLOAD_DIR / doc['filename']
                            if not src.exists(): continue
                            folder = id_to_name.get(doc['item_id'], str(doc['item_id']))
                            oname  = doc['original_name'] or doc['filename']
                            zpath  = f'attachments/{folder}/{oname}'
                            if zpath in name_count:
                                name_count[zpath] += 1
                                base, ext = os.path.splitext(oname)
                                zpath = f'attachments/{folder}/{base}_{name_count[zpath]}{ext}'
                            else:
                                name_count[zpath] = 0
                            zf.write(src, zpath)
                    zip_buf.seek(0)
                    return send_file(zip_buf, mimetype='application/zip',
                                     as_attachment=True, download_name=f'{fname_base}.zip')

            # No attachments – return Excel only
            excel_buf.seek(0)
            return send_file(excel_buf,
                             mimetype='application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
                             as_attachment=True, download_name=f'{fname_base}.xlsx')
    except Exception as ex:
        import traceback; traceback.print_exc()
        return err(f'导出失败: {ex}', 500)



@app.route('/api/documents/bulk-delete', methods=['POST','OPTIONS'])
def bulk_delete_documents():
    if request.method == 'OPTIONS': return ok()
    payload = request.get_json(silent=True) or {}
    if not isinstance(payload, dict):
        return err('请求参数格式错误', 400)
    raw_ids = payload.get('ids', [])
    if not isinstance(raw_ids, list):
        return err('ids 必须是数组', 400)
    try:
        ids = []
        for value in raw_ids:
            if isinstance(value, bool):
                raise ValueError
            item_id = int(value)
            if item_id <= 0:
                raise ValueError
            if item_id not in ids:
                ids.append(item_id)
    except (TypeError, ValueError, OverflowError):
        return err('附件 ID 必须是正整数', 400)
    if not ids: return err('no ids', 400)
    with get_db() as db:
        result = _delete_document_rows(db, ids)
    return ok(result)


# ══════════════ 回收站 ══════════════
def _trash_public_row(row):
    item = dict(row)
    try:
        payload = json.loads(item.pop('payload'))
    except Exception:
        payload = {}
    record = payload.get('record') or {}
    detail = ''
    if item['item_type'] in ('patent', 'trademark'):
        detail = record.get('app_no') or record.get('reg_no') or ''
    elif item['item_type'] == 'copyright':
        detail = record.get('reg_no') or record.get('version') or ''
    elif item['item_type'] == 'document':
        detail = record.get('doc_type') or record.get('original_name') or ''
    elif item['item_type'] == 'fee_payment':
        detail = f"缴费日期 {record.get('paid_date') or '—'}"
    elif item['item_type'] == 'status_history':
        detail = record.get('note') or record.get('operator') or ''
    item['type_label'] = TRASH_TYPE_LABELS.get(item['item_type'], item['item_type'])
    item['detail'] = detail
    item['related_count'] = (
        len(payload.get('documents', [])) +
        len(payload.get('status_history', [])) +
        len(payload.get('fee_payments', []))
    )
    return item


@app.route('/api/recycle-bin', methods=['GET','DELETE','OPTIONS'])
def recycle_bin_api():
    if request.method == 'OPTIONS':
        return ok()
    if request.method == 'GET':
        item_type = request.args.get('type', '').strip()
        query = request.args.get('q', '').strip()
        with get_db() as db:
            sql = "SELECT * FROM recycle_bin WHERE 1=1"
            params = []
            if item_type:
                sql += " AND item_type=?"
                params.append(item_type)
            if query:
                sql += " AND name LIKE ?"
                params.append(f'%{query}%')
            rows = db.execute(sql + " ORDER BY deleted_at DESC,id DESC", params).fetchall()
        return ok([_trash_public_row(row) for row in rows])

    # Emptying is deliberately available only through this explicit manual request.
    with get_db() as db:
        rows = db.execute("SELECT * FROM recycle_bin ORDER BY id").fetchall()
        files_removed = 0
        for row in rows:
            files_removed += _purge_trash_entry(db, row)
    return ok({'deleted': len(rows), 'files_removed': files_removed})


@app.route('/api/recycle-bin/<int:trash_id>/restore', methods=['POST','OPTIONS'])
def restore_recycle_bin_item(trash_id):
    if request.method == 'OPTIONS':
        return ok()
    with get_db() as db:
        row = db.execute("SELECT * FROM recycle_bin WHERE id=?", (trash_id,)).fetchone()
        if not row:
            return err('回收站记录不存在', 404)
        try:
            restored = _restore_trash_entry(db, row)
        except (ValueError, sqlite3.IntegrityError) as exc:
            return err(str(exc), 409)
        db.execute("DELETE FROM recycle_bin WHERE id=?", (trash_id,))
    return ok(restored)


@app.route('/api/recycle-bin/<int:trash_id>', methods=['DELETE','OPTIONS'])
def purge_recycle_bin_item(trash_id):
    if request.method == 'OPTIONS':
        return ok()
    with get_db() as db:
        row = db.execute("SELECT * FROM recycle_bin WHERE id=?", (trash_id,)).fetchone()
        if not row:
            return err('回收站记录不存在', 404)
        files_removed = _purge_trash_entry(db, row)
    return ok({'deleted': 1, 'files_removed': files_removed})


@app.route('/api/diagnostic')
def diagnostic():
    """诊断端点：返回服务器基本信息（仅本地访问）"""
    if request.remote_addr not in ('127.0.0.1', '::1'):
        return err('仅允许本地访问', 403)
    import sys
    return ok({
        'base_dir': str(BASE_DIR),
        'static_dir': str(STATIC_DIR),
        'index_exists': (STATIC_DIR/'index.html').exists(),
        'db_exists': DB_PATH.exists(),
        'python': sys.version,
        'port': WEB_PORT,
        'app_version': APP_VERSION,
    })


register_alert_center(app, globals())

if __name__=='__main__':
    print("="*50); print("  知产管家 · 网页端正在启动..."); print("="*50)
    init_db()
    print(f"🌐 请在浏览器打开: http://127.0.0.1:{WEB_PORT}")
    print("="*50)
    from waitress import serve
    serve(app, host='127.0.0.1', port=WEB_PORT, threads=8)