# -*- coding: utf-8 -*-
"""校园德育量化登记系统 · 桌面应用（本地运行，数据存飞书多维表格）"""
import json, os, hashlib, time, threading, webbrowser, base64, io, uuid, re, sys
import contextlib, tempfile, platform, datetime
from urllib.parse import unquote
from concurrent.futures import ThreadPoolExecutor
import requests
from flask import Flask, request, jsonify, send_from_directory, Response
from openpyxl import Workbook, load_workbook
from openpyxl.styles import Font as XlFont
from openpyxl.worksheet.datavalidation import DataValidation

# 桌面外置模式：优先加载与 app.py 同目录的 paper_ocr.py（exe 内置版本可能滞后于热更的 app.py）
try:
    import importlib.util as _ilu
    import sys as _isys
    _ext_pocr = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'paper_ocr.py')
    if os.path.exists(_ext_pocr) and 'paper_ocr' not in _isys.modules:
        _pspec = _ilu.spec_from_file_location('paper_ocr', _ext_pocr)
        _pmod = _ilu.module_from_spec(_pspec)
        _isys.modules['paper_ocr'] = _pmod
        _pspec.loader.exec_module(_pmod)
        del _pspec, _pmod
    del _ilu, _isys, _ext_pocr
except Exception:
    pass
from paper_ocr import TEMPLATES as PAPER_TEMPLATES, analyze_paper, public_templates as paper_public_templates, engine_info as paper_engine_info, image_from_bytes as paper_ocr_image_from_bytes, PaperError
from paper_ocr import engine_installed as paper_engine_installed, reload_engine as paper_engine_reload, ensure_engine_path as paper_ensure_engine_path, ocr_available as paper_ocr_available
try:
    from paper_ocr import rule_candidates as paper_rule_candidates
except ImportError:
    paper_rule_candidates = None   # 桌面内置旧 paper_ocr 无此函数 → 本地候选推荐降级，其余功能不受影响

BASE = os.path.dirname(os.path.abspath(__file__))
CONFIG_PATH = os.path.join(BASE, 'config.json')
GRADE_ORDER = ['初一', '初二', '初三', '高一', '高二', '高三']
PAPER_DEPTS = ('纪检部', '艺体部', '宿管部', '劳动部', '学习部', '礼仪部')
PAPER_DIR = os.path.join(BASE, 'data', 'paper_scans')
os.makedirs(PAPER_DIR, exist_ok=True)
_PAPER_LOCK = threading.Lock()
PAPER_ITEM_FIELD = '纸表项目'       # A-G / 空：纸表模板项目，便于追溯与统计
PAPER_CAND_FIELD = '纸表候选ID'     # 批次内稳定行键：candidate_id|班级，用于崩溃后续办幂等
_PAPER_DEDUP_CACHE = {'key': '', 'rows': []}
_PAPER_CAP_CACHE = {'ts': 0.0, 'ok': False, 'name': '', 'err': ''}
_CONFIG_LOCK = threading.Lock()

def load_cfg():
    with open(CONFIG_PATH, encoding='utf-8') as f:
        return json.load(f)

def save_cfg(cfg):
    with _CONFIG_LOCK:
        with open(CONFIG_PATH, 'w', encoding='utf-8') as f:
            json.dump(cfg, f, ensure_ascii=False, indent=2)

def sha(s):
    return hashlib.sha256((s or '').encode('utf-8')).hexdigest()

app = Flask(__name__, static_folder=os.path.join(BASE, 'static'), static_url_path='/static')

# 全局 HTTP 会话：复用 TCP/TLS 连接，避免每次调用飞书都重新握手
HTTP = requests.Session()

@app.after_request
def no_cache_html(resp):
    if resp.mimetype == 'text/html':
        resp.headers['Cache-Control'] = 'no-cache, no-store, must-revalidate'
        resp.headers['Pragma'] = 'no-cache'
    return resp

_token = {'v': None, 'exp': 0}
_tlock = threading.Lock()

def get_token():
    with _tlock:
        cfg = load_cfg()
        if _token['v'] and time.time() < _token['exp'] - 120:
            return _token['v']
        r = HTTP.post('https://open.feishu.cn/open-apis/auth/v3/tenant_access_token/internal',
                          json={'app_id': cfg['app_id'], 'app_secret': cfg['app_secret']}, timeout=15)
        d = r.json()
        if d.get('code') != 0 or not d.get('tenant_access_token'):
            raise RuntimeError('获取飞书令牌失败: ' + json.dumps(d, ensure_ascii=False))
        _token['v'] = d['tenant_access_token']
        _token['exp'] = time.time() + int(d.get('expire', 7200))
        return _token['v']

def bh():
    return {'Authorization': 'Bearer ' + get_token(), 'Content-Type': 'application/json'}

def fe_url(tid, extra=''):
    cfg = load_cfg()
    return f"https://open.feishu.cn/open-apis/bitable/v1/apps/{cfg['app_token']}/tables/{tid}/records" + extra

def list_records_raw(tid):
    out, pt = [], None
    while True:
        extra = '?page_size=500' + (('&page_token=' + pt) if pt else '')
        d = HTTP.get(fe_url(tid, extra), headers=bh(), timeout=25).json()
        if d.get('code') != 0:
            raise RuntimeError('读取记录失败: ' + json.dumps(d, ensure_ascii=False))
        data = d.get('data') or {}
        out += data.get('items') or []
        if data.get('has_more'):
            pt = data.get('page_token')
        else:
            break
    return out

# ---------- 飞书表级读缓存（P0-3 性能优化 2026-11-05） ----------
# 读多写少：列表类接口加 TTL 缓存；写操作失效由下方 HTTP.post/put/delete 补丁自动完成
# （从请求 URL 提取 table_id，成功返回后清该表缓存），无需在每个写接口里手工清。
# 回退开关：环境变量 DEYU_CACHE_OFF=1 启动后全部退回实时拉取。
_fe_cache = {}  # tid -> {'v': rows, 'exp': ts}
_TABLE_URL_RE = re.compile(r'/bitable/v\d+/apps/[A-Za-z0-9]+/tables/([A-Za-z0-9]+)')

def fe_list_cached(tid, ttl=45):
    """带 TTL 的飞书全表读取；异常由调用方按原逻辑兜底。"""
    if not tid or os.environ.get('DEYU_CACHE_OFF') == '1':
        return list_records_raw(tid)
    now = time.time()
    ent = _fe_cache.get(tid)
    if ent and now < ent['exp']:
        return ent['v']
    rows = list_records_raw(tid)
    _fe_cache[tid] = {'v': rows, 'exp': now + ttl}
    return rows

def fe_invalidate(tid):
    if tid:
        _fe_cache.pop(tid, None)

def _fe_write_wrap(orig):
    def _w(url, *a, **kw):
        r = orig(url, *a, **kw)
        try:
            m = _TABLE_URL_RE.search(str(url))
            if m:
                fe_invalidate(m.group(1))
        except Exception:
            pass
        return r
    return _w

HTTP.post = _fe_write_wrap(HTTP.post)
HTTP.put = _fe_write_wrap(HTTP.put)
HTTP.delete = _fe_write_wrap(HTTP.delete)

# ---------- 操作日志 ----------
def write_log(action, target='', detail=''):
    """异步写操作日志：立即返回，不阻塞接口响应；detail 可传函数（在后台线程取值）"""
    try:
        cfg = load_cfg()
        tid = cfg.get('tid_logs')
        if not tid:
            return
        if callable(detail):
            try:
                detail = detail()
            except Exception:
                detail = ''
        fields = {
            '时间': int(time.time() * 1000),
            '动作': str(action)[:50],
            '对象': str(target or '')[:200],
            '详情': str(detail or '')[:500],
        }
        def _post():
            try:
                HTTP.post(fe_url(tid), headers=bh(), json={'fields': fields}, timeout=15)
            except Exception:
                pass
        threading.Thread(target=_post, daemon=True).start()
    except Exception:
        pass

def record_brief(rid):
    """读取记录摘要用于日志展示，失败返回 rid"""
    try:
        cfg = load_cfg()
        d = HTTP.get(fe_url(cfg['tid_records']) + '/' + rid, headers=bh(), timeout=15).json()
        f = (d.get('data') or {}).get('record', {}).get('fields') or {}
        return (str(f.get('年级') or '') + str(f.get('班级') or '') + '·' +
                str(f.get('事项细项') or '') + '(' + str(f.get('分值') or '') + '分)')
    except Exception:
        return rid

@app.route('/api/logs')
def get_logs():
    cfg = load_cfg()
    tid = cfg.get('tid_logs')
    out = []
    if tid:
        try:
            for item in fe_list_cached(tid, 45):   # 原先每次实时拉飞书，实测 2.6~2.7s；写日志时 _fe_write_wrap 会自动失效
                f = item.get('fields') or {}
                ts = num(f.get('时间'))
                out.append({
                    'time': time.strftime('%Y-%m-%d %H:%M', time.localtime(ts / 1000)) if ts else '',
                    '_ts': ts,
                    'action': f.get('动作') or '', 'target': f.get('对象') or '',
                    'detail': f.get('详情') or '',
                })
        except Exception:
            pass
    out.sort(key=lambda x: -x['_ts'])
    return jsonify(ok=True, logs=out[:200])

def norm_record(item):
    f = item.get('fields') or {}
    ts = num(f.get('检查时间'))
    tstr = time.strftime('%Y-%m-%d %H:%M', time.localtime(ts / 1000)) if ts else ''
    sc = f.get('分值')
    try:
        sc = float(sc)
    except (TypeError, ValueError):
        sc = 0
    return {
        'rid': item.get('record_id'),
        'time': tstr, '_ts': ts or 0,
        'grade': f.get('年级') or '', 'cls': f.get('班级') or '',
        'dept': f.get('部门') or '', 'item': f.get('事项细项') or '',
        'type': f.get('类型') or '', 'score': int(sc) if sc == int(sc) else sc,
        'desc': f.get('事实描述') or '', 'user': f.get('使用人') or '', 'student': f.get('学生') or '',
        'studentno': rt(f.get('学号')) or '',
        'src': f.get('登记来源') or '',
        'appeal_result': rt(f.get('申诉结果')) or '',
        'building': rt(f.get('楼栋')) or '', 'room': rt(f.get('房间')) or '', 'bed': rt(f.get('床位')) or '',
        'area': rt(f.get('包干区')) or '',
        'paper_batch': rt(f.get('纸表批次')) or '', 'paper_template': rt(f.get('纸表模板')) or '',
        'paper_cell': rt(f.get('纸表来源格')) or '',
        'status': f.get('状态') or '有效', 'cancel_reason': f.get('消分原因') or '',
    }

def norm_user(item):
    f = item.get('fields') or {}
    return {'rid': item.get('record_id'), 'name': f.get('姓名') or '',
            'grade': f.get('年级') or '', 'identity': f.get('身份') or '',
            'dept': rt(f.get('部门')) or '', 'grp': rt(f.get('组别')) or '',
            'cls': rt(f.get('班级')) or '', 'role': rt(f.get('权限角色')) or ''}

def get_appeals_raw():
    return fe_list_cached(load_cfg()['tid_appeals'], 45)

def rt(v):
    """飞书富文本/文本统一取字符串"""
    if isinstance(v, list) and v and isinstance(v[0], dict):
        return ''.join(str(x.get('text') or '') for x in v)
    return v

def num(v, default=0):
    """飞书数字字段可能返回字符串（如 '1789742031998'），统一安全转数值"""
    try:
        return float(v)
    except (TypeError, ValueError):
        return default

# ---------- AI 视觉服务（纸表云端复核） ----------
AI_PROVIDERS = {
    'deepseek': {'name': 'DeepSeek', 'base_url': 'https://api.deepseek.com/v1', 'model': 'deepseek-flash'},
    'zhipu': {'name': '智谱 BigModel', 'base_url': 'https://open.bigmodel.cn/api/paas/v4', 'model': 'glm-4.6v-flash'},
    'dashscope': {'name': '阿里百炼', 'base_url': 'https://dashscope.aliyuncs.com/compatible-mode/v1', 'model': 'qwen-vl-ocr'},
    'custom': {'name': 'OpenAI 兼容服务', 'base_url': '', 'model': ''},
}
_AI_HTTP = requests.Session()
_AI_HTTP.trust_env = False
_AI_DAILY = {'date': '', 'count': 0}

def _ai_cfg():
    cfg = load_cfg()
    c = cfg.get('ai_vision') or {}
    out = {
        'enabled': bool(c.get('enabled')),
        'provider': c.get('provider') or 'deepseek',
        'base_url': (c.get('base_url') or '').strip(),
        'model': (c.get('model') or '').strip(),
        'fallback_model': (c.get('fallback_model') or '').strip(),
        'api_key': (c.get('api_key') or '').strip(),
        'timeout_sec': max(5, min(120, int(c.get('timeout_sec') or 30))),
        'max_tokens': max(200, min(4000, int(c.get('max_tokens') or 1200))),
        'max_cells': max(1, min(12, int(c.get('max_cells') or 4))),
        'daily_limit': max(0, min(10000, int(c.get('daily_limit') or 200))),
        'privacy_mode': c.get('privacy_mode') or 'crop',
        'thinking': c.get('thinking') or 'disabled',
    }
    if out['privacy_mode'] not in ('crop', 'full'):
        out['privacy_mode'] = 'crop'
    if out['thinking'] not in ('disabled', 'low', 'enabled'):
        out['thinking'] = 'disabled'
    return cfg, out

def _ai_key_mask(key):
    if not key:
        return ''
    if len(key) <= 10:
        return key[:2] + '****'
    return key[:4] + '****' + key[-4:]

def _ai_public(c):
    p = AI_PROVIDERS.get(c['provider']) or {}
    return {
        'enabled': c['enabled'], 'provider': c['provider'], 'provider_name': p.get('name') or c['provider'],
        'base_url': c['base_url'], 'model': c['model'], 'fallback_model': c['fallback_model'],
        'timeout_sec': c['timeout_sec'], 'max_tokens': c['max_tokens'], 'max_cells': c['max_cells'],
        'daily_limit': c['daily_limit'], 'privacy_mode': c['privacy_mode'], 'thinking': c['thinking'],
        'key_set': bool(c['api_key']), 'key_mask': _ai_key_mask(c['api_key']),
    }

def _ai_valid_base(url):
    return bool(re.match(r'^https?://[^\s]+$', url or ''))

def _ai_payload(c, prompt, image_b64=None, max_tokens=None):
    content = [{'type': 'text', 'text': prompt}]
    if image_b64:
        content.append({'type': 'image_url', 'image_url': {'url': 'data:image/jpeg;base64,' + image_b64}})
    payload = {
        'model': c['model'],
        'messages': [{'role': 'user', 'content': content}],
        'temperature': 0,
        'max_tokens': max_tokens or c['max_tokens'],
        'stream': False,
    }
    thinking = c.get('thinking') or 'disabled'
    if thinking == 'disabled':
        payload['thinking'] = {'type': 'disabled'}
    elif thinking == 'low':
        payload['thinking'] = {'type': 'enabled'}
        payload['reasoning_effort'] = 'low'
    else:
        payload['thinking'] = {'type': 'enabled'}
    model = (c.get('model') or '').lower()
    if 'deepseek' in model or c.get('provider') == 'deepseek':
        payload['response_format'] = {'type': 'json_object'}
    return payload

def _ai_chat(c, prompt, image_b64=None, max_tokens=None):
    if not _ai_valid_base(c.get('base_url')):
        raise RuntimeError('Base URL 无效')
    if not c.get('api_key'):
        raise RuntimeError('API Key 未配置')
    if not c.get('model'):
        raise RuntimeError('模型 ID 未配置')
    url = c['base_url'].rstrip('/') + '/chat/completions'
    r = _AI_HTTP.post(url, headers={
        'Authorization': 'Bearer ' + c['api_key'], 'Content-Type': 'application/json'
    }, json=_ai_payload(c, prompt, image_b64, max_tokens), timeout=c['timeout_sec'])
    try:
        d = r.json()
    except Exception:
        d = {'raw': r.text[:300]}
    if r.status_code != 200:
        msg = ((d.get('error') or {}).get('message') if isinstance(d.get('error'), dict) else '') or str(d)[:180]
        raise RuntimeError('HTTP %s：%s' % (r.status_code, msg))
    ch = (d.get('choices') or [{}])[0]
    msg = ch.get('message') or {}
    content = (msg.get('content') or '').strip()
    if ch.get('finish_reason') == 'length' and not content:
        raise RuntimeError('模型输出为空：思考内容超出 max_tokens，请在 AI 服务里关闭思考')
    return content, d.get('usage') or {}, r.status_code

def _ai_json(content):
    if not content:
        return {}
    m = re.search(r'\{[\s\S]*\}', content)
    if not m:
        return {}
    try:
        return json.loads(m.group(0))
    except Exception:
        return {}

def _ai_count():
    today = time.strftime('%Y-%m-%d')
    if _AI_DAILY.get('date') != today:
        _AI_DAILY['date'] = today
        _AI_DAILY['count'] = 0
    _AI_DAILY['count'] += 1
    return _AI_DAILY['count']

@app.route('/api/ai/config', methods=['POST'])
def ai_config_get():
    b = request.get_json(force=True) or {}
    if not check_pw('admin', b.get('admin_password')):
        return jsonify(ok=False, msg='管理口令验证失败'), 401
    cfg, c = _ai_cfg()
    return jsonify(ok=True, config=_ai_public(c), providers=AI_PROVIDERS)

@app.route('/api/ai/config', methods=['PUT'])
def ai_config_save():
    b = request.get_json(force=True) or {}
    if not check_pw('admin', b.get('admin_password')):
        return jsonify(ok=False, msg='管理口令验证失败'), 401
    cfg, old = _ai_cfg()
    c = dict(old)
    provider = (b.get('provider') or old['provider']).strip()
    if provider not in AI_PROVIDERS:
        return jsonify(ok=False, msg='不支持的服务商'), 400
    c['provider'] = provider
    c['enabled'] = bool(b.get('enabled'))
    c['base_url'] = (b.get('base_url') or '').strip()[:220]
    c['model'] = (b.get('model') or '').strip()[:100]
    c['fallback_model'] = (b.get('fallback_model') or '').strip()[:100]
    if not _ai_valid_base(c['base_url']):
        return jsonify(ok=False, msg='Base URL 必须以 http:// 或 https:// 开头'), 400
    if not c['model']:
        return jsonify(ok=False, msg='模型 ID 必填'), 400
    try:
        c['timeout_sec'] = max(5, min(120, int(b.get('timeout_sec') or old['timeout_sec'])))
        c['max_tokens'] = max(200, min(4000, int(b.get('max_tokens') or old['max_tokens'])))
        c['max_cells'] = max(1, min(12, int(b.get('max_cells') or old['max_cells'])))
        c['daily_limit'] = max(0, min(10000, int(b.get('daily_limit') or old['daily_limit'])))
    except (TypeError, ValueError):
        return jsonify(ok=False, msg='超时 / tokens / 数量上限必须是数字'), 400
    c['privacy_mode'] = b.get('privacy_mode') if b.get('privacy_mode') in ('crop', 'full') else old['privacy_mode']
    c['thinking'] = b.get('thinking') if b.get('thinking') in ('disabled', 'low', 'enabled') else old['thinking']
    key = (b.get('api_key') or '').strip()
    key_changed = False
    if key == '__CLEAR__':
        c['api_key'] = ''
        key_changed = True
    elif key:
        if len(key) < 8:
            return jsonify(ok=False, msg='API Key 长度异常'), 400
        c['api_key'] = key
        key_changed = True
    if c['enabled'] and not c['api_key']:
        return jsonify(ok=False, msg='启用前请先配置 API Key'), 400
    cfg['ai_vision'] = c
    save_cfg(cfg)
    write_log('AI服务配置', c['provider'] + ' / ' + c['model'],
              ('Key已更新；' if key_changed else 'Key未修改；') + ('启用' if c['enabled'] else '停用'))
    return jsonify(ok=True, config=_ai_public(c))

@app.route('/api/ai/test', methods=['POST'])
def ai_test():
    b = request.get_json(force=True) or {}
    if not check_pw('admin', b.get('admin_password')):
        return jsonify(ok=False, msg='管理口令验证失败'), 401
    cfg, saved = _ai_cfg()
    c = dict(saved)
    if b.get('provider'): c['provider'] = b['provider']
    if b.get('base_url'): c['base_url'] = (b['base_url'] or '').strip()
    if b.get('model'): c['model'] = (b['model'] or '').strip()
    if b.get('thinking'): c['thinking'] = b['thinking']
    key = (b.get('api_key') or '').strip()
    if key:
        c['api_key'] = key
    if not _ai_valid_base(c['base_url']):
        return jsonify(ok=False, msg='Base URL 无效'), 400
    if not c['api_key']:
        return jsonify(ok=False, msg='API Key 未配置'), 400
    if not c['model']:
        return jsonify(ok=False, msg='模型 ID 未配置'), 400
    t0 = time.time()
    try:
        content, usage, status = _ai_chat(c, '只输出 JSON：{"ok":true}', max_tokens=80)
        return jsonify(ok=True, model=c['model'], latency=round(time.time() - t0, 2),
                       usage=usage, preview=content[:120])
    except Exception as exc:
        return jsonify(ok=False, msg=str(exc)[:300], latency=round(time.time() - t0, 2)), 502

def upload_media(filename, data_bytes):
    """上传附件到飞书，返回 file_token；失败抛异常（调用方负责提示，不再静默丢附件）"""
    cfg = load_cfg()
    url = 'https://open.feishu.cn/open-apis/drive/v1/medias/upload_all'
    files = {'file': (filename, data_bytes, 'image/jpeg')}
    data = {'file_name': filename, 'parent_type': 'bitable_image',
            'parent_node': cfg['app_token'], 'size': str(len(data_bytes))}
    d = HTTP.post(url, headers={'Authorization': 'Bearer ' + get_token()}, data=data, files=files, timeout=120).json()
    if d.get('code') != 0:
        raise RuntimeError('飞书素材上传失败(%s): %s' % (d.get('code'), (d.get('msg') or '')[:100]))
    tk = (d.get('data') or {}).get('file_token')
    if not tk:
        raise RuntimeError('飞书素材上传未返回 file_token')
    return tk

def norm_appeal(item):
    f = item.get('fields') or {}
    t = num(f.get('提交时间'))
    tstr = time.strftime('%Y-%m-%d %H:%M', time.localtime(t / 1000)) if t else ''
    atts = [{'name': rt(x.get('name')) or '附件', 'url': x.get('url') or ''}
            for x in (f.get('附件') or []) if isinstance(x, dict)]
    return {'arid': item.get('record_id'), 'rid': rt(f.get('关联记录')) or '',
            'appellant': rt(f.get('申诉人')) or '', 'reason': rt(f.get('申诉理由')) or '',
            'time': tstr, 'status': rt(f.get('状态')) or '待处理', 'opinion': rt(f.get('处理意见')) or '',
            'attachments': atts}

_cred_cache = {'v': None, 'exp': 0}
_users_cache = {'v': None, 'exp': 0}

def get_users_cached():
    """用户表缓存 60s：登录查部门/教师名单用"""
    now = time.time()
    if _users_cache['v'] is None or now > _users_cache['exp']:
        try:
            _users_cache['v'] = [norm_user(i) for i in list_records_raw(load_cfg()['tid_users'])]
        except Exception:
            _users_cache['v'] = []
        _users_cache['exp'] = now + 60
    return _users_cache['v']

def get_creds():
    """凭据表缓存 60s：角色 -> 密码哈希"""
    now = time.time()
    if _cred_cache['v'] is None or now > _cred_cache['exp']:
        rows = {}
        try:
            tid = load_cfg().get('tid_creds')
            if tid:
                for it in list_records_raw(tid):
                    f = it.get('fields') or {}
                    rows[rt(f.get('角色')) or ''] = rt(f.get('密码哈希')) or ''
        except Exception:
            rows = {}
        _cred_cache['v'] = rows
        _cred_cache['exp'] = now + 60
    return _cred_cache['v']

ROLE_OF_LEVEL = {'reg': '学生会', 'admin': '管理员', 'bzr': '班主任'}
GRADE_ROLES = {'高一': '年级管理·高一', '高二': '年级管理·高二', '高三': '年级管理·高三'}
USER_ROLES = ('年级管理', '普通教师')
_user_fields_ok = False


def ensure_user_fields():
    """用户表缺失「权限角色」字段自动补建（单选：年级管理/普通教师）。
    年级管理登录必须显式带这个值，空值视为未开通。"""
    global _user_fields_ok
    if _user_fields_ok:
        return True
    try:
        cfg = load_cfg()
        tid = cfg.get('tid_users')
        if not tid:
            return False
        have = set(fe_field_names(tid))
        if '权限角色' not in have:
            fe_create_field(tid, {
                'field_name': '权限角色', 'type': 3,
                'property': {'options': [{'name': '年级管理'}, {'name': '普通教师'}]}})
        _user_fields_ok = True
        return True
    except Exception:
        return False

def check_pw_grade(pw, grade):
    """只校验「指定年级」的管理口令。三个年级口令允许相同，靠年级而不是口令区别人。"""
    role = GRADE_ROLES.get((grade or '').strip())
    if not role or not pw:
        return False
    return sha(pw) == (get_creds().get(role) or '')


def _hdr_grade():
    """前端登录后每个请求带 X-GRADE；多个年级口令相同时用它定位年级。
    HTTP 头只允许 Latin-1，前端对「高一/高二/高三」做了 encodeURIComponent，这里统一还原。"""
    try:
        return unquote((request.headers.get('X-GRADE') or '').strip())
    except Exception:
        return ''


def _hdr_pw():
    """同上：X-PW 口令可能含中文，前端 encodeURIComponent 后这里还原。"""
    try:
        return unquote((_hdr_pw() or '').strip())
    except Exception:
        return ''


def check_pw_any(pw, prefer_grade=''):
    """管理员 / 年级管理统一校验（分年级独立口令，允许三个年级设同一口令）。
    返回 ('admin','') 或 ('grade','高一') 或 None；管理员口令永远优先命中。
    prefer_grade 用于多年级口令相同时指定年级（默认取字典顺序第一个，即高一）。"""
    if not pw:
        return None
    h = sha(pw)
    creds = get_creds()
    ah = creds.get('管理员')
    if ah and h == ah:
        return ('admin', '')
    cfg = load_cfg()
    if cfg.get('admin_pw_hash') and h == cfg['admin_pw_hash']:
        return ('admin', '')
    sg = (prefer_grade or '').strip()
    if sg:
        role = GRADE_ROLES.get(sg)
        if role and creds.get(role) and h == creds[role]:
            return ('grade', sg)
    for g, role in GRADE_ROLES.items():
        gh = creds.get(role)
        if gh and h == gh:
            return ('grade', g)
    return None

def grade_of_cls(cls):
    """从班级名推断年级（如 '高二 3 班' → '高二'），匹配不到返回 ''"""
    cls = (cls or '').strip()
    for g in GRADE_ROLES:
        if cls.startswith(g):
            return g
    return ''

def check_pw(level, pw):
    role = ROLE_OF_LEVEL.get(level)
    h = get_creds().get(role) if role else None
    if not h:
        cfg = load_cfg()
        key = 'admin_pw_hash' if level == 'admin' else 'reg_pw_hash'
        return sha(pw) == cfg.get(key)
    if sha(pw) == h:
        return True
    # 管理员口令可作为登记级别通行（管理员全功能）
    if level != 'admin':
        ah = get_creds().get('管理员')
        if ah and sha(pw) == ah:
            return True
    return False

def need_auth(level):
    pw = _hdr_pw()
    if not check_pw(level, pw):
        return jsonify(ok=False, msg='口令验证失败，请重新输入' + level + '口令'), 401

# ---------- 页面 ----------
@app.route('/')
def index():
    return send_from_directory(os.path.join(BASE, 'templates'), 'index.html')

# ---------- 认证 ----------
@app.route('/api/login', methods=['POST'])
def login():
    b = request.get_json(force=True)
    level = b.get('level') or b.get('role'); pw = b.get('password')
    if level not in ('reg', 'admin', 'bzr', 'grade'):
        write_log('登录失败', '参数错误', 'level=' + repr(level))
        return jsonify(ok=False, msg='参数错误'), 400
    if level != 'grade' and not check_pw(level, pw):
        return jsonify(ok=False, msg='口令不正确'), 401
    if level == 'grade':
        name = (b.get('name') or '').strip()
        if not name:
            return jsonify(ok=False, msg='请选择姓名'), 400
        found = False
        teacher_grade = ''
        teacher_role = ''
        for u in get_users_cached():
            if u['name'] == name and u['identity'] == '老师':
                teacher_grade = u.get('grade') or ''
                teacher_role = u.get('role') or ''
                found = True
                break
        if not found:
            return jsonify(ok=False, msg='该姓名不在教师名单中'), 401
        if teacher_grade not in GRADE_ROLES:
            return jsonify(ok=False, msg='该教师未配置年级（请联系管理员在用户表填写「年级」为 高一/高二/高三）'), 400
        if teacher_role != '年级管理':
            write_log('登录拒绝', name, '年级管理：权限角色=' + (teacher_role or '空'))
            return jsonify(ok=False, msg='该教师未开通年级管理权限（请在用户表把「权限角色」设为「年级管理」）'), 403
        # 口令：管理员口令可代登录；否则必须命中该教师「本年级」口令（三个年级可设同一口令）
        if not check_pw('admin', pw) and not check_pw_grade(pw, teacher_grade):
            other = check_pw_any(pw)
            if other and other[0] == 'grade' and other[1] != teacher_grade:
                return jsonify(ok=False, msg='口令为「' + other[1] + '」年级管理口令，与该教师年级（' + teacher_grade + '）不符'), 401
            return jsonify(ok=False, msg='口令不正确'), 401
        return jsonify(ok=True, role='年级管理', name=name, grade=teacher_grade)
    if level == 'reg':
        name = (b.get('name') or '').strip()
        if not name:
            return jsonify(ok=False, msg='请选择登记人'), 400
        dept = ''
        for u in get_users_cached():
            if u['name'] == name:
                dept = u.get('dept') or ''
                break
        return jsonify(ok=True, role='学生会', name=name, dept=dept)
    if level == 'bzr':
        name = (b.get('name') or '').strip()
        if not name:
            return jsonify(ok=False, msg='请选择姓名'), 400
        cls = ''
        found = False
        for u in get_users_cached():
            if u['name'] == name and u['identity'] == '老师':
                cls = u.get('cls') or ''
                found = True
                break
        if not found:
            return jsonify(ok=False, msg='该姓名不在教师名单中'), 401
        if not cls:
            return jsonify(ok=False, msg='该教师未绑定班级，请联系管理员在用户表填写'), 400
        return jsonify(ok=True, role='班主任', name=name, cls=cls)
    return jsonify(ok=True, role='管理员')

@app.route('/api/password', methods=['POST'])
def change_pw():
    b = request.get_json(force=True)
    if not check_pw('admin', b.get('admin_password')):
        return jsonify(ok=False, msg='管理口令验证失败'), 401
    level = b.get('level'); new = b.get('new_password')
    if level == 'grade':
        grade = b.get('grade')
        if grade not in GRADE_ROLES:
            return jsonify(ok=False, msg='请指定年级（高一/高二/高三）'), 400
        role = GRADE_ROLES[grade]
    elif level in ('reg', 'admin', 'bzr'):
        role = ROLE_OF_LEVEL[level]
    else:
        role = None
    if not role or not new or len(new) < 4:
        return jsonify(ok=False, msg='新口令至少 4 位'), 400
    h = sha(new)
    cfg = load_cfg()
    tid_c = cfg.get('tid_creds')
    target = None
    if tid_c:
        try:
            for it in list_records_raw(tid_c):
                f = it.get('fields') or {}
                if rt(f.get('角色')) == role:
                    target = it.get('record_id'); break
        except Exception:
            pass
    if target:
        d = HTTP.put(fe_url(tid_c) + '/' + target, headers=bh(),
                         json={'fields': {'密码哈希': h, '更新时间': int(time.time() * 1000)}}, timeout=20).json()
        if d.get('code') != 0:
            return jsonify(ok=False, msg='写入凭据表失败: ' + str(d.get('msg'))), 500
    elif tid_c and level == 'grade':
        # 年级口令首次设置：凭据表自动建行
        d = HTTP.post(fe_url(tid_c), headers=bh(),
                      json={'fields': {'角色': role, '密码哈希': h, '更新时间': int(time.time() * 1000)}}, timeout=20).json()
        if d.get('code') != 0:
            return jsonify(ok=False, msg='凭据表新建行失败: ' + str(d.get('msg'))), 500
    else:
        cfg['admin_pw_hash' if level == 'admin' else 'reg_pw_hash'] = h
        save_cfg(cfg)
    _cred_cache['v'] = None
    write_log('修改口令', role + ' 口令', '口令已更新')
    return jsonify(ok=True)

# ---------- 用户表 ----------
@app.route('/api/users')
def get_users():
    # 原先每次实时拉飞书（实测 1.1~1.4s）；用户增改走 HTTP.post/put，_fe_write_wrap 会自动失效缓存
    users = [norm_user(i) for i in fe_list_cached(load_cfg()['tid_users'], 45)]
    return jsonify(ok=True, users=users)

@app.route('/api/users', methods=['POST'])
def add_user():
    b = request.get_json(force=True)
    if not check_pw('admin', b.get('admin_password')):
        return jsonify(ok=False, msg='管理口令验证失败'), 401
    name = (b.get('name') or '').strip()
    if not name:
        return jsonify(ok=False, msg='姓名必填'), 400
    cfg = load_cfg()
    ensure_user_fields()
    role = (b.get('role') or '').strip()
    fields = {'姓名': name, '年级': b.get('grade') or '', '身份': b.get('identity') or '', '部门': b.get('dept') or '', '组别': b.get('grp') or '', '班级': b.get('cls') or ''}
    if role or 'role' in b:
        fields['权限角色'] = role or None
    d = HTTP.post(fe_url(cfg['tid_users']), headers=bh(), json={'fields': fields}, timeout=20).json()
    if d.get('code') != 0:
        return jsonify(ok=False, msg='写入失败: ' + str(d.get('msg'))), 500
    write_log('新增用户', name, str(b.get('grade') or '') + '·' + str(b.get('identity') or '') + '·' + str(b.get('dept') or '') + ('·' + role if role else ''))
    return jsonify(ok=True, rid=d['data']['record']['record_id'])

@app.route('/api/users/<rid>', methods=['PUT'])
def upd_user(rid):
    b = request.get_json(force=True)
    if not check_pw('admin', b.get('admin_password')):
        return jsonify(ok=False, msg='管理口令验证失败'), 401
    name = (b.get('name') or '').strip()
    if not name:
        return jsonify(ok=False, msg='姓名必填'), 400
    cfg = load_cfg()
    ensure_user_fields()
    role = (b.get('role') or '').strip()
    fields = {'姓名': name, '年级': b.get('grade') or '', '身份': b.get('identity') or '',
              '部门': b.get('dept') or '', '组别': b.get('grp') or '', '班级': b.get('cls') or ''}
    if role or 'role' in b:
        fields['权限角色'] = role or None
    d = HTTP.put(fe_url(cfg['tid_users']) + '/' + rid, headers=bh(), json={'fields': fields}, timeout=20).json()
    if d.get('code') != 0:
        return jsonify(ok=False, msg='更新失败: ' + str(d.get('msg'))), 500
    write_log('修改用户', name, str(b.get('grade') or '') + '·' + str(b.get('identity') or '') + '·' + str(b.get('dept') or '') + ('·' + role if role else ''))
    _users_cache['v'] = None
    return jsonify(ok=True)

@app.route('/api/users/<rid>', methods=['DELETE'])
def del_user(rid):
    b = request.get_json(silent=True) or {}
    if not check_pw('admin', _hdr_pw() or b.get('admin_password')):
        return jsonify(ok=False, msg='管理口令验证失败'), 401
    cfg = load_cfg()
    d = HTTP.delete(fe_url(cfg['tid_users']) + '/' + rid, headers=bh(), timeout=20).json()
    if d.get('code') == 0:
        write_log('删除用户', 'rid=' + rid)
        _users_cache['v'] = None
    return jsonify(ok=d.get('code') == 0, msg=d.get('msg'))

# ---------- 班级字典 ----------
@app.route('/api/classes')
def get_classes():
    cfg = load_cfg()
    tid = cfg.get('tid_classes')
    classes = {}
    if tid:
        try:
            for item in fe_list_cached(tid, 300):
                f = item.get('fields') or {}
                grade = f.get('年级'); cls = f.get('班级')
                if grade and cls:
                    classes.setdefault(grade, [])
                    if cls not in classes[grade]:
                        classes[grade].append(cls)
        except Exception:
            pass
    if not classes:
        classes = cfg.get('classes', {})
    for g in GRADE_ORDER:
        classes.setdefault(g, [])
    return jsonify(ok=True, classes=classes, source=('feishu' if classes else 'config'))

# ---------- 检查记录 ----------
@app.route('/api/records')
def get_records():
    items = fe_list_cached(load_cfg()['tid_records'], 45)
    recs = [norm_record(i) for i in items]
    recs.sort(key=lambda x: x['_ts'], reverse=True)
    return jsonify(ok=True, records=recs)

_record_fields_ok = False
def ensure_record_fields():
    """检查记录表缺失字段自动补建(学号/包干区/纸表识别批次)"""
    global _record_fields_ok
    if _record_fields_ok:
        return True
    try:
        cfg = load_cfg()
        have = set(fe_field_names(cfg['tid_records']))
        for name in ('学号', '包干区', '纸表批次', '纸表模板', '纸表来源格', '识别置信度', '申诉结果', PAPER_ITEM_FIELD, PAPER_CAND_FIELD):
            if name not in have:
                fe_create_field(cfg['tid_records'], {'field_name': name, 'type': 1})
        _record_fields_ok = True
        return True
    except Exception:
        return False

# ---------- 重复登记软提示(查重) ----------
_dedup_cache = {'ts': 0.0, 'rows': []}

def _dedup_recent():
    """最近 2 小时记录缓存(60s TTL),查重毫秒级完成,不拖慢提交"""
    now = time.time()
    if _dedup_cache['rows'] and now - _dedup_cache['ts'] < 60:
        return _dedup_cache['rows']
    try:
        cut = int((now - 2 * 3600) * 1000)
        rows = []
        for it in list_records_raw(load_cfg()['tid_records']):
            r = norm_record(it)
            if (r.get('_ts') or 0) >= cut:
                rows.append(r)
        _dedup_cache['ts'] = now
        _dedup_cache['rows'] = rows
    except Exception:
        pass
    return _dedup_cache['rows']

@app.route('/api/records/check', methods=['POST'])
def check_record_dups():
    """提交前查重:返回与入参一一对应的疑似重复记录(软提示,不阻断)"""
    b = request.get_json(force=True)
    if not check_pw('reg', b.get('reg_password')):
        return jsonify(ok=False, msg='登记口令验证失败'), 401
    items = b.get('records') or []
    win_min = num(load_cfg().get('dedup_window_min'), 60)
    if win_min <= 0 or not items:
        return jsonify(ok=True, dups=[[] for _ in items], window=win_min)
    win_ms = win_min * 60 * 1000
    now_ms = int(time.time() * 1000)
    recent = _dedup_recent()
    dups = []
    for it in items:
        hits = []
        if (it.get('type') or '扣分') != '扣分':
            dups.append(hits)
            continue
        cls = (it.get('cls') or '').strip()
        student = (it.get('student') or '').strip()
        sname = (it.get('studentno') or '').strip()
        item = (it.get('item') or '').strip()
        for r in recent:
            if (r.get('status') or '有效') not in ('有效', ''):
                continue
            if r.get('type') != '扣分':
                continue
            if (r.get('cls') or '') != cls:
                continue
            if abs((r.get('_ts') or 0) - now_ms) > win_ms:
                continue
            if student or sname:
                rs = (r.get('student') or '').strip()
                rn = (r.get('studentno') or '').strip()
                if not ((student and rs == student) or (sname and rn and rn == sname)):
                    continue
            else:
                if (r.get('item') or '').strip() != item:
                    continue
            hits.append({'time': r.get('time'), 'item': r.get('item'), 'score': r.get('score'),
                         'user': r.get('user'), 'dept': r.get('dept'), 'student': r.get('student')})
        hits.sort(key=lambda h: h.get('time') or '')
        dups.append(hits[:5])
    return jsonify(ok=True, dups=dups, window=win_min)

@app.route('/api/records', methods=['POST'])
def add_record():
    b = request.get_json(force=True)
    if not check_pw('reg', b.get('reg_password')):
        return jsonify(ok=False, msg='登记口令验证失败'), 401
    labels = {'grade': '年级', 'cls': '班级', 'dept': '登记部门', 'item': '事项细项', 'user': '使用人'}
    missing = [labels[k] for k in ('grade', 'cls', 'dept', 'item', 'user') if not (b.get(k) or '').strip()]
    if missing:
        return jsonify(ok=False, msg='请完整填写：' + '、'.join(missing)), 400
    try:
        score = float(b.get('score'))
    except (TypeError, ValueError):
        return jsonify(ok=False, msg='分值必须是数字'), 400
    ensure_record_fields()
    cfg = load_cfg()
    if b.get('time_str'):
        tt = time.strptime(b['time_str'], '%Y-%m-%d %H:%M')
        ts = int(time.mktime(tt) * 1000)
    else:
        ts = int(time.time() * 1000)
    fields = {
        '检查时间': ts,
        '年级': b.get('grade'), '班级': (b.get('cls') or '').strip(),
        '部门': b.get('dept'), '事项细项': (b.get('item') or '').strip(),
        '类型': b.get('type') or '扣分', '分值': abs(score) if (b.get('type') != '加分') else abs(score),
        '事实描述': (b.get('desc') or '').strip(), '使用人': (b.get('user') or '').strip(),
        '登记来源': '桌面应用',
    }
    if b.get('type') == '加分':
        fields['分值'] = abs(score)
    else:
        fields['分值'] = -abs(score)
    for k, col in (('building', '楼栋'), ('room', '房间'), ('bed', '床位'), ('student', '学生'), ('studentno', '学号')):
        v = (b.get(k) or '').strip()
        if v:
            fields[col] = v[:30]
    d = HTTP.post(fe_url(cfg['tid_records']), headers=bh(), json={'fields': fields}, timeout=20).json()
    if d.get('code') != 0:
        return jsonify(ok=False, msg='写入失败: ' + str(d.get('msg'))), 500
    return jsonify(ok=True, rid=d['data']['record']['record_id'])

# ---------- 包干区登记 ----------
_areas_cache = {'v': None, 'exp': 0}

def get_areas_cached():
    """包干区表缓存 60s：序号 → 区域/班级/班主任（年级从班级名前两字推导）"""
    now = time.time()
    if _areas_cache['v'] is None or now > _areas_cache['exp']:
        rows = []
        cfg = load_cfg()
        tid = cfg.get('tid_areas')
        if not tid:
            # 老安装包 config 缺 tid_areas → 按表名找已有表并回写配置
            tid = find_table_id_by_name('包干区')
            if tid:
                cfg['tid_areas'] = tid
                save_cfg(cfg)
        if tid:
            try:
                for it in list_records_raw(tid):
                    f = it.get('fields') or {}
                    no = rt(f.get('序号')) or ''
                    cls = rt(f.get('负责班级')) or ''
                    if no and cls:
                        rows.append({'no': no, 'area': rt(f.get('包干范围')) or '',
                                     'cls': cls, 'grade': cls[:2], 'head': rt(f.get('班主任')) or ''})
            except Exception:
                pass
        rows.sort(key=lambda x: (len(x['no']), x['no']))
        _areas_cache['v'] = rows
        _areas_cache['exp'] = now + 60
    return _areas_cache['v']

@app.route('/api/areas')
def get_areas():
    return jsonify(ok=True, areas=get_areas_cached())

def _area_expire_ts(dur):
    """整改提醒时长: am=今天12:00(已过顺延明天) / 2h=+2小时 / school=今天17:30(已过顺延明天)"""
    now = time.time()
    if dur == '2h':
        return now + 7200
    hh, mm = (12, 0) if dur == 'am' else (17, 30)
    ts = time.mktime(time.strptime(time.strftime('%Y-%m-%d') + ' %02d:%02d' % (hh, mm), '%Y-%m-%d %H:%M'))
    return ts + 86400 if ts <= now else ts

@app.route('/api/area_checkin', methods=['POST'])
def area_checkin():
    b = request.get_json(force=True)
    if not check_pw('reg', b.get('reg_password')):
        return jsonify(ok=False, msg='登记口令验证失败'), 401
    no = (b.get('no') or '').strip()
    item = (b.get('item') or '').strip()
    user = (b.get('user') or '').strip()
    desc = (b.get('desc') or '').strip()
    if not no or not item or not user or not desc:
        return jsonify(ok=False, msg='序号、事项细项、使用人、事实描述必填'), 400
    area = next((a for a in get_areas_cached() if a['no'].lower() == no.lower()), None)
    if not area:
        return jsonify(ok=False, msg='包干区序号「' + no + '」不存在，请核对'), 400
    try:
        score = float(b.get('score'))
    except (TypeError, ValueError):
        return jsonify(ok=False, msg='分值必须是数字'), 400
    ensure_record_fields()
    cfg = load_cfg()
    if b.get('time_str'):
        try:
            ts = int(time.mktime(time.strptime(b['time_str'], '%Y-%m-%d %H:%M')) * 1000)
        except ValueError:
            return jsonify(ok=False, msg='检查时间格式应为 2026-10-28 09:30'), 400
    else:
        ts = int(time.time() * 1000)
    # ① 写扣分记录（年级/班级/班主任信息全部来自包干区表，不可更改；年级按班级名前缀推断兜底，防止包干区表年级字段脏数据影响筛选）
    fields = {
        '检查时间': ts,
        '年级': grade_of_cls(area['cls']) or area['grade'], '班级': area['cls'],
        '部门': (b.get('dept') or '劳动部').strip()[:10],
        '事项细项': item[:40], '类型': '扣分', '分值': -abs(score),
        '事实描述': desc[:500], '使用人': user[:20],
        '登记来源': '包干区', '包干区': area['no'][:10],
    }
    d = HTTP.post(fe_url(cfg['tid_records']), headers=bh(), json={'fields': fields}, timeout=20).json()
    if d.get('code') != 0:
        return jsonify(ok=False, msg='写入失败: ' + str(d.get('msg'))), 500
    rid = d['data']['record']['record_id']
    write_log('包干区登记', '#%s %s' % (area['no'], area['cls'][:14]), '%s %s分' % (item[:20], -abs(score)))
    # ② 整改提醒（可选）→ 公告表 → 班牌「特殊事件」卡，到期自动消失
    fix_result = None
    if b.get('need_fix'):
        dur = b.get('dur') or 'am'
        if dur not in ('am', '2h', 'school'):
            dur = 'am'
        ensure_notice_fields()
        # 防骚扰: 今日已发过同班级且未过期的整改提醒 → 需前端确认后 force 重提
        # (通知内容不再带包干区编号, 按 标题+班级范围+当日+未过期 判断)
        if not b.get('force'):
            day0 = int(time.mktime(time.strptime(time.strftime('%Y-%m-%d'), '%Y-%m-%d')) * 1000)
            now_ms = int(time.time() * 1000)
            try:
                for it in list_records_raw(cfg['tid_notices']):
                    f = it.get('fields') or {}
                    if (rt(f.get('标题')) or '') != '🧹 包干区整改提醒':
                        continue
                    if area['cls'] not in (rt(f.get('范围')) or ''):
                        continue
                    if num(f.get('发布时间'), 0) >= day0 and num(f.get('过期时间'), 0) > now_ms:
                        return jsonify(ok=False, need_confirm=True, rid=rid,
                                       msg=area['cls'] + ' 今日已收到过整改提醒，仍要再次发送吗？')
            except Exception:
                pass
        exp_ms = int(_area_expire_ts(dur) * 1000)
        nfields = {
            '标题': '🧹 包干区整改提醒',
            # 班牌卡片空间有限且已精准投递到负责班级, 不再重复包干区位置
            '内容': '检查发现' + desc + '，请立即整改！',
            '发布人': user[:20], '发布时间': int(time.time() * 1000),
            '范围': area['cls'], '过期时间': exp_ms,
        }
        d2 = HTTP.post(fe_url(cfg['tid_notices']), headers=bh(), json={'fields': nfields}, timeout=20).json()
        if d2.get('code') != 0:
            write_log('包干区整改提醒失败', '#%s %s' % (area['no'], area['cls'][:14]), str(d2.get('msg')))
            fix_result = 'ok记录已写入，但通知推送失败: ' + str(d2.get('msg'))
        else:
            write_log('包干区整改提醒', '#%s %s' % (area['no'], area['cls'][:14]),
                      '推送至 ' + area['cls'] + '，至 ' + time.strftime('%m-%d %H:%M', time.localtime(exp_ms / 1000)) + ' 自动消失')
            fix_result = '已推送至 ' + area['cls'] + ' 班牌，' + time.strftime('%H:%M', time.localtime(exp_ms / 1000)) + ' 自动消失'
    return jsonify(ok=True, rid=rid, cls=area['cls'], fix=fix_result)

@app.route('/api/records/<rid>', methods=['PUT'])
def edit_record(rid):
    b = request.get_json(force=True) or {}
    if not check_pw('admin', _hdr_pw() or b.get('admin_password')):
        return jsonify(ok=False, msg='管理口令验证失败'), 401
    fields = {}
    if b.get('score') is not None:
        try:
            v = float(b['score'])
            fields['分值'] = -abs(v) if b.get('type') == '扣分' else abs(v)
        except (TypeError, ValueError):
            return jsonify(ok=False, msg='分值必须是数字'), 400
    if b.get('type'): fields['类型'] = b['type']
    if b.get('desc') is not None: fields['事实描述'] = b['desc']
    if not fields:
        return jsonify(ok=False, msg='没有要修改的内容'), 400
    cfg = load_cfg()
    brief = record_brief(rid)
    d = HTTP.put(fe_url(cfg['tid_records']) + '/' + rid, headers=bh(), json={'fields': fields}, timeout=20).json()
    if d.get('code') == 0:
        write_log('改分', brief, ', '.join(k + '=' + str(v) for k, v in fields.items()))
    return jsonify(ok=d.get('code') == 0, msg=d.get('msg'))

@app.route('/api/records/<rid>', methods=['DELETE'])
def del_record(rid):
    if not check_pw('admin', _hdr_pw()):
        return jsonify(ok=False, msg='管理口令验证失败'), 401
    cfg = load_cfg()
    brief = record_brief(rid)
    d = HTTP.delete(fe_url(cfg['tid_records']) + '/' + rid, headers=bh(), timeout=20).json()
    if d.get('code') == 0:
        write_log('删除记录', brief)
    return jsonify(ok=d.get('code') == 0, msg=d.get('msg'))

# ---------- 细则字典 ----------
_rules_fields_ok = False
def ensure_rules_fields():
    """细则表缺失「适用年级」字段自动补建(单选:通用/高一/高二/高三)，旧数据无值视为通用"""
    global _rules_fields_ok
    if _rules_fields_ok:
        return True
    try:
        cfg = load_cfg()
        have = set(fe_field_names(cfg['tid_rules']))
        if '适用年级' not in have:
            fe_create_field(cfg['tid_rules'], {
                'field_name': '适用年级', 'type': 3,
                'property': {'options': [{'name': '通用'}, {'name': '高一'}, {'name': '高二'}, {'name': '高三'}]}})
        _rules_fields_ok = True
        return True
    except Exception:
        return False

def rule_grade_param(b, auth):
    """解析请求里的适用年级参数。返回 (grade_val, err_msg)
    - 管理员：可传 ''(通用)/通用/高一/高二/高三
    - 年级管理：强制为本年级，忽略传入值"""
    role, ggrade = auth
    val = (b.get('grade') or '').strip()
    if role == 'grade':
        return ggrade, None
    if val in ('', '通用'):
        return '', None
    if val in GRADE_ROLES:
        return val, None
    return None, '适用年级参数错误'

@app.route('/api/rules')
def get_rules():
    ensure_rules_fields()
    items = fe_list_cached(load_cfg()['tid_rules'], 300)
    rules = []
    for i in items:
        f = i.get('fields') or {}
        try:
            sc = float(f.get('默认分值'))
        except (TypeError, ValueError):
            sc = 0
        rules.append({'rid': i.get('record_id'), 'item': f.get('事项细项') or '',
                      'dept': f.get('归属部门') or '', 'type': f.get('类型') or '',
                      'grade': rt(f.get('适用年级')) or '',
                      'score': int(sc) if sc == int(sc) else sc})
    rules.sort(key=lambda x: (x['dept'], x['type'], -abs(x['score']) if isinstance(x['score'], (int, float)) else 0))
    return jsonify(ok=True, rules=rules)

@app.route('/api/rules', methods=['POST'])
def add_rule():
    b = request.get_json(force=True)
    auth = check_pw_any(_hdr_pw() or b.get('admin_password'), _hdr_grade())
    if not auth:
        return jsonify(ok=False, msg='口令验证失败（需管理口令或年级管理口令）'), 401
    item = (b.get('item') or '').strip()
    if not item or not b.get('dept'):
        return jsonify(ok=False, msg='细项与部门必填'), 400
    gval, gerr = rule_grade_param(b, auth)
    if gerr:
        return jsonify(ok=False, msg=gerr), 400
    ensure_rules_fields()
    cfg = load_cfg()
    fields = {'事项细项': item, '归属部门': b.get('dept'), '类型': b.get('type') or '扣分',
              '默认分值': int(b.get('score') or 1)}
    if gval:
        fields['适用年级'] = gval
    d = HTTP.post(fe_url(cfg['tid_rules']), headers=bh(), json={'fields': fields}, timeout=20).json()
    if d.get('code') != 0:
        return jsonify(ok=False, msg='写入失败: ' + str(d.get('msg'))), 500
    who = '年级管理·' + auth[1] if auth[0] == 'grade' else '管理员'
    write_log('新增细则', str(b.get('dept') or '') + '·' + item,
              str(b.get('type') or '扣分') + ' ' + str(b.get('score') or 1) + '分 · 适用:' + (gval or '通用') + ' · ' + who)
    return jsonify(ok=True, rid=d['data']['record']['record_id'])

@app.route('/api/rules/<rid>', methods=['PUT'])
def upd_rule(rid):
    b = request.get_json(force=True)
    auth = check_pw_any(_hdr_pw() or b.get('admin_password'), _hdr_grade())
    if not auth:
        return jsonify(ok=False, msg='口令验证失败（需管理口令或年级管理口令）'), 401
    role, ggrade = auth
    item = (b.get('item') or '').strip()
    if not item or not b.get('dept'):
        return jsonify(ok=False, msg='细项与部门必填'), 400
    cfg = load_cfg()
    # 校验原细则归属：年级管理只能改本年级细则
    old_grade = ''
    if role == 'grade':
        try:
            od = HTTP.get(fe_url(cfg['tid_rules']) + '/' + rid, headers=bh(), timeout=15).json()
            old_grade = rt(((od.get('data') or {}).get('record') or {}).get('fields', {}).get('适用年级')) or ''
        except Exception:
            old_grade = ''
        if old_grade and old_grade != ggrade:
            return jsonify(ok=False, msg='「' + old_grade + '」细则由「' + old_grade + '」年级管理维护，你只能修改本年级或通用细则'), 403
        # 年级管理：适用年级保持原值（通用细则改完仍是通用，本年级细则仍是本年级，不允许改动适用范围）
        gval, gerr = old_grade, None
    else:
        gval, gerr = rule_grade_param(b, auth)
    if gerr:
        return jsonify(ok=False, msg=gerr), 400
    ensure_rules_fields()
    fields = {'事项细项': item, '归属部门': b.get('dept'), '类型': b.get('type') or '扣分',
              '默认分值': int(b.get('score') or 1)}
    if gval:
        fields['适用年级'] = gval
    else:
        fields['适用年级'] = None   # 单选清空 → 通用
    d = HTTP.put(fe_url(cfg['tid_rules']) + '/' + rid, headers=bh(), json={'fields': fields}, timeout=20).json()
    if d.get('code') != 0:
        return jsonify(ok=False, msg='更新失败: ' + str(d.get('msg'))), 500
    who = '年级管理·' + ggrade if role == 'grade' else '管理员'
    write_log('修改细则', str(b.get('dept') or '') + '·' + item,
              str(b.get('type') or '扣分') + ' ' + str(b.get('score') or 1) + '分 · 适用:' + (gval or '通用') + ' · ' + who)
    return jsonify(ok=True)

@app.route('/api/rules/<rid>', methods=['DELETE'])
def del_rule(rid):
    body = request.get_json(silent=True) or {}
    auth = check_pw_any(_hdr_pw() or body.get('admin_password'), _hdr_grade())
    if not auth:
        return jsonify(ok=False, msg='口令验证失败（需管理口令或年级管理口令）'), 401
    role, ggrade = auth
    cfg = load_cfg()
    if role == 'grade':
        old_grade = ''
        try:
            od = HTTP.get(fe_url(cfg['tid_rules']) + '/' + rid, headers=bh(), timeout=15).json()
            old_grade = rt(((od.get('data') or {}).get('record') or {}).get('fields', {}).get('适用年级')) or ''
        except Exception:
            old_grade = ''
        if old_grade and old_grade != ggrade:
            return jsonify(ok=False, msg='「' + old_grade + '」细则由「' + old_grade + '」年级管理维护，你只能删除本年级或通用细则'), 403
    d = HTTP.delete(fe_url(cfg['tid_rules']) + '/' + rid, headers=bh(), timeout=20).json()
    if d.get('code') == 0:
        who = '年级管理·' + ggrade if role == 'grade' else '管理员'
        write_log('删除细则', 'rid=' + rid, who)
    return jsonify(ok=d.get('code') == 0, msg=d.get('msg'))

# ---------- 申诉与消分 ----------
@app.route('/api/appeals')
def get_appeals():
    # 原先这里实时拉全量记录表（当前 1259 条），实测 5.9~6.5s，年级页申诉卡一直转圈；
    # 记录表已有 45s 读缓存，申诉数据本身也走缓存，这里必须共用
    recs = {r['rid']: r for r in (norm_record(i) for i in fe_list_cached(load_cfg()['tid_records'], 45))}
    appeals = []
    for a in (norm_appeal(i) for i in get_appeals_raw()):
        a['record'] = recs.get(a['rid'])
        appeals.append(a)
    appeals.sort(key=lambda x: x['status'] != '待处理')
    return jsonify(ok=True, appeals=appeals)

@app.route('/api/appeals', methods=['POST'])
def add_appeal():
    b = request.get_json(force=True)
    rid = b.get('rid'); appellant = (b.get('appellant') or '').strip()
    reason = (b.get('reason') or '').strip()
    if not rid or not appellant or not reason:
        return jsonify(ok=False, msg='关联记录、申诉人、申诉理由必填'), 400
    # 幂等防重闸：同记录已有「待处理」申诉 → 拒绝；同记录+同申诉人+同理由 2 分钟内 → 竞态拦截
    try:
        now_ms = int(time.time() * 1000)
        for a in get_appeals_raw():
            af = a.get('fields') or {}
            if rt(af.get('关联记录')) != rid:
                continue
            st = rt(af.get('状态')) or '待处理'
            if st == '待处理':
                return jsonify(ok=False, msg='该记录已有待处理申诉（申诉人：' + (rt(af.get('申诉人')) or '?') + '），请耐心等待处理，勿重复提交'), 409
            t = num(af.get('提交时间'))
            if (rt(af.get('申诉人')) == appellant and rt(af.get('申诉理由')) == reason
                    and t and 0 <= now_ms - t < 2 * 60 * 1000):
                return jsonify(ok=False, msg='刚刚已提交过相同申诉，请勿重复提交'), 409
    except Exception:
        pass   # 查重异常不阻断主流程（宁可放过不可误伤）
    cfg = load_cfg()
    fields = {'关联记录': rid, '申诉人': appellant, '申诉理由': reason,
              '提交时间': int(time.time() * 1000), '状态': '待处理'}
    atts = b.get('attachments') or []
    att_errs = []
    toks = []
    if isinstance(atts, list) and atts:
        import base64 as _b64
        for i, a in enumerate(atts[:3]):
            if not isinstance(a, str) or not a:
                att_errs.append('附件%d未生成（图片可能仍在压缩中）' % (i + 1))
                continue
            try:
                data = _b64.b64decode(a.split(',', 1)[-1])
            except Exception:
                att_errs.append('附件%d数据异常' % (i + 1))
                continue
            try:
                tk = upload_media('申诉附件%d.jpg' % (i + 1), data)
                toks.append({'file_token': tk})
            except Exception as e:
                att_errs.append('附件%d上传失败：%s' % (i + 1, str(e)[:90]))
    if toks:
        fields['附件'] = toks
    d = HTTP.post(fe_url(cfg['tid_appeals']), headers=bh(), json={'fields': fields}, timeout=20).json()
    if d.get('code') != 0:
        return jsonify(ok=False, msg='提交失败: ' + str(d.get('msg'))), 500
    write_log('发起申诉', appellant, '关联 ' + rid[:20] + (' · 附' + str(len(toks)) + '个附件' if toks else ''))
    HTTP.put(fe_url(cfg['tid_records']) + '/' + rid, headers=bh(),
                 json={'fields': {'状态': '申诉中'}}, timeout=20)
    resp = {'ok': True, 'arid': d['data']['record']['record_id']}
    if att_errs:
        # 申诉已提交成功，但附件上传失败必须明确告知（不再静默丢附件）
        resp['attachment_error'] = '；'.join(att_errs)
    return jsonify(resp)

@app.route('/api/appeals/<arid>', methods=['POST'])
def handle_appeal(arid):
    b = request.get_json(force=True)
    auth = check_pw_any(_hdr_pw() or b.get('admin_password'), _hdr_grade())
    if not auth:
        return jsonify(ok=False, msg='口令验证失败（需管理口令或年级管理口令）'), 401
    role, ggrade = auth
    result = b.get('result')
    if result not in ('已维持', '已更正', '已消分', '已撤销'):
        return jsonify(ok=False, msg='处理结果参数错误'), 400
    opinion = (b.get('opinion') or '').strip()
    cfg = load_cfg()
    d = HTTP.get(fe_url(cfg['tid_appeals']) + '/' + arid, headers=bh(), timeout=20).json()
    rid = rt((d.get('data') or {}).get('record', {}).get('fields', {}).get('关联记录'))
    if not rid:
        return jsonify(ok=False, msg='申诉记录异常：未找到关联记录'), 500
    if role == 'grade':
        # 年级管理只能处理关联记录属于本年级的申诉
        rd = HTTP.get(fe_url(cfg['tid_records']) + '/' + rid, headers=bh(), timeout=15).json()
        rgrade = rt(((rd.get('data') or {}).get('record') or {}).get('fields', {}).get('年级')) or ''
        if rgrade != ggrade:
            return jsonify(ok=False, msg='该申诉涉及记录属于「' + (rgrade or '未知年级') + '」，仅限本年级申诉处理'), 403
    upd = {'状态': result, '处理意见': opinion}
    HTTP.put(fe_url(cfg['tid_appeals']) + '/' + arid, headers=bh(), json={'fields': upd}, timeout=20)
    rec_fields = {}
    if result == '已维持':
        rec_fields = {'状态': '有效'}
    elif result == '已更正':
        rec_fields = {'状态': '有效', '处理意见': opinion}
        try:
            ns = float(b.get('new_score'))
            rec_fields['分值'] = -abs(ns) if b.get('rec_type') != '加分' else abs(ns)
        except (TypeError, ValueError):
            pass
    elif result == '已消分':
        rec_fields = {'状态': '已消分', '消分原因': '申诉' + result + '：' + opinion}
    elif result == '已撤销':
        rec_fields = {'状态': '已撤销', '消分原因': '申诉' + result + '：' + opinion}
    # 裁定结果回写记录，班主任在记录查询里可见（谁裁的、什么意见）
    rec_fields['申诉结果'] = ('申诉' + result + '：' + opinion)[:180]
    HTTP.put(fe_url(cfg['tid_records']) + '/' + rid, headers=bh(), json={'fields': rec_fields}, timeout=20)
    who = '年级管理·' + ggrade if role == 'grade' else '管理员'
    write_log('申诉处理', record_brief(rid), '结果：' + result + (('；' + opinion) if opinion else '') + ' · ' + who)
    return jsonify(ok=True)

@app.route('/api/records/<rid>/cancel', methods=['POST'])
def cancel_score(rid):
    b = request.get_json(force=True)
    if not check_pw('admin', b.get('admin_password')):
        return jsonify(ok=False, msg='管理口令验证失败'), 401
    reason = (b.get('reason') or '管理员消分').strip()
    cfg = load_cfg()
    brief = record_brief(rid)
    d = HTTP.put(fe_url(cfg['tid_records']) + '/' + rid, headers=bh(),
                     json={'fields': {'状态': '已消分', '消分原因': reason}}, timeout=20).json()
    if d.get('code') == 0:
        write_log('消分', brief, '原因：' + reason)
    return jsonify(ok=d.get('code') == 0, msg=d.get('msg'))

# ---------- 批量写入 ----------
@app.route('/api/records/batch', methods=['POST'])
def add_records_batch():
    b = request.get_json(force=True)
    if not check_pw('reg', b.get('reg_password')):
        return jsonify(ok=False, msg='登记口令验证失败'), 401
    recs = b.get('records') or []
    if not recs:
        return jsonify(ok=False, msg='没有可提交的记录'), 400
    ensure_record_fields()
    cfg = load_cfg()
    fields_list = []
    for r in recs:
        try:
            score = float(r.get('score'))
        except (TypeError, ValueError):
            return jsonify(ok=False, msg='存在非数字分值'), 400
        for k in ('grade', 'cls', 'dept', 'item'):
            if not (r.get(k) or '').strip():
                return jsonify(ok=False, msg='存在未填写完整的行（缺 ' + k + '）'), 400
        v = -abs(score) if r.get('type') != '加分' else abs(score)
        f = {
            '检查时间': int(time.time() * 1000),
            '年级': r['grade'], '班级': r['cls'], '部门': r['dept'],
            '事项细项': r['item'], '类型': r.get('type') or '扣分', '分值': v,
            '事实描述': (r.get('note') or '').strip(), '学生': (r.get('student') or '').strip(), '学号': (r.get('studentno') or '').strip(), '使用人': (r.get('user') or '').strip(),
            '登记来源': '桌面应用',
        }
        for k, col in (('building', '楼栋'), ('room', '房间'), ('bed', '床位')):
            vv = (r.get(k) or '').strip()
            if vv:
                f[col] = vv[:30]
        fields_list.append({'fields': f})
    ok_n = 0
    for i in range(0, len(fields_list), 500):
        chunk = fields_list[i:i + 500]
        d = HTTP.post(fe_url(cfg['tid_records']) + '/batch_create', headers=bh(), json={'records': chunk}, timeout=40).json()
        if d.get('code') != 0:
            return jsonify(ok=False, msg='批量写入失败: ' + str(d.get('msg')), done=ok_n), 500
        ok_n += len(chunk)
    return jsonify(ok=True, count=ok_n)

# ---------- 纸表识别 ----------
def _paper_batch_path(batch_id):
    if not re_full_batch_id(batch_id):
        return None
    return os.path.join(PAPER_DIR, batch_id + '.json')

def re_full_batch_id(batch_id):
    import re
    return bool(re.fullmatch(r'PP\d{8}-\d{6}-[0-9A-F]{4,8}', str(batch_id or '')))

def _paper_load_batch(batch_id):
    path = _paper_batch_path(batch_id)
    if not path or not os.path.exists(path):
        return None
    try:
        with open(path, encoding='utf-8') as f:
            return json.load(f)
    except Exception:
        return None

def _paper_save_batch(batch):
    """原子写：唯一临时名，避免 AI/确认并发时互相截断；失败必须抛错，不能静默吞。"""
    path = _paper_batch_path(batch.get('batch_id'))
    if not path:
        return False
    fd, tmp = tempfile.mkstemp(prefix=os.path.basename(path) + '.', suffix='.tmp', dir=PAPER_DIR)
    try:
        with os.fdopen(fd, 'w', encoding='utf-8') as f:
            json.dump(batch, f, ensure_ascii=False, indent=2)
        os.replace(tmp, path)
        return True
    except Exception:
        try:
            os.unlink(tmp)
        except Exception:
            pass
        raise

@contextlib.contextmanager
def _paper_file_lock(batch_id, timeout=8):
    """跨进程批次锁：Windows msvcrt / Linux flock；同进程仍由 _PAPER_LOCK 保护。"""
    path = _paper_batch_path(batch_id)
    if not path:
        yield
        return
    fd = os.open(path + '.lock', os.O_CREAT | os.O_RDWR, 0o600)
    locked = False
    try:
        if os.name == 'nt' and os.fstat(fd).st_size == 0:
            os.write(fd, b'0')
            os.lseek(fd, 0, os.SEEK_SET)
        end = time.time() + timeout
        while True:
            try:
                if os.name == 'nt':
                    import msvcrt
                    os.lseek(fd, 0, os.SEEK_SET)
                    msvcrt.locking(fd, msvcrt.LK_NBLCK, 1)
                else:
                    import fcntl
                    fcntl.flock(fd, fcntl.LOCK_EX | fcntl.LOCK_NB)
                locked = True
                break
            except (OSError, BlockingIOError):
                if time.time() > end:
                    raise PaperError('批次正在被其他进程处理，请稍后重试')
                time.sleep(0.1)
        yield
    finally:
        if locked:
            try:
                if os.name == 'nt':
                    import msvcrt
                    os.lseek(fd, 0, os.SEEK_SET)
                    msvcrt.locking(fd, msvcrt.LK_UNLCK, 1)
                else:
                    import fcntl
                    fcntl.flock(fd, fcntl.LOCK_UN)
            except Exception:
                pass
        os.close(fd)

def _paper_mutate(batch_id, fn):
    """锁内 读最新 → 修改 → 原子写；fn 返回 None 表示不保存。"""
    if not _paper_batch_path(batch_id):
        return None
    with _PAPER_LOCK, _paper_file_lock(batch_id):
        batch = _paper_load_batch(batch_id)
        if not batch:
            return None
        out = fn(batch)
        if out is not False:
            _paper_save_batch(batch)
            _PAPER_LIST_CACHE.update({'ts': 0.0, 'raw': []})
        return batch if out is None else out

def _paper_date_diff(a, b):
    try:
        da = datetime.date.fromisoformat(str(a or '')[:10])
        db = datetime.date.fromisoformat(str(b or '')[:10])
        return abs((da - db).days)
    except Exception:
        return 9999

def _paper_is_backfill(date_s):
    try:
        d = datetime.date.fromisoformat(str(date_s or '')[:10])
        return d < (datetime.date.today() - datetime.timedelta(days=3))
    except Exception:
        return False

def _paper_dedup_for(check_time, win_min):
    """回溯批次查重：近 2 小时走现有缓存，历史日期按 check_time±窗口拉一次并缓存。"""
    win_ms = max(0, int(win_min or 0)) * 60000
    now_ms = int(time.time() * 1000)
    if abs(now_ms - check_time) <= 2 * 3600 * 1000:
        return _dedup_recent()
    day = time.strftime('%Y-%m-%d', time.localtime(check_time / 1000))
    if _PAPER_DEDUP_CACHE['key'] == day and _PAPER_DEDUP_CACHE['rows']:
        return _PAPER_DEDUP_CACHE['rows']
    rows = []
    try:
        for it in list_records_raw(load_cfg()['tid_records']):
            r = norm_record(it)
            ts = r.get('_ts') or 0
            if ts and abs(ts - check_time) <= max(win_ms, 3600 * 1000):
                rows.append(r)
    except Exception:
        return []
    _PAPER_DEDUP_CACHE.update({'key': day, 'rows': rows})
    return rows

_paper_cleanup = {'ts': 0}
def _paper_cleanup_old():
    """原图含学生信息，默认只保留 90 天。"""
    now = time.time()
    if now - _paper_cleanup['ts'] < 6 * 3600:
        return
    _paper_cleanup['ts'] = now
    try:
        max_age = max(1, num(load_cfg().get('paper_retention_days'), 90)) * 86400
        for name in os.listdir(PAPER_DIR):
            path = os.path.join(PAPER_DIR, name)
            try:
                if os.path.isfile(path) and now - os.path.getmtime(path) > max_age:
                    os.remove(path)
            except Exception:
                pass
    except Exception:
        pass

def _paper_classes():
    cfg = load_cfg()
    classes = {}
    tid = cfg.get('tid_classes')
    if tid:
        try:
            for item in fe_list_cached(tid, 300):
                f = item.get('fields') or {}
                grade, cls = f.get('年级'), f.get('班级')
                if grade and cls:
                    classes.setdefault(grade, [])
                    if cls not in classes[grade]:
                        classes[grade].append(cls)
        except Exception:
            pass
    if not classes:
        classes = cfg.get('classes') or {}
    return classes

def _paper_rules():
    out = []
    try:
        for i in fe_list_cached(load_cfg()['tid_rules'], 300):
            f = i.get('fields') or {}
            try:
                sc = float(f.get('默认分值'))
            except (TypeError, ValueError):
                sc = 0
            out.append({'item': f.get('事项细项') or '', 'dept': f.get('归属部门') or '',
                        'type': f.get('类型') or '', 'score': sc,
                        'grade': rt(f.get('适用年级')) or ''})
    except Exception:
        pass
    return out


def _paper_raw_text(cand):
    """取候选的“识别原文”：优先云端已读出的文字，其次本地 OCR 描述（剥掉前缀与附加说明）。"""
    txt = ((cand.get('ai') or {}).get('visible_text') or '').strip()
    if txt:
        return txt[:120]
    d = (cand.get('desc') or '').strip()
    d = re.sub(r'^(逐格识别|识别原文)[:：]\s*', '', d)
    d = d.split('；')[0].strip()
    return d[:120]


def _paper_ai_rules(template_id='', dept='', grade='', limit=70):
    """AI 提示词用的细则池。先按模板部门收窄（196→70/24），再按年级收窄（暂全通用），最后限量。
    这样既不漏项（不截断 196 条里的后 76 条），又不把整表塞进提示词。"""
    rules = [r for r in _paper_rules() if (r.get('type') or '扣分') == '扣分' and r.get('item')]
    dep = dept or (PAPER_TEMPLATES.get(template_id) or {}).get('dept') or ''
    if dep:
        same = [r for r in rules if (r.get('dept') or '') == dep]
        if len(same) >= 8:
            rules = same
    if grade:
        graded = [r for r in rules if (r.get('grade') or '') in ('', '通用', grade)]
        if len(graded) >= 8:
            rules = graded
    return rules[:limit]

def _paper_dorm_rows():
    try:
        rows = [norm_dorm_assign(i) for i in fe_list_cached(dorm_assign_tid(), 60)]
    except Exception:
        return []
    sems = sorted({r.get('semester') for r in rows if r.get('semester')}, reverse=True)
    if sems:
        rows = [r for r in rows if r.get('semester') == sems[0]]
    return rows

def _paper_grade_from_cls(cls):
    for g in GRADE_ORDER:
        if str(cls or '').startswith(g):
            return g
    return ''

def _paper_time_ms(date_s, session):
    hhmm = {'早读': '07:40', '午读': '12:40', '晚读': '18:40', '下午放学': '17:30'}.get(session or '', '')
    if date_s and hhmm:
        try:
            return int(time.mktime(time.strptime(date_s + ' ' + hhmm, '%Y-%m-%d %H:%M')) * 1000)
        except Exception:
            pass
    return int(time.time() * 1000)

# ---------- 能力位 / 计分口径 / 写前校验 ----------
def _paper_platform_windows():
    return platform.system().lower() == 'windows'

def _paper_local_request():
    return (request.remote_addr or '') in ('127.0.0.1', '::1', '::ffff:127.0.0.1')

def _paper_capabilities(force=False):
    """服务端能力位：只有 Windows + 真实加载成功才允许识别；目录存在不算。"""
    now = time.time()
    if not force and now - _PAPER_CAP_CACHE['ts'] < 300:
        return {k: _PAPER_CAP_CACHE.get(k) for k in
                ('platform', 'engine_installed', 'engine_ready', 'engine_name',
                 'loaded_ok', 'loaded_name', 'load_err', 'paper_enabled', 'recognize_enabled')}
    win = _paper_platform_windows()
    ok, name, err = False, '', ''
    if win:
        try:
            ok, name, err = paper_ocr_available()
        except Exception as exc:
            ok, err = False, str(exc)[:200]
    info = paper_engine_info()
    out = {
        'platform': 'windows' if win else platform.system().lower(),
        'engine_installed': bool(paper_engine_installed()),
        'engine_ready': bool(info.get('ready')),
        'engine_name': info.get('name', ''),
        'loaded_ok': bool(ok), 'loaded_name': name or '', 'load_err': err,
        'paper_enabled': bool(win and ok), 'recognize_enabled': bool(win and ok),
    }
    _PAPER_CAP_CACHE.update({'ts': now, **out})
    return out

def _paper_allowed_items(template_id):
    if template_id == 'after_class':
        return {x['item'] for x in PAPER_TEMPLATES['after_class']['items']}
    if template_id == 'dorm_log':
        return {r['item'] for r in _paper_rules()
                if (r.get('type') or '扣分') == '扣分' and (r.get('dept') or '') == '宿管部' and r.get('item')}
    return {r['item'] for r in _paper_rules() if (r.get('type') or '扣分') == '扣分' and r.get('item')}

def _paper_rule_for(item, dept='', grade=''):
    item = str(item or '').strip()
    if not item:
        return None
    hits = [r for r in _paper_rules()
            if (r.get('type') or '扣分') == '扣分' and (r.get('item') or '').strip() == item]
    if not hits:
        return None
    for r in hits:
        if dept and (r.get('dept') or '') == dept:
            return r
    for r in hits:
        if (r.get('grade') or '') in ('', '通用', grade or ''):
            return r
    return hits[0]

def _paper_unit_info(batch, row):
    """服务端解析单价与数量口径；忽略客户端传的单价/合计。
    返回 (unit_score, unit_label, qty_mode, paper_code, err)。"""
    tpl = batch.get('template') or ''
    item = (row.get('item') or '').strip()
    if tpl == 'after_class':
        meta = next((x for x in PAPER_TEMPLATES['after_class']['items'] if x['item'] == item), None)
        if not meta:
            return 0, '', '', '', '事项不在课后表 7 个纸表项目中'
        return abs(float(meta['score'])), meta.get('unit') or '项', meta.get('qty_mode') or 'fixed', meta.get('code') or '', ''
    if tpl == 'dorm_log':
        rule = _paper_rule_for(item, '宿管部', '')
        if not rule:
            return 0, '', '', '', '事项不在宿管部现行细则字典中'
        try:
            v = float(row.get('unit_score') if row.get('unit_score') not in (None, '') else row.get('score'))
        except (TypeError, ValueError):
            return 0, '', '', '', '宿舍页边分值不是数字'
        return abs(v), '间', 'fixed', '', ''
    dept0 = (row.get('dept') or batch.get('dept') or '')
    rule = _paper_rule_for(item, dept0, (row.get('grade') or batch.get('grade') or ''))
    if not rule:
        return 0, '', '', '', '事项不在现行细则字典中'
    if rule.get('dept') and dept0 and rule.get('dept') != dept0:
        return 0, '', '', '', '事项归属部门（%s）与登记部门（%s）不一致' % (rule.get('dept'), dept0)
    return abs(float(rule.get('score') or 0)), (row.get('unit') or '项'), 'count', '', ''

def _paper_entry_key(candidate_id, cls):
    return '%s|%s' % (str(candidate_id or '').strip(), str(cls or '').strip())

def _paper_written_keys(batch_id):
    """按纸表批次回查飞书已写记录，取 纸表候选ID|班级。崩溃后重试以此为准，不依赖本地 done。"""
    keys = set()
    try:
        for it in fe_list_cached(load_cfg()['tid_records'], 0):
            f = it.get('fields') or {}
            if (rt(f.get('纸表批次')) or '') != batch_id:
                continue
            k = rt(f.get(PAPER_CAND_FIELD)) or ''
            if k:
                keys.add(k)
    except Exception:
        pass
    return keys

@app.route('/api/paper/templates')
def paper_templates():
    cap = _paper_capabilities()
    return jsonify(ok=True, templates=paper_public_templates(),
                   engine_ready=bool(cap.get('engine_ready')), engine_name=cap.get('engine_name', ''),
                   engine_installed=bool(cap.get('engine_installed')),
                   paper_enabled=bool(cap.get('paper_enabled')),
                   recognize_enabled=bool(cap.get('recognize_enabled')),
                   loaded_ok=bool(cap.get('loaded_ok')), load_err=cap.get('load_err', ''),
                   platform=cap.get('platform', ''))

# ---------- 本地识别引擎外挂（桌面版可选下载，2026-11-05） ----------
import zipfile as _zipfile
import platform as _platform
ENGINE_DIR = os.path.join(BASE, 'engines')
ENGINE_ZIP_NAME = 'rapidocr_engine_win64_v2.zip'
_engine_dl = {'running': False, 'pct': 0, 'msg': '', 'err': ''}

def _engine_base_url():
    return ((load_cfg().get('update_url') or 'https://deyu.cahym.cn').rstrip('/') + '/updates/engine/')

@app.route('/api/engine/status')
def engine_status():
    cap = _paper_capabilities(force=True)
    return jsonify(ok=True,
                   installed=bool(cap.get('engine_installed')),
                   engine_ready=bool(cap.get('engine_ready')),
                   engine_name=cap.get('engine_name', ''),
                   loaded_ok=bool(cap.get('loaded_ok')),
                   loaded_name=cap.get('loaded_name', ''),
                   load_err=cap.get('load_err', ''),
                   paper_enabled=bool(cap.get('paper_enabled')),
                   installable=(cap.get('platform') == 'windows'),
                   sizeMB=196,
                   downloading=_engine_dl['running'], pct=_engine_dl['pct'],
                   msg=_engine_dl['msg'], err=_engine_dl['err'])

@app.route('/api/engine/download', methods=['POST'])
def engine_download():
    """后台线程：从云端 updates/engine/ 下载引擎 zip → 校验 sha256 → 解压到 engines/ → 热重载。"""
    b = request.get_json(silent=True) or {}
    if not _paper_platform_windows():
        return jsonify(ok=False, msg='本地识别引擎仅支持 Windows 桌面版'), 403
    if not _paper_local_request() and not check_pw('admin', b.get('admin_password')):
        return jsonify(ok=False, msg='请使用管理员口令后再下载引擎'), 401
    if not bool(load_cfg().get('allow_engine_download', True)):
        return jsonify(ok=False, msg='服务器已关闭引擎下载'), 403
    if _engine_dl['running']:
        return jsonify(ok=False, msg='下载已在进行中'), 409
    if paper_engine_installed() and not b.get('force'):
        return jsonify(ok=True, installed=True, msg='本地识别引擎已安装')

    def _work():
        _engine_dl.update({'running': True, 'pct': 0, 'msg': '连接服务器…', 'err': ''})
        tmp = os.path.join(BASE, 'engines_dl.zip')
        try:
            url = _engine_base_url() + ENGINE_ZIP_NAME
            r = HTTP.get(url, stream=True, timeout=30)
            r.raise_for_status()
            total = int(r.headers.get('Content-Length') or 0)
            got = 0
            _engine_dl['msg'] = '下载中'
            with open(tmp, 'wb') as f:
                for chunk in r.iter_content(256 * 1024):
                    if chunk:
                        f.write(chunk)
                        got += len(chunk)
                        _engine_dl['pct'] = int(got * 100 / total) if total else 0
            _engine_dl['msg'] = '校验完整性…'
            try:
                want = (HTTP.get(_engine_base_url() + ENGINE_ZIP_NAME + '.sha256', timeout=15).text.strip().split()[0] or '').lower()
                if want:
                    h = hashlib.sha256()
                    with open(tmp, 'rb') as f:
                        for blk in iter(lambda: f.read(1024 * 1024), b''):
                            h.update(blk)
                    if h.hexdigest() != want:
                        raise RuntimeError('引擎包完整性校验失败，请重试')
            except RuntimeError:
                raise
            except Exception:
                pass  # 校验文件拉取失败不阻断（zip 本体 HTTP 已保证传输完整）
            _engine_dl['msg'] = '解压安装…'
            os.makedirs(ENGINE_DIR, exist_ok=True)
            with _zipfile.ZipFile(tmp) as z:
                z.extractall(ENGINE_DIR)
            os.remove(tmp)
            ok = paper_engine_reload()
            _engine_dl.update({'running': False, 'pct': 100,
                               'msg': '安装完成' if ok else '解压完成，但引擎加载失败，请重启应用',
                               'err': '' if ok else 'reload failed'})
        except Exception as exc:
            _engine_dl.update({'running': False, 'pct': 0, 'msg': '', 'err': str(exc)[:200]})
            try:
                if os.path.exists(tmp):
                    os.remove(tmp)
            except Exception:
                pass

    threading.Thread(target=_work, daemon=True).start()
    return jsonify(ok=True, msg='下载已开始')

# ---------- 本地识别引擎外挂结束 ----------

@app.route('/api/paper/recognize', methods=['POST'])
def paper_recognize():
    b = request.get_json(force=True) or {}
    if not check_pw('reg', b.get('reg_password')):
        return jsonify(ok=False, msg='登记口令验证失败'), 401
    cap = _paper_capabilities()
    if not cap.get('recognize_enabled'):
        return jsonify(ok=False, msg='当前设备未启用本地识别；云端仅支持上传存档与批量录入'), 503
    template_id = b.get('template') or ''
    if template_id not in PAPER_TEMPLATES:
        return jsonify(ok=False, msg='请选择纸表模板'), 400
    raw = b.get('image') or ''
    if not isinstance(raw, str) or ',' not in raw:
        return jsonify(ok=False, msg='请先拍照或上传纸表照片'), 400
    try:
        data = base64.b64decode(raw.split(',', 1)[1], validate=False)
    except Exception:
        return jsonify(ok=False, msg='图片数据损坏，请重拍'), 400
    if not data or len(data) > 8 * 1024 * 1024:
        return jsonify(ok=False, msg='图片为空或超过 8MB，请压缩后重试'), 400
    ctx = {
        'grade': (b.get('grade') or '').strip()[:10],
        'dept': (b.get('dept') or PAPER_TEMPLATES[template_id].get('dept') or '').strip()[:20],
        'user': (b.get('user') or '').strip()[:30],
        'date': (b.get('date') or time.strftime('%Y-%m-%d')).strip()[:12],
        'session': (b.get('session') or '').strip()[:20],
        'building': (b.get('building') or '').strip()[:30],
    }
    if not ctx['user']:
        return jsonify(ok=False, msg='请选择使用人'), 400
    if PAPER_TEMPLATES[template_id].get('needs_grade') and not ctx['grade']:
        return jsonify(ok=False, msg='请选择年级'), 400
    if PAPER_TEMPLATES[template_id].get('needs_building') and not ctx['building']:
        return jsonify(ok=False, msg='请选择宿舍楼栋'), 400
    classes_map = _paper_classes()
    ctx['_known_classes'] = (classes_map.get(ctx['grade']) or [])
    try:
        result = analyze_paper(data, template_id, ctx, rules=_paper_rules(),
                               classes=classes_map, dorm_rows=_paper_dorm_rows())
    except PaperError as exc:
        return jsonify(ok=False, msg=str(exc)), 503
    except Exception as exc:
        import traceback as _tb
        _lines = _tb.format_exc().strip().splitlines()
        _loc = next((l.strip() for l in reversed(_lines) if l.strip().startswith('File ')), '')
        return jsonify(ok=False, msg='识别失败：' + str(exc)[:140] + ' ｜ 出错位置：' + _loc[:110]), 500
    # 本地细则候选：识别完就有，不依赖云端 AI
    rules_ded = [r for r in _paper_rules() if (r.get('type') or '扣分') == '扣分' and r.get('item')]
    for cand in result.get('candidates') or []:
        try:
            cand['match'] = paper_rule_candidates(
                _paper_raw_text(cand), rules_ded,
                '', ctx['grade'], topn=3,
                prefer_dept=cand.get('dept') or ctx['dept'] or '') if paper_rule_candidates else []
        except Exception:
            cand['match'] = []
    now = time.localtime()
    batch_id = 'PP%s-%s' % (time.strftime('%Y%m%d-%H%M%S', now), uuid.uuid4().hex[:8].upper())
    ext = '.png' if data[:8] == b'\x89PNG\r\n\x1a\n' else '.jpg'
    image_name = batch_id + ext
    try:
        with open(os.path.join(PAPER_DIR, image_name), 'wb') as f:
            f.write(data)
    except Exception:
        image_name = ''
    _paper_cleanup_old()
    date_input = ctx['date']
    date_paper = result.get('detected_date') or ''
    date_conflict = bool(date_paper and date_input and date_paper != date_input)
    date_diff = _paper_date_diff(date_input, date_paper) if date_conflict else 0
    date_used = date_input
    session_used = result.get('detected_session') or ctx['session']
    candidates = result.get('candidates') or []
    for cand in candidates:
        cand['total'] = float(cand.get('score') or 0)
        if cand.get('unit_score') in (None, ''):
            try:
                cand['unit_score'] = round(float(cand.get('score') or 0) / max(1, int(cand.get('qty') or 1)), 2)
            except (TypeError, ValueError):
                cand['unit_score'] = 0
        cand.setdefault('qty_mode', 'fixed' if template_id in ('after_class', 'dorm_log') else 'count')
    batch = {
        'batch_id': batch_id,
        'created': int(time.time() * 1000),
        'template': template_id,
        'template_name': PAPER_TEMPLATES[template_id]['name'],
        'dept': ctx['dept'], 'user': ctx['user'],
        'date': date_input, 'date_input': date_input, 'date_paper': date_paper,
        'date_conflict': date_conflict, 'date_diff_days': date_diff,
        'session': session_used, 'session_input': ctx['session'],
        'grade': ctx['grade'], 'building': ctx['building'],
        'check_time': _paper_time_ms(date_input, session_used),
        'image': image_name, 'status': 'recognized', 'warnings': result.get('warnings') or [],
        'ocr_count': result.get('ocr_count'), 'ocr_seconds': result.get('ocr_seconds'),
        'candidates': candidates,
    }
    result.update({'date_used': date_used, 'date_input': date_input, 'date_paper': date_paper,
                   'date_conflict': date_conflict, 'date_diff_days': date_diff})
    result['session_used'] = session_used
    try:
        _paper_save_batch(batch)
        _PAPER_LIST_CACHE.update({'ts': 0.0, 'raw': []})
    except Exception as exc:
        return jsonify(ok=False, msg='批次保存失败：' + str(exc)[:120]), 500
    result.update({'ok': True, 'batch_id': batch_id})
    return jsonify(result)

def _paper_ai_crop_b64(img, roi):
    from PIL import Image
    try:
        x0, y0, x1, y1 = [max(0, int(v)) for v in roi[:4]]
        pad = max(8, int(min(max(1, x1 - x0), max(1, y1 - y0)) * 0.08))
        crop = img.crop((max(0, x0 - pad), max(0, y0 - pad), x1 + pad, y1 + pad))
        if crop.width < 12 or crop.height < 12:
            return ''
        max_side = 1200
        if max(crop.size) > max_side:
            scale = max_side / max(crop.size)
            crop = crop.resize((max(1, int(crop.width * scale)), max(1, int(crop.height * scale))), Image.LANCZOS)
        buf = io.BytesIO()
        crop.convert('RGB').save(buf, 'JPEG', quality=86, optimize=True)
        return base64.b64encode(buf.getvalue()).decode('ascii')
    except Exception:
        return ''

def _paper_ai_prompt(cand, pool=None):
    if pool is None:
        pool = _paper_ai_rules(cand.get('template') or '', cand.get('dept') or '')
    rules = [{'item': r.get('item'), 'dept': r.get('dept'), 'score': r.get('score')} for r in pool]
    hint = cand.get('desc') or ''
    return (
        '你是学校德育检查表的 OCR 复核助手。图片是一个已定位的纸质表格问题格，可能包含手写内容。'
        '只依据图片可见内容识别，不要臆造。图片边缘可能有“√/✓”或相邻单元格内容；'
        '禁止把“√/✓”本身当作扣分事项，禁止为符号单独生成 issue。'
        '本地OCR参考提示可能错误，仅辅助定位，不可直接当答案。\n'
        '输出严格 JSON：{"visible_text":"格子内可见文字","issues":[{"raw":"原始手写片段",'
        '"item":"最接近的事项","quantity":数字,"unit":"人|处|次","score":数字,'
        '"confidence":0到100,"needs_human":true,"reason":"原因"}],"unreadable":false}\n'
        '一格有多个事项就拆成多个 issues；没有可见手写内容则 issues=[]，unreadable=true。'
        'item 只能从下面“可选细则”里原样挑选一项；若没有任何一项能可靠对应，'
        '必须返回 item="NO_MATCH"，禁止自造事项、禁止改写细则名称。\n'
        '候选来源：' + str(cand.get('cell') or '') + '；扣分对象：' + str(cand.get('target') or cand.get('cls') or '') + '；'
        '本地OCR提示：' + str(hint[:240]) + '；可选细则（只能从中选，否则 NO_MATCH）：'
        + json.dumps(rules, ensure_ascii=False)
    )

@app.route('/api/paper/ai_review', methods=['POST'])
def paper_ai_review():
    b = request.get_json(force=True) or {}
    if not check_pw('reg', b.get('reg_password')):
        return jsonify(ok=False, msg='登记口令验证失败'), 401
    cfg, c = _ai_cfg()
    if not c['enabled']:
        return jsonify(ok=False, msg='云端 AI 复核未启用，请联系管理员在「日志与口令 → AI 服务」开启'), 400
    if not c['api_key'] or not c['model']:
        return jsonify(ok=False, msg='云端 AI 服务未配置完整'), 400
    if c['daily_limit'] and _AI_DAILY.get('date') == time.strftime('%Y-%m-%d') and _AI_DAILY['count'] >= c['daily_limit']:
        return jsonify(ok=False, msg='今日云端复核次数已达上限'), 429
    batch = _paper_load_batch((b.get('batch_id') or '').strip())
    if not batch:
        return jsonify(ok=False, msg='识别批次不存在或已过期'), 404
    if batch.get('status') != 'recognized':
        return jsonify(ok=False, msg='批次状态已变化（%s），不能再次复核' % batch.get('status')), 409
    image_name = batch.get('image') or ''
    path = os.path.join(PAPER_DIR, image_name) if image_name else ''
    if not image_name or not os.path.isfile(path):
        return jsonify(ok=False, msg='原图已过期，无法进行云端复核'), 404
    try:
        with open(path, 'rb') as f:
            data = f.read()
        bgr, img = paper_ocr_image_from_bytes(data)
    except Exception as exc:
        return jsonify(ok=False, msg='原图读取失败：' + str(exc)[:120]), 500

    candidates = batch.get('candidates') or []
    ids = b.get('ids') or []
    if isinstance(ids, str):
        ids = [x.strip() for x in ids.split(',') if x.strip()]
    force = bool(b.get('force'))
    if ids:
        picked = [x for x in candidates if x.get('id') in ids]
    else:
        picked = [x for x in candidates if x.get('status') != 'ok' or int(x.get('confidence') or 0) < 85]
        if not force:
            picked = [x for x in picked if not x.get('ai')]
    picked = picked[:c['max_cells']]
    if not picked:
        return jsonify(ok=True, updates=[], used=0, model=c['model'], provider=c['provider'],
                       msg='没有需要云端复核的候选')

    updates, errors = [], []
    ai_by_id, match_by_id = {}, {}
    used = 0
    rules_all = [r for r in _paper_rules() if (r.get('type') or '扣分') == '扣分' and r.get('item')]
    pool = _paper_ai_rules(batch.get('template') or '', batch.get('dept') or '', batch.get('grade') or '')
    for cand in picked:
        roi = cand.get('roi')
        image_b64 = ''
        if isinstance(roi, list) and len(roi) == 4:
            image_b64 = _paper_ai_crop_b64(img, roi)
        elif c['privacy_mode'] == 'full':
            buf = io.BytesIO()
            img.thumbnail((1600, 1600))
            img.convert('RGB').save(buf, 'JPEG', quality=86, optimize=True)
            image_b64 = base64.b64encode(buf.getvalue()).decode('ascii')
        if not image_b64:
            errors.append({'id': cand.get('id'), 'msg': '隐私模式为只传小图，但该候选缺少坐标'})
            continue
        # 本地候选先行：不依赖云端，永远可用
        local_match = (paper_rule_candidates(
            _paper_raw_text(cand), rules_all,
            '', batch.get('grade') or '',
            topn=3, prefer_dept=cand.get('dept') or batch.get('dept') or '')
            if paper_rule_candidates else [])
        try:
            content, usage, status = _ai_chat(c, _paper_ai_prompt(cand, pool), image_b64)
            used += 1
            parsed = _ai_json(content)
            issues = parsed.get('issues') or []
            best = issues[0] if issues else {}
            raw_item = (best.get('item') or '').strip()
            nomatch = raw_item.upper().replace(' ', '').replace('_', '') in ('NOMATCH', '', '无')
            try:
                best_score = abs(float(best.get('score') or 0))
            except (TypeError, ValueError):
                best_score = 0
            top_score = (local_match[0]['score'] if local_match else 0)
            risk = 'high' if (cand.get('risk') == 'high' or best_score >= 50 or top_score >= 50) else ''
            ai = {
                'time': int(time.time() * 1000), 'provider': c['provider'], 'model': c['model'],
                'visible_text': parsed.get('visible_text') or '', 'unreadable': bool(parsed.get('unreadable')),
                'item': '' if nomatch else raw_item, 'raw_item': raw_item, 'nomatch': nomatch,
                'qty': max(1, int(best.get('quantity') or 1)),
                'unit': best.get('unit') or cand.get('unit') or '项',
                'score': best_score, 'confidence': max(0, min(100, int(best.get('confidence') or 0))),
                'needs_human': bool(best.get('needs_human', True)), 'reason': best.get('reason') or '',
                'risk': risk, 'match': local_match, 'issues': issues, 'usage': usage,
            }
            cand['ai'] = ai
            cand['match'] = local_match
            ai_by_id[cand.get('id')] = ai
            match_by_id[cand.get('id')] = local_match
            updates.append({'id': cand.get('id'), 'ai': ai})
            _ai_count()
        except Exception as exc:
            if local_match:
                cand['match'] = local_match
                match_by_id[cand.get('id')] = local_match
            errors.append({'id': cand.get('id'), 'msg': str(exc)[:240]})
        time.sleep(0.15)

    def _merge_ai(fresh):
        # 只 patch ai/match；绝不回写 status/submitted_*，避免覆盖并发提交
        if fresh.get('status') != 'recognized':
            return False
        for c in fresh.get('candidates') or []:
            cid = c.get('id')
            if cid in ai_by_id:
                c['ai'] = ai_by_id[cid]
            if cid in match_by_id:
                c['match'] = match_by_id[cid]
        fresh['ai_updated'] = int(time.time() * 1000)
        return True

    if ai_by_id or match_by_id:
        if not _paper_mutate(batch.get('batch_id'), _merge_ai):
            return jsonify(ok=False, msg='批次状态已变化（可能已提交），AI 结果未保存'), 409
        batch = _paper_load_batch(batch.get('batch_id')) or batch
        candidates = batch.get('candidates') or candidates
    write_log('纸表AI复核', batch.get('batch_id') or '',
              c['provider'] + '/' + c['model'] + '；成功 ' + str(used) + ' 格；失败 ' + str(len(errors)) + ' 格')
    return jsonify(ok=True, updates=updates, errors=errors, used=used,
                   provider=c['provider'], model=c['model'], candidates=candidates)

def _paper_recent_dups(entry, win_ms, recent):
    hits = []
    cls = entry.get('cls') or ''
    item = entry.get('item') or ''
    ts = entry.get('check_time') or int(time.time() * 1000)
    for r in recent:
        if (r.get('status') or '有效') not in ('有效', ''):
            continue
        if r.get('type') != '扣分' or (r.get('cls') or '') != cls:
            continue
        if abs((r.get('_ts') or 0) - ts) > win_ms:
            continue
        if (r.get('item') or '').strip() != item.strip():
            continue
        hits.append({'time': r.get('time'), 'item': r.get('item'), 'score': r.get('score'),
                     'user': r.get('user'), 'dept': r.get('dept'), 'student': r.get('student')})
    return hits[:3]

@app.route('/api/paper/confirm', methods=['POST'])
def paper_confirm():
    b = request.get_json(force=True) or {}
    if not check_pw('reg', b.get('reg_password')):
        return jsonify(ok=False, msg='登记口令验证失败'), 401
    batch_id = b.get('batch_id') or ''
    batch = _paper_load_batch(batch_id)
    if not batch:
        return jsonify(ok=False, msg='识别批次不存在或已过期'), 404
    st = batch.get('status') or 'recognized'
    if st == 'submitted':
        return jsonify(ok=True, duplicate_submit=True, count=batch.get('submitted_count', 0),
                       batch_id=batch_id, msg='该批次已提交，请勿重复写入')
    if st == 'writing':
        started = int(batch.get('writing_started') or 0)
        if not started or int(time.time() * 1000) - started > 10 * 60 * 1000:
            def _mark_unknown(fresh):
                fresh.update({'status': 'unknown', 'error': 'writing timeout'})
                return True
            _paper_mutate(batch_id, _mark_unknown)
            batch = _paper_load_batch(batch_id) or batch
            st = batch.get('status') or 'unknown'
        else:
            return jsonify(ok=False, msg='该批次正在写入，请稍后查看结果'), 409
    resume = bool(b.get('resume'))
    if st in ('partial', 'unknown'):
        if not (resume and b.get('reconciled')):
            return jsonify(ok=False, need_reconcile=True, status=st,
                           done=int(batch.get('done') or 0),
                           submitted_count=int(batch.get('submitted_count') or 0),
                           msg='该批次上次写入中断，请先核对已写入记录，再进行续办'), 409
    elif resume:
        resume = False

    # 日期：默认操作人选择；纸表日期只在用户明确选择后采用；改期/补录必须填原因
    date_input = (batch.get('date_input') or batch.get('date') or '').strip()
    date_paper = (batch.get('date_paper') or '').strip()
    choice = (b.get('date_choice') or '').strip()
    if batch.get('date_conflict') and choice not in ('input', 'paper'):
        return jsonify(ok=False, need_date_choice=True, date_input=date_input, date_paper=date_paper,
                       diff_days=int(batch.get('date_diff_days') or 0),
                       msg='纸表日期与操作人选择的日期不一致，请二选一'), 409
    if choice == 'paper':
        if not date_paper:
            return jsonify(ok=False, msg='纸表未识别出日期，不能选择纸表日期'), 400
        date_final = date_paper
    else:
        date_final = date_input or time.strftime('%Y-%m-%d')
    date_reason = (b.get('date_reason') or '').strip()[:200]
    backfill = _paper_is_backfill(date_final)
    if (date_final != date_input or backfill) and not date_reason:
        return jsonify(ok=False, need_date_reason=True, date_final=date_final, backfill=backfill,
                       msg='改用纸表日期或补录历史日期必须填写原因'), 400
    check_time = _paper_time_ms(date_final, batch.get('session') or '')

    incoming = b.get('rows') or []
    if not isinstance(incoming, list) or not incoming:
        return jsonify(ok=False, msg='没有可提交的扣分项'), 400
    if len(incoming) > 300:
        return jsonify(ok=False, msg='单批最多提交 300 个候选问题'), 400

    template = batch.get('template') or ''
    cand_map = {str(c.get('id')): c for c in (batch.get('candidates') or [])}
    allowed = _paper_allowed_items(template)
    classes_map = _paper_classes()
    dorm_map = {}
    if template == 'dorm_log':
        for r in _paper_dorm_rows():
            if r.get('room'):
                dorm_map.setdefault(r['room'], [])
                if r.get('cls') and r['cls'] not in dorm_map[r['room']]:
                    dorm_map[r['room']].append(r['cls'])
    entries, seen_keys = [], set()
    for i, row in enumerate(incoming):
        if not isinstance(row, dict):
            return jsonify(ok=False, msg='第 %d 行数据异常' % (i + 1)), 400
        cid = str(row.get('candidate_id') or row.get('id') or '').strip()
        manual = bool(row.get('manual'))
        cand = cand_map.get(cid) if cid else None
        if not manual and not cand:
            return jsonify(ok=False, msg='第 %d 行候选不属于当前批次或已被删除' % (i + 1)), 400
        if manual:
            if template == 'dorm_log':
                return jsonify(ok=False, msg='宿舍表不允许手动补录，请走宿舍扣分页'), 400
            reason = (row.get('reason') or '').strip()
            if not reason:
                return jsonify(ok=False, msg='第 %d 行手动补录必须填写原因' % (i + 1)), 400
            row_key = 'manual:%s' % ((row.get('client_row_id') or ('m%d' % (i + 1))).strip()[:40])
            cell = '手动补录'
            confidence = 0
        else:
            row_key = cid
            cell = (row.get('cell') or cand.get('cell') or '').strip()[:60]
            confidence = int(cand.get('confidence') or row.get('confidence') or 0)
        item = (row.get('item') or (cand or {}).get('item') or '').strip()[:80]
        if not item:
            return jsonify(ok=False, msg='第 %d 行缺少事项细项' % (i + 1)), 400
        if allowed and item not in allowed:
            return jsonify(ok=False, msg='第 %d 行事项不在现行细则字典中：%s' % (i + 1, item)), 400
        paper_code = ''
        if template == 'after_class':
            meta = next((x for x in PAPER_TEMPLATES['after_class']['items'] if x['item'] == item), None)
            if not meta:
                return jsonify(ok=False, msg='第 %d 行事项不是课后表 7 个纸表项目之一' % (i + 1)), 400
            paper_code = meta.get('code') or ''
            dict_items = {r['item'] for r in _paper_rules() if (r.get('type') or '扣分') == '扣分'}
            if dict_items and item not in dict_items:
                return jsonify(ok=False, msg='第 %d 行纸表专用事项尚未加入细则字典：%s' % (i + 1, item)), 400
        if template == 'dorm_log':
            room = str(row.get('room') or (cand or {}).get('room') or '').strip()[:20]
            classes = dorm_map.get(room) or []
            if not room or not classes:
                return jsonify(ok=False, msg='第 %d 行的宿舍房间未映射到班级，请先核对宿舍安排' % (i + 1)), 400
            building = (row.get('building') or (cand or {}).get('building') or batch.get('building') or '').strip()[:30]
            if row.get('unit_score') in (None, '') and cand:
                row['unit_score'] = cand.get('score') or 0
        else:
            cls = str(row.get('cls') or row.get('target') or (cand or {}).get('cls') or '').strip()[:30]
            if not cls or '待' in cls[:2]:
                return jsonify(ok=False, msg='第 %d 行未确定扣分班级' % (i + 1)), 400
            grade = _paper_grade_from_cls(cls)
            if not grade:
                return jsonify(ok=False, msg='第 %d 行班级无法识别年级：%s' % (i + 1, cls)), 400
            if batch.get('grade') and grade != batch.get('grade'):
                return jsonify(ok=False, msg='第 %d 行班级与批次年级不一致' % (i + 1)), 400
            known = classes_map.get(grade) or []
            if known and cls not in known:
                return jsonify(ok=False, msg='第 %d 行班级不在当前年级班级字典中：%s' % (i + 1, cls)), 400
            classes = [cls]
            building, room = '', ''
        dept = str(row.get('dept') or (cand or {}).get('dept') or batch.get('dept') or '纪检部').strip()[:10]
        if dept not in PAPER_DEPTS:
            return jsonify(ok=False, msg='第 %d 行登记部门不合法' % (i + 1)), 400
        if template == 'after_class':
            dept = '纪检部'
        unit_score, unit_label, qty_mode, code2, err = _paper_unit_info(batch, row)
        if err:
            return jsonify(ok=False, msg='第 %d 行：%s' % (i + 1, err)), 400
        if template == 'dorm_log' or qty_mode == 'fixed':
            qty = 1
        else:
            try:
                qty = int(float(row.get('qty') or 1))
            except (TypeError, ValueError):
                return jsonify(ok=False, msg='第 %d 行数量不是数字' % (i + 1)), 400
            if qty < 1 or qty > 200:
                return jsonify(ok=False, msg='第 %d 行数量必须在 1—200 之间' % (i + 1)), 400
        total = round(abs(float(unit_score)) * qty, 2)
        if total <= 0 or total > 2000:
            return jsonify(ok=False, msg='第 %d 行扣分合计必须在 0.5—2000 之间' % (i + 1)), 400
        desc = (row.get('desc') or '').strip()
        if qty > 1:
            desc = (desc + '；数量 %d%s' % (qty, unit_label or '项')).strip('；')
        if template == 'dorm_log':
            desc = (desc + '；房间 %s %s；整间扣分' % (building, room)).strip('；')
        if manual:
            desc = (desc + '；手动补录原因：' + (row.get('reason') or '').strip()).strip('；')
        grade = _paper_grade_from_cls(classes[0]) or (batch.get('grade') or '')
        for cls in classes:
            key = _paper_entry_key(row_key, cls)
            if key in seen_keys:
                continue
            seen_keys.add(key)
            entries.append({
                'source_index': i, 'row_key': key, 'candidate_id': row_key,
                'grade': _paper_grade_from_cls(cls) or grade, 'cls': str(cls).strip()[:30],
                'dept': dept, 'item': item[:40], 'unit_score': abs(float(unit_score)),
                'qty': qty, 'total': total, 'score': total, 'desc': desc[:500],
                'user': (batch.get('user') or '').strip()[:20],
                'cell': cell, 'confidence': confidence, 'paper_code': paper_code or code2,
                'building': building, 'room': room, 'check_time': check_time,
            })
    if len(entries) > 500:
        return jsonify(ok=False, msg='展开后超过 500 条，请分批提交'), 400

    win_min = num(load_cfg().get('dedup_window_min'), 60)
    dups, dup_seen = [], set()
    if win_min > 0 and not b.get('force'):
        recent = _paper_dedup_for(check_time, win_min)
        for e in entries:
            hits = _paper_recent_dups(e, win_min * 60000, recent)
            if hits and (e['source_index'], e['item']) not in dup_seen:
                dup_seen.add((e['source_index'], e['item']))
                dups.append({'index': e['source_index'], 'target': e['cls'], 'item': e['item'], 'hits': hits[:3]})
    if dups:
        return jsonify(ok=False, need_confirm=True, dups=dups, window=win_min,
                       msg='发现 %d 项在 %d 分钟窗口内疑似重复，请确认是否仍要写入' % (len(dups), win_min))

    with _PAPER_LOCK, _paper_file_lock(batch_id):
        fresh = _paper_load_batch(batch_id)
        if not fresh:
            return jsonify(ok=False, msg='识别批次已丢失'), 404
        fst = fresh.get('status') or 'recognized'
        if fst == 'submitted':
            return jsonify(ok=True, duplicate_submit=True, count=fresh.get('submitted_count', 0), batch_id=batch_id)
        if fst == 'writing':
            started = int(fresh.get('writing_started') or 0)
            if started and int(time.time() * 1000) - started <= 10 * 60 * 1000:
                return jsonify(ok=False, msg='该批次正在写入，请稍后查看结果'), 409
            fst = 'unknown'
        if fst in ('partial', 'unknown') and not (resume and b.get('reconciled')):
            return jsonify(ok=False, need_reconcile=True, status=fst,
                           done=int(fresh.get('done') or 0),
                           msg='该批次上次写入中断，请先核对已写入记录，再进行续办'), 409
        fresh.update({
            'status': 'writing', 'writing_started': int(time.time() * 1000),
            'submitted_rows': incoming, 'submitted_at': int(time.time() * 1000),
            'date_final': date_final, 'date_choice': choice or 'input',
            'date_reason': date_reason, 'backfill': backfill, 'check_time': check_time,
            'resume': bool(resume),
        })
        _paper_save_batch(fresh)
        batch = fresh

    if not ensure_record_fields():
        def _reset(fresh):
            fresh.update({'status': 'partial' if resume else 'recognized',
                          'error': '检查记录表字段初始化失败'})
            return True
        _paper_mutate(batch_id, _reset)
        return jsonify(ok=False, msg='检查记录表缺少纸表识别字段且自动补建失败，请管理员检查飞书权限'), 500

    written = set()
    if resume or st in ('partial', 'unknown'):
        written = set(batch.get('done_keys') or []) | _paper_written_keys(batch_id)
        entries = [e for e in entries if e['row_key'] not in written]
        if not entries:
            def _done(fresh):
                fresh.update({'status': 'submitted', 'submitted_count': len(written),
                              'done': len(written), 'submitted_at': int(time.time() * 1000)})
                return True
            _paper_mutate(batch_id, _done)
            return jsonify(ok=True, count=len(written), batch_id=batch_id, resumed=True)

    cfg = load_cfg()
    fields_list = []
    for e in entries:
        fields_list.append({'fields': {
            '检查时间': e['check_time'], '年级': e['grade'], '班级': e['cls'],
            '部门': e['dept'], '事项细项': e['item'], '类型': '扣分', '分值': -abs(e['total']),
            '事实描述': e['desc'], '使用人': e['user'], '登记来源': '纸表识别',
            '纸表批次': batch_id, '纸表模板': batch.get('template_name', '')[:40],
            '纸表来源格': e['cell'], '识别置信度': str(e['confidence']),
            '楼栋': e['building'], '房间': e['room'],
            PAPER_ITEM_FIELD: e.get('paper_code') or '',
            PAPER_CAND_FIELD: e['row_key'],
        }})

    def _mark_partial(done, keys, err):
        def _fn(fresh):
            fresh.update({'status': 'partial', 'done': done, 'done_keys': keys, 'error': str(err)[:200]})
            return True
        _paper_mutate(batch_id, _fn)

    done = len(written)
    done_keys = list(written)
    try:
        for i in range(0, len(fields_list), 400):
            chunk = fields_list[i:i + 400]
            d = HTTP.post(fe_url(cfg['tid_records']) + '/batch_create', headers=bh(),
                          json={'records': chunk}, timeout=60).json()
            if d.get('code') != 0:
                _mark_partial(done, done_keys, d.get('msg'))
                return jsonify(ok=False, msg='写入失败，已完成 %d 条；请核对后续办' % done, done=done,
                               need_reconcile=True), 500
            done += len(chunk)
            done_keys += [e['row_key'] for e in entries[i:i + 400]]
            def _progress(fresh):
                fresh.update({'status': 'writing', 'done': done, 'done_keys': done_keys})
                return True
            _paper_mutate(batch_id, _progress)
    except Exception as exc:
        _mark_partial(done, done_keys, str(exc))
        return jsonify(ok=False, msg='写入中断，已完成 %d 条；请核对后续办' % done, done=done,
                       need_reconcile=True), 500

    def _submitted(fresh):
        fresh.update({'status': 'submitted', 'submitted_count': done, 'done': done,
                      'done_keys': done_keys, 'submitted_at': int(time.time() * 1000)})
        return True
    _paper_mutate(batch_id, _submitted)
    write_log('纸表识别扣分', '%s %s' % (batch.get('template_name', ''), batch_id),
              '候选 %d 项，写入 %d 条；日期 %s%s；%s' % (
                  len(incoming), done, date_final,
                  ('（' + date_reason + '）') if date_reason else '',
                  batch.get('user', '')))
    return jsonify(ok=True, count=done, batch_id=batch_id, date_used=date_final,
                   backfill=backfill, resumed=bool(resume))
@app.route('/api/paper/batch_get', methods=['POST'])
def paper_batch_get():
    """按批次号取状态/已写条数/候选，供刷新后续办与 partial 对账（不返回原图）。"""
    b = request.get_json(force=True) or {}
    if not check_pw('reg', b.get('reg_password')):
        return jsonify(ok=False, msg='登记口令验证失败'), 401
    batch = _paper_load_batch((b.get('batch_id') or '').strip())
    if not batch:
        return jsonify(ok=False, msg='识别批次不存在或已过期'), 404
    return jsonify(ok=True, batch={
        'batch_id': batch.get('batch_id'), 'status': batch.get('status'),
        'template': batch.get('template'), 'template_name': batch.get('template_name'),
        'user': batch.get('user'), 'date_input': batch.get('date_input') or batch.get('date'),
        'date_paper': batch.get('date_paper'), 'date_conflict': batch.get('date_conflict'),
        'date_diff_days': batch.get('date_diff_days'), 'session': batch.get('session'),
        'grade': batch.get('grade'), 'building': batch.get('building'),
        'done': int(batch.get('done') or 0), 'submitted_count': int(batch.get('submitted_count') or 0),
        'error': batch.get('error') or '', 'warnings': batch.get('warnings') or [],
    }, candidates=batch.get('candidates') or [], submitted_rows=batch.get('submitted_rows') or [])

_PAPER_LIST_CACHE = {'ts': 0.0, 'raw': []}

def _paper_scan_raw():
    """扫描批次目录（10s 缓存），返回完整批次 dict 列表，按 created 倒序。"""
    now = time.time()
    if _PAPER_LIST_CACHE['raw'] and now - _PAPER_LIST_CACHE['ts'] < 10:
        return _PAPER_LIST_CACHE['raw']
    rows = []
    try:
        for name in os.listdir(PAPER_DIR):
            if not name.endswith('.json') or name.endswith('.tmp'):
                continue
            path = os.path.join(PAPER_DIR, name)
            try:
                with open(path, encoding='utf-8') as f:
                    b = json.load(f)
            except Exception:
                continue
            if isinstance(b, dict) and b.get('batch_id'):
                rows.append(b)
    except Exception:
        pass
    rows.sort(key=lambda x: -(int(x.get('created') or 0)))
    _PAPER_LIST_CACHE.update({'ts': now, 'raw': rows})
    return rows

@app.route('/api/paper/batches', methods=['POST'])
def paper_batches():
    """最近批次列表（续办入口）：只回摘要，不回原图/候选；普通用户只看本人。"""
    b = request.get_json(force=True) or {}
    if not check_pw('reg', b.get('reg_password')):
        return jsonify(ok=False, msg='登记口令验证失败'), 401
    days = max(1, min(30, int(b.get('days') or 7)))
    user = (b.get('user') or '').strip()[:30]
    mine_only = bool(b.get('mine_only'))
    cut = int((time.time() - days * 86400) * 1000)
    out = []
    for raw in _paper_scan_raw():
        if int(raw.get('created') or 0) < cut:
            continue
        st = raw.get('status') or 'recognized'
        if st == 'submitted' and int(raw.get('created') or 0) < int((time.time() - 86400) * 1000):
            continue   # 已完成超 1 天的不再打扰
        if mine_only and user and (raw.get('user') or '') != user:
            continue
        out.append({
            'batch_id': raw.get('batch_id'), 'status': st,
            'template': raw.get('template'), 'template_name': raw.get('template_name'),
            'user': raw.get('user'), 'date_input': raw.get('date_input') or raw.get('date'),
            'created': int(raw.get('created') or 0), 'done': int(raw.get('done') or 0),
            'submitted_count': int(raw.get('submitted_count') or 0),
            'cand_count': len(raw.get('candidates') or []),
            'error': raw.get('error') or '',
        })
    return jsonify(ok=True, batches=out[:60])

@app.route('/api/paper/feedback', methods=['POST'])
def paper_feedback():
    """登记人对识别结果的四类反馈，落操作日志供别名库/模板修正。"""
    b = request.get_json(force=True) or {}
    if not check_pw('reg', b.get('reg_password')):
        return jsonify(ok=False, msg='登记口令验证失败'), 401
    kind = (b.get('kind') or '').strip()[:20]
    if kind not in ('字认错', '分算错', '漏一行', '班级错', '其他'):
        return jsonify(ok=False, msg='反馈类型不合法'), 400
    note = (b.get('note') or '').strip()[:300]
    write_log('纸表识别反馈', (b.get('batch_id') or '无批次')[:40],
              kind + ('；' + note if note else '') + '；' + str(b.get('user') or ''))
    return jsonify(ok=True)

@app.route('/api/paper/stats', methods=['POST'])
def paper_stats():
    """近 N 天纸表质量聚合：提交/放弃/中断/平均耗时/人工修改行率。"""
    b = request.get_json(force=True) or {}
    if not check_pw('admin', b.get('admin_password')):
        return jsonify(ok=False, msg='管理口令验证失败'), 401
    days = max(1, min(60, int(b.get('days') or 7)))
    cut = int((time.time() - days * 86400) * 1000)
    agg = {'days': days, 'total': 0, 'submitted': 0, 'abandoned': 0,
           'interrupted': 0, 'writing': 0, 'avg_submit_seconds': 0, 'submit_n': 0,
           'edited_rows': 0, 'rows_total': 0}
    for raw in _paper_scan_raw():
        if int(raw.get('created') or 0) < cut:
            continue
        agg['total'] += 1
        st = raw.get('status') or 'recognized'
        if st == 'submitted':
            agg['submitted'] += 1
        elif st in ('partial', 'unknown'):
            agg['interrupted'] += 1
        elif st == 'writing':
            agg['writing'] += 1
        elif st == 'recognized' and int(raw.get('created') or 0) < int((time.time() - 30 * 60) * 1000):
            agg['abandoned'] += 1
        if st == 'submitted' and raw.get('submitted_at') and raw.get('created'):
            agg['submit_n'] += 1
            agg['avg_submit_seconds'] += max(0, (int(raw['submitted_at']) - int(raw['created'])) / 1000)
        for row in (raw.get('submitted_rows') or []):
            agg['rows_total'] += 1
            if row.get('edited') or row.get('score_touched') or row.get('qty_touched'):
                agg['edited_rows'] += 1
    if agg['submit_n']:
        agg['avg_submit_seconds'] = round(agg['avg_submit_seconds'] / agg['submit_n'], 1)
    return jsonify(ok=True, **agg)

# ---------- 检查排班 ----------
DEFAULT_DUTY_RULES = {
    '纪检部': [{'slot':'早读','n':2},{'slot':'午休','n':2},{'slot':'晚自习','n':2}],
    '艺体部': [{'slot':'大课间','n':4},{'slot':'机动','n':1}],
    '宿管部': [{'slot':'早查','n':2},{'slot':'晚查','n':2}],
    '劳动部': [{'slot':'包干区小检','n':3},{'slot':'机动','n':1}],
    '学习部': [{'slot':'早读检查','n':2},{'slot':'作业收交','n':2}],
    '礼仪部': [{'slot':'执勤抽查','n':2},{'slot':'机动','n':2}],
}

@app.route('/api/duty_rules', methods=['GET', 'POST'])
def duty_rules():
    cfg = load_cfg()
    if request.method == 'GET':
        rules = cfg.get('duty_rules')
        if not rules:
            rules = DEFAULT_DUTY_RULES
            cfg['duty_rules'] = rules
            save_cfg(cfg)
        return jsonify(ok=True, rules=rules)
    b = request.get_json(force=True)
    if not check_pw('admin', b.get('admin_password')):
        return jsonify(ok=False, msg='管理口令验证失败'), 401
    rules = b.get('rules')
    if not isinstance(rules, dict) or not rules:
        return jsonify(ok=False, msg='规则格式错误'), 400
    clean = {}
    for dept, slots in rules.items():
        if not isinstance(dept, str) or not dept.strip():
            continue
        clean[dept.strip()] = [{'slot': str(x.get('slot') or '').strip(), 'n': max(1, int(x.get('n') or 1))}
                               for x in (slots or []) if str(x.get('slot') or '').strip()]
    if not clean:
        return jsonify(ok=False, msg='至少保留一个部门的有效规则'), 400
    cfg['duty_rules'] = clean
    save_cfg(cfg)
    write_log('修改值勤规则', '排班配置', json.dumps(clean, ensure_ascii=False)[:400])
    return jsonify(ok=True)

@app.route('/api/duty_ai', methods=['POST'])
def duty_ai():
    """AI 排班：注入值勤规则+可用人员，返回结构化排班（可应用）或文本建议"""
    b = request.get_json(force=True)
    if not check_pw('admin', b.get('admin_password')):
        return jsonify(ok=False, msg='管理口令验证失败'), 401
    cfg = load_cfg()
    llm = cfg.get('llm') or {}
    if not (llm.get('enabled') and llm.get('base_url') and llm.get('api_key') and llm.get('model')):
        return jsonify(ok=False, msg='AI 未接入：请在 config.json 中配置 "llm": {"enabled": true, "base_url": "...", "api_key": "...", "model": "..."} 后重启服务')
    instruction = (b.get('instruction') or '').strip()
    if not instruction:
        return jsonify(ok=False, msg='请输入调整指令'), 400
    import re as _re
    dept = (b.get('dept') or '').strip()
    grade = (b.get('grade') or '').strip()
    rules = cfg.get('duty_rules') or DEFAULT_DUTY_RULES
    pool = [u for u in get_users_cached()
            if (not dept or u.get('dept') == dept) and (not grade or u.get('grade') == grade)]
    if not pool:
        return jsonify(ok=False, msg='可用人员为空：请先在用户表为成员填写部门与组别'), 400
    pool_lines = '\n'.join('- ' + u['name'] + '（' + (u.get('dept') or '') + '/' + (u.get('grade') or '') + '/组' + (u.get('grp') or '?') + '）' for u in pool)
    rules_lines = '\n'.join(dp + '：' + ' + '.join(sl['slot'] + str(sl['n']) + '人' for sl in slots) for dp, slots in rules.items())
    system = (
        '你是学生会检查排班助手。请根据值勤规则、可用人员与用户指令，安排本周检查排班。\n'
        '【值勤规则（部门：每日时段与人数）】\n' + rules_lines +
        '\n【值勤日】A 组值勤周一/三/五，B 组值勤周二/四；高三分会免晚自习时段。\n'
        '【可用人员（姓名（部门/年级/组））】\n' + pool_lines +
        '\n【输出要求】先用一两句话说明安排思路；然后单独一行输出 JSON 数组（不要代码块包裹），'
        '格式：[{"weekday":"周一","slot":"时段名","name":"人员姓名"}]。'
        'weekday 限周一至周五；slot 必须来自该人员所属部门的规则时段；name 必须来自可用人员名单，不得编造。'
    )
    try:
        d = HTTP.post(llm['base_url'].rstrip('/') + '/chat/completions',
                          headers={'Authorization': 'Bearer ' + llm['api_key']},
                          json={'model': llm['model'], 'messages': [
                              {'role': 'system', 'content': system},
                              {'role': 'user', 'content': instruction}]}, timeout=90).json()
        text = ((d.get('choices') or [{}])[0].get('message') or {}).get('content') or ''
    except Exception as e:
        return jsonify(ok=False, msg='AI 调用失败: ' + str(e)[:200]), 500
    schedule = []
    m = _re.search(r'\[[\s\S]*?\]', text)
    if m:
        try:
            arr = json.loads(m.group(0))
            valid_names = {u['name']: u for u in pool}
            valid_slots = set()
            for dp, slots in rules.items():
                if dept and dp != dept:
                    continue
                for sl in slots:
                    valid_slots.add(sl['slot'])
            for x in arr:
                if not isinstance(x, dict):
                    continue
                nm = x.get('name')
                if nm in valid_names and x.get('weekday') in ('周一', '周二', '周三', '周四', '周五') and x.get('slot') in valid_slots:
                    schedule.append({'weekday': x['weekday'], 'slot': x['slot'],
                                     'name': nm, 'grp': valid_names[nm].get('grp') or ''})
        except Exception:
            schedule = []
    write_log('AI排班', llm['model'], instruction[:150] + ' → ' + str(len(schedule)) + ' 条')
    return jsonify(ok=True, reply=text, schedule=schedule)


@app.route('/api/duties')
def get_duties():
    base = request.args.get('date') or time.strftime('%Y-%m-%d')
    try:
        d0 = time.strptime(base, '%Y-%m-%d')
    except ValueError:
        return jsonify(ok=False, msg='日期格式错误'), 400
    import datetime as _dt
    dt = _dt.datetime.strptime(base, '%Y-%m-%d')
    monday = dt - _dt.timedelta(days=dt.weekday())
    start_ms = int(time.mktime(monday.timetuple()) * 1000)
    end_ms = start_ms + 7 * 86400 * 1000
    cfg = load_cfg()
    out = []
    tid = cfg.get('tid_duty')
    if tid:
        for it in list_records_raw(tid):
            f = it.get('fields') or {}
            raw = f.get('日期')
            try:
                ts = float(raw) if raw is not None and str(raw).strip() != '' else 0
            except (TypeError, ValueError):
                ts = 0
            if not (start_ms <= ts < end_ms):
                continue
            dstr = time.strftime('%Y-%m-%d', time.localtime(ts / 1000)) if ts else ''
            out.append({'did': it.get('record_id'), 'date': dstr,
                        'weekday': rt(f.get('星期')) or '', 'slot': rt(f.get('时段')) or '',
                        'name': rt(f.get('检查员')) or '', 'cls': rt(f.get('班级')) or '',
                        'dept': rt(f.get('部门')) or '', 'grp': rt(f.get('组别')) or ''})
    out.sort(key=lambda x: (x['date'], x['slot'], x['name']))
    return jsonify(ok=True, duties=out, monday=monday.strftime('%Y-%m-%d'))

@app.route('/api/duties/batch', methods=['POST'])
def add_duties_batch():
    b = request.get_json(force=True)
    if not check_pw('admin', b.get('admin_password')):
        return jsonify(ok=False, msg='管理口令验证失败'), 401
    recs = b.get('records') or []
    if not recs:
        return jsonify(ok=False, msg='没有可写入的安排'), 400
    cfg = load_cfg()
    tid = cfg.get('tid_duty')
    if not tid:
        return jsonify(ok=False, msg='未配置检查安排表'), 500
    fields_list = []
    for r in recs:
        fields_list.append({'fields': {
            '日期': int(r.get('date_ms') or 0), '星期': r.get('weekday') or '',
            '时段': r.get('slot') or '', '检查员': r.get('name') or '',
            '班级': r.get('cls') or '', '部门': r.get('dept') or '', '组别': r.get('grp') or '',
        }})
    # purge: 'week' 清本周全部 / 'week_dept' 清本周该部门 —— 防止重复生成堆积
    purge = b.get('purge')
    if purge in ('week', 'week_dept'):
        import datetime as _dt
        base = b.get('week_start') or time.strftime('%Y-%m-%d')
        dt0 = _dt.datetime.strptime(base, '%Y-%m-%d')
        monday = dt0 - _dt.timedelta(days=dt0.weekday())
        start_ms = int(time.mktime(monday.timetuple()) * 1000)
        end_ms = start_ms + 7 * 86400 * 1000
        stale = []
        for it in list_records_raw(tid):
            f = it.get('fields') or {}
            raw = f.get('日期')
            try:
                ts = float(raw) if raw is not None and str(raw).strip() != '' else 0
            except (TypeError, ValueError):
                ts = 0
            if start_ms <= ts < end_ms:
                if purge == 'week_dept' and rt(f.get('部门')) != (b.get('dept') or ''):
                    continue
                stale.append(it.get('record_id'))
        for i in range(0, len(stale), 500):
            chunk = stale[i:i + 500]
            HTTP.delete(fe_url(tid) + '/batch_delete', headers=bh(), json={'records': chunk}, timeout=40)
        print('purge 清除旧排班:', len(stale))
    ok_n = 0
    for i in range(0, len(fields_list), 500):
        chunk = fields_list[i:i + 500]
        d = HTTP.post(fe_url(tid) + '/batch_create', headers=bh(), json={'records': chunk}, timeout=40).json()
        if d.get('code') != 0:
            return jsonify(ok=False, msg='写入失败: ' + str(d.get('msg')), done=ok_n), 500
        ok_n += len(chunk)
    if recs:
        write_log('生成排班', '全校' if b.get('purge') == 'week' else (recs[0].get('dept') or ''), '共 ' + str(ok_n) + ' 条安排' + ('（清除旧排班 ' + str(len(stale)) + ' 条）' if purge else ''))
    return jsonify(ok=True, count=ok_n)

@app.route('/api/duties/<did>', methods=['DELETE'])
def del_duty(did):
    if not check_pw('admin', _hdr_pw()):
        return jsonify(ok=False, msg='管理口令验证失败'), 401
    cfg = load_cfg()
    tid = cfg.get('tid_duty')
    if not tid:
        return jsonify(ok=False, msg='未配置检查安排表'), 500
    d = HTTP.delete(fe_url(tid) + '/' + did, headers=bh(), timeout=20).json()
    if d.get('code') == 0:
        write_log('删除排班', 'did=' + did)
    return jsonify(ok=d.get('code') == 0, msg=d.get('msg'))

@app.route('/api/users/swap_ab', methods=['POST'])
def swap_ab():
    b = request.get_json(force=True)
    if not check_pw('admin', b.get('admin_password')):
        return jsonify(ok=False, msg='管理口令验证失败'), 401
    cfg = load_cfg()
    tid = cfg['tid_users']
    updates = []
    for u in (norm_user(i) for i in list_records_raw(tid)):
        grp = (u.get('grp') or '').strip().upper()
        if grp in ('A', 'B'):
            updates.append({'record_id': u['rid'], 'fields': {'组别': ('B' if grp == 'A' else 'A')}})
    ok_n = 0
    for i in range(0, len(updates), 500):
        chunk = updates[i:i + 500]
        d = HTTP.post(fe_url(tid) + '/batch_update', headers=bh(), json={'records': chunk}, timeout=40).json()
        if d.get('code') != 0:
            return jsonify(ok=False, msg='互换失败: ' + str(d.get('msg')), done=ok_n), 500
        ok_n += len(chunk)
    write_log('AB组互换', '用户表', '对调 ' + str(ok_n) + ' 人')
    _users_cache['v'] = None
    return jsonify(ok=True, count=ok_n)

# ---------- 公告与留言 ----------
@app.route('/api/notices')
def get_notices():
    cfg = load_cfg()
    out = []
    tid = cfg.get('tid_notices')
    if tid:
        try:
            for it in fe_list_cached(tid, 45):
                f = it.get('fields') or {}
                ts = num(f.get('发布时间'))
                pin = f.get('置顶')
                out.append({'nid': it.get('record_id'),
                            'title': rt(f.get('标题')) or '', 'content': rt(f.get('内容')) or '',
                            'by': rt(f.get('发布人')) or '', 'ts': ts,
                            'pin': bool(pin), 'time': time.strftime('%m-%d %H:%M', time.localtime(ts / 1000)) if ts else ''})
        except Exception:
            pass
    out.sort(key=lambda x: (-int(x['pin']), -x['ts']))
    return jsonify(ok=True, notices=out[:50])

@app.route('/api/notices', methods=['POST'])
def add_notice():
    b = request.get_json(force=True)
    if not check_pw('admin', b.get('admin_password')):
        return jsonify(ok=False, msg='管理口令验证失败'), 401
    title = (b.get('title') or '').strip()
    content = (b.get('content') or '').strip()
    if not title or not content:
        return jsonify(ok=False, msg='标题与内容必填'), 400
    cfg = load_cfg()
    tid = cfg.get('tid_notices')
    if not tid:
        return jsonify(ok=False, msg='未配置公告表'), 500
    fields = {'标题': title, '内容': content, '发布人': '管理员',
              '发布时间': int(time.time() * 1000)}
    if b.get('pin'):
        fields['置顶'] = ['置顶']  # 公告表「置顶」是多选字段：勾选写选项，不勾选整个字段省略
    d = HTTP.post(fe_url(tid), headers=bh(), json={'fields': fields}, timeout=20).json()
    if d.get('code') != 0:
        return jsonify(ok=False, msg='发布失败: ' + str(d.get('msg'))), 500
    write_log('发布公告', title[:30])
    return jsonify(ok=True)

@app.route('/api/notices/<nid>', methods=['DELETE'])
def del_notice(nid):
    if not check_pw('admin', _hdr_pw()):
        return jsonify(ok=False, msg='管理口令验证失败'), 401
    cfg = load_cfg()
    tid = cfg.get('tid_notices')
    if not tid:
        return jsonify(ok=False, msg='未配置公告表'), 500
    d = HTTP.delete(fe_url(tid) + '/' + nid, headers=bh(), timeout=20).json()
    if d.get('code') == 0:
        write_log('删除公告', 'nid=' + nid)
    return jsonify(ok=d.get('code') == 0, msg=d.get('msg'))

@app.route('/api/messages')
def get_messages():
    cfg = load_cfg()
    out = []
    tid = cfg.get('tid_messages')
    if tid:
        try:
            for it in fe_list_cached(tid, 45):   # 空表实时拉也要 1.45s，加缓存；留言写入会自动失效
                f = it.get('fields') or {}
                ts = num(f.get('时间'))
                out.append({'mid': it.get('record_id'),
                            'time': time.strftime('%m-%d %H:%M', time.localtime(ts / 1000)) if ts else '',
                            '_ts': ts, 'sender': rt(f.get('发送人')) or '', 'identity': rt(f.get('身份')) or '',
                            'content': rt(f.get('内容')) or '', 'reply': rt(f.get('回复')) or ''})
        except Exception:
            pass
    out.sort(key=lambda x: -x['_ts'])
    return jsonify(ok=True, messages=out[:100])

@app.route('/api/messages', methods=['POST'])
def add_message():
    b = request.get_json(force=True)
    sender = (b.get('sender') or '').strip()
    identity = (b.get('identity') or '').strip()
    content = (b.get('content') or '').strip()
    if not sender or not content:
        return jsonify(ok=False, msg='发送人与内容必填'), 400
    if len(content) > 500:
        return jsonify(ok=False, msg='留言最长 500 字'), 400
    cfg = load_cfg()
    tid = cfg.get('tid_messages')
    if not tid:
        return jsonify(ok=False, msg='未配置留言表'), 500
    d = HTTP.post(fe_url(tid), headers=bh(), json={'fields': {
        '时间': int(time.time() * 1000), '发送人': sender, '身份': identity,
        '内容': content}}, timeout=20).json()
    if d.get('code') != 0:
        return jsonify(ok=False, msg='发送失败: ' + str(d.get('msg'))), 500
    write_log('留言', sender, content[:50])
    return jsonify(ok=True)

@app.route('/api/messages/<mid>', methods=['POST'])
def reply_message(mid):
    b = request.get_json(force=True)
    if not check_pw('admin', b.get('admin_password')):
        return jsonify(ok=False, msg='管理口令验证失败'), 401
    reply = (b.get('reply') or '').strip()
    if not reply:
        return jsonify(ok=False, msg='回复内容必填'), 400
    cfg = load_cfg()
    tid = cfg.get('tid_messages')
    if not tid:
        return jsonify(ok=False, msg='未配置留言表'), 500
    d = HTTP.put(fe_url(tid) + '/' + mid, headers=bh(), json={'fields': {'回复': reply}}, timeout=20).json()
    if d.get('code') == 0:
        write_log('回复留言', 'mid=' + mid, reply[:50])
    return jsonify(ok=d.get('code') == 0, msg=d.get('msg'))

@app.route('/api/messages/<mid>', methods=['DELETE'])
def del_message(mid):
    if not check_pw('admin', _hdr_pw()):
        return jsonify(ok=False, msg='管理口令验证失败'), 401
    cfg = load_cfg()
    tid = cfg.get('tid_messages')
    if not tid:
        return jsonify(ok=False, msg='未配置留言表'), 500
    d = HTTP.delete(fe_url(tid) + '/' + mid, headers=bh(), timeout=20).json()
    if d.get('code') == 0:
        write_log('删除留言', 'mid=' + mid)
    return jsonify(ok=d.get('code') == 0, msg=d.get('msg'))

# ---------- 启动 ----------
def _warmup():
    """后台预热飞书凭证与常用缓存，避免首次登录慢"""
    def warm():
        try:
            get_token(); get_creds(); get_users_cached()
        except Exception:
            pass
    threading.Timer(1.0, warm).start()

_warmup()

def open_browser():
    time.sleep(1.2)
    webbrowser.open('http://127.0.0.1:8765')

# ---------- 活动名单 ----------
@app.route('/api/activities')
def get_activities():
    cfg = load_cfg()
    tid = cfg.get('tid_activities')
    out = []
    if tid:
        try:
            for it in fe_list_cached(tid, 45):
                f = it.get('fields') or {}
                out.append({'aid': it.get('record_id'),
                            'act': rt(f.get('活动名称')) or '', 'date': rt(f.get('日期')) or '',
                            'cls': rt(f.get('班级')) or '', 'member': rt(f.get('姓名')) or '',
                            'dept': rt(f.get('部门')) or '', 'note': rt(f.get('备注')) or '',
                            'creator': rt(f.get('创建人')) or '', 'ts': num(f.get('创建时间'))})
        except Exception:
            pass
    out.sort(key=lambda x: (x['date'], x['act']), reverse=True)
    return jsonify(ok=True, rows=out)

@app.route('/api/activities', methods=['POST'])
def add_activity():
    b = request.get_json(force=True)
    if not check_pw('admin', b.get('admin_password')):
        return jsonify(ok=False, msg='管理口令验证失败'), 401
    name = (b.get('name') or '').strip()
    date = (b.get('date') or '').strip()
    members = b.get('members') or []
    if not name or not date or not members:
        return jsonify(ok=False, msg='活动名称、日期与成员必填'), 400
    cfg = load_cfg()
    note = (b.get('note') or '').strip()
    creator = (b.get('creator') or '管理员').strip()
    now = int(time.time() * 1000)
    records = [{'fields': {
        '活动名称': name[:60], '日期': date[:20],
        '班级': str(m.get('cls') or '')[:30], '姓名': str(m.get('name') or '')[:30],
        '部门': str(m.get('dept') or '')[:20], '备注': note[:200],
        '创建人': creator[:30], '创建时间': now}} for m in members]
    ok_n = 0
    for chunk in [records[i:i+400] for i in range(0, len(records), 400)]:
        d = HTTP.post(fe_url(cfg['tid_activities']) + '/batch_create', headers=bh(), json={'records': chunk}, timeout=60).json()
        if d.get('code') != 0:
            return jsonify(ok=False, msg='写入失败: ' + str(d.get('msg'))), 500
        ok_n += len(chunk)
    write_log('活动归档', name + ' ' + date, str(ok_n) + ' 人')
    return jsonify(ok=True, count=ok_n)

@app.route('/api/activities', methods=['DELETE'])
def del_activity():
    b = request.get_json(silent=True) or {}
    if not check_pw('admin', _hdr_pw() or b.get('admin_password')):
        return jsonify(ok=False, msg='管理口令验证失败'), 401
    name = (b.get('name') or '').strip()
    date = (b.get('date') or '').strip()
    if not name or not date:
        return jsonify(ok=False, msg='需指定活动名称与日期'), 400
    cfg = load_cfg()
    tid = cfg.get('tid_activities')
    # 飞书"写入后立即删"存在索引延迟（幽灵记录导致 batch 原子失败、逐条删被限流），
    # 因此删除放后台线程慢慢做（batch + 逐条兜底 + 多轮重试），接口立即返回。
    def _bg_del():
        removed = 0
        try:
            for attempt in range(8):
                ids = []
                try:
                    for it in list_records_raw(tid):
                        f = it.get('fields') or {}
                        if rt(f.get('活动名称')) == name and rt(f.get('日期')) == date:
                            ids.append(it.get('record_id'))
                except Exception:
                    pass
                if not ids:
                    break
                # 整批先删（快，通常清掉大部分）
                try:
                    HTTP.delete(fe_url(tid) + '/batch_delete', headers=bh(), json={'records': ids}, timeout=40)
                except Exception:
                    pass
                time.sleep(1.0)
                # 逐条并行清漏网
                try:
                    rest_ids = []
                    for it in list_records_raw(tid):
                        f = it.get('fields') or {}
                        if rt(f.get('活动名称')) == name and rt(f.get('日期')) == date:
                            rest_ids.append(it.get('record_id'))
                    def _one(rid):
                        try:
                            HTTP.delete(fe_url(tid) + '/' + rid, headers=bh(), timeout=20)
                            return 1
                        except Exception:
                            return 0
                    with ThreadPoolExecutor(max_workers=6) as ex:
                        removed += sum(ex.map(_one, rest_ids))
                except Exception:
                    pass
                time.sleep(2.0)
        except Exception:
            pass
    threading.Thread(target=_bg_del, daemon=True).start()
    return jsonify(ok=True, msg='删除任务已开始', count=0)

# ---------- 排班偏好 ----------
@app.route('/api/duty_prefs')
def get_duty_prefs():
    cfg = load_cfg()
    p = cfg.get('duty_prefs') or {}
    return jsonify(ok=True, prefs={'avoid_self': bool(p.get('avoid_self', True)),
                                   'nearby': bool(p.get('nearby', True))})

@app.route('/api/duty_prefs', methods=['POST'])
def set_duty_prefs():
    b = request.get_json(force=True)
    if not check_pw('admin', b.get('admin_password')):
        return jsonify(ok=False, msg='管理口令验证失败'), 401
    prefs = {'avoid_self': bool(b.get('avoid_self')), 'nearby': bool(b.get('nearby'))}
    cfg = load_cfg()
    cfg['duty_prefs'] = prefs
    try:
        json.dump(cfg, open(CONFIG_PATH, 'w', encoding='utf-8'), ensure_ascii=False, indent=2)
    except Exception:
        return jsonify(ok=False, msg='保存失败'), 500
    write_log('排班偏好', '回避本班:' + ('开' if prefs['avoid_self'] else '关') + ' · 就近连班:' + ('开' if prefs['nearby'] else '关'))
    return jsonify(ok=True, prefs=prefs)

# ---------- 宿舍床位 ----------
@app.route('/api/dorms')
def get_dorms():
    cfg = load_cfg()
    out = []
    try:
        for it in list_records_raw(cfg.get('tid_dorms')):
            f = it.get('fields') or {}
            out.append({'rid': it.get('record_id'),
                        'building': rt(f.get('楼栋')) or '', 'room': rt(f.get('房间')) or '',
                        'bed': rt(f.get('床位')) or '', 'grade': rt(f.get('年级')) or '',
                        'cls': rt(f.get('班级')) or '', 'name': rt(f.get('姓名')) or ''})
    except Exception:
        pass
    out.sort(key=lambda x: (x['building'], x['room'], len(x['bed']), x['bed']))
    return jsonify(ok=True, rows=out)

@app.route('/api/dorms', methods=['POST'])
def import_dorms():
    b = request.get_json(force=True)
    if not check_pw('admin', b.get('admin_password')):
        return jsonify(ok=False, msg='管理口令验证失败'), 401
    rows = b.get('rows') or []
    if not rows:
        return jsonify(ok=False, msg='没有可导入的床位'), 400
    cfg = load_cfg()
    records = [{'fields': {
        '楼栋': str(r.get('building') or '')[:30], '房间': str(r.get('room') or '')[:20],
        '床位': str(r.get('bed') or '')[:10], '年级': str(r.get('grade') or '')[:10],
        '班级': str(r.get('cls') or '')[:30], '姓名': str(r.get('name') or '')[:30]}} for r in rows]
    n = 0
    for chunk in [records[i:i+400] for i in range(0, len(records), 400)]:
        d = HTTP.post(fe_url(cfg['tid_dorms']) + '/batch_create', headers=bh(), json={'records': chunk}, timeout=60).json()
        if d.get('code') != 0:
            return jsonify(ok=False, msg='写入失败: ' + str(d.get('msg'))), 500
        n += len(chunk)
    write_log('床位导入', '共 ' + str(n) + ' 床')
    return jsonify(ok=True, count=n)

@app.route('/api/dorms', methods=['PUT'])
def edit_dorm():
    b = request.get_json(force=True)
    if not check_pw('admin', b.get('admin_password')):
        return jsonify(ok=False, msg='管理口令验证失败'), 401
    rid = b.get('rid')
    if not rid:
        return jsonify(ok=False, msg='缺少床位记录ID'), 400
    field_map = {'building': '楼栋', 'room': '房间', 'bed': '床位', 'grade': '年级', 'cls': '班级', 'name': '姓名'}
    fields = {}
    for k, col in field_map.items():
        if k in b:
            fields[col] = str(b.get(k) or '')[:30]
    if not fields:
        return jsonify(ok=False, msg='没有需要更新的字段'), 400
    cfg = load_cfg()
    d = HTTP.put(fe_url(cfg['tid_dorms']) + '/' + rid, headers=bh(), json={'fields': fields}, timeout=20).json()
    if d.get('code') != 0:
        return jsonify(ok=False, msg='更新失败: ' + str(d.get('msg'))), 500
    return jsonify(ok=True)

@app.route('/api/dorms', methods=['DELETE'])
def del_dorms():
    b = request.get_json(silent=True) or {}
    if not check_pw('admin', _hdr_pw() or b.get('admin_password')):
        return jsonify(ok=False, msg='管理口令验证失败'), 401
    rids = b.get('rids') or []
    if not rids:
        return jsonify(ok=False, msg='需指定要删除的床位'), 400
    cfg = load_cfg()
    n = 0
    for rid in rids:
        try:
            d = HTTP.delete(fe_url(cfg['tid_dorms']) + '/' + rid, headers=bh(), timeout=20).json()
            if d.get('code') == 0:
                n += 1
        except Exception:
            pass
    write_log('删除床位', 'rid=' + ','.join(rids[:5]) + ('...' if len(rids) > 5 else ''), str(n) + ' 条')
    return jsonify(ok=True, count=n)

# ---------- 德育挂件(PulseDeck 桌面小组件)只读接口 ----------

_widget_cache = {'key': None, 'v': None, 'exp': 0}

@app.after_request
def widget_cors(resp):
    if request.path.startswith('/api/widget/'):
        resp.headers['Access-Control-Allow-Origin'] = '*'
    return resp

def _collect_widget_notices(cls, grade, limit=6):
    """按班级/年级过滤公告;紧急广播单独返回;过期自动剔除"""
    cfg = load_cfg()
    notices, broadcasts = [], []
    tid = cfg.get('tid_notices')
    now_ms = int(time.time() * 1000)

    def match(scopes):
        if not scopes:
            return True
        return ('全校' in scopes) or (grade and grade in scopes) or (cls and cls in scopes)

    if tid:
        try:
            for it in fe_list_cached(tid, 45):
                f = it.get('fields') or {}
                ts = num(f.get('发布时间'))
                raw_scope = rt(f.get('范围')) or ''
                if isinstance(raw_scope, list):
                    scopes = [str(x.get('text') if isinstance(x, dict) else x).strip()
                              for x in raw_scope if x]
                else:
                    scopes = [s.strip() for s in str(raw_scope).replace('，', ',').split(',') if s.strip()]
                expire = num(f.get('过期时间'), 0)
                if expire and now_ms > expire:
                    continue
                if not match(scopes):
                    continue
                entry = {'title': rt(f.get('标题')) or '', 'content': rt(f.get('内容')) or '',
                         'pin': bool(f.get('置顶')), 'ts': ts,
                         'time': time.strftime('%m-%d %H:%M', time.localtime(ts / 1000)) if ts else ''}
                if f.get('紧急'):
                    broadcasts.append(entry)
                else:
                    notices.append(entry)
        except Exception:
            pass
    notices.sort(key=lambda x: (-int(x['pin']), -x['ts']))
    broadcasts.sort(key=lambda x: -x['ts'])
    return notices[:limit], broadcasts[:3]

def _collect_widget_duties():
    cfg = load_cfg()
    out = []
    tid = cfg.get('tid_duty')
    if tid:
        try:
            day0 = time.mktime(time.strptime(time.strftime('%Y-%m-%d'), '%Y-%m-%d')) * 1000
            for it in fe_list_cached(tid, 45):
                f = it.get('fields') or {}
                ts = num(f.get('日期'))
                if not (day0 <= ts < day0 + 86400000):
                    continue
                out.append({'slot': rt(f.get('时段')) or '', 'name': rt(f.get('检查员')) or '',
                            'dept': rt(f.get('部门')) or '', 'cls': rt(f.get('班级')) or '',
                            'grp': rt(f.get('组别')) or ''})
        except Exception:
            pass
    out.sort(key=lambda x: (x['slot'], x['name']))
    return out

@app.route('/api/widget/board')
def widget_board():
    """桌面挂件聚合只读接口:班级加减分 / 年级排名 / 公告事件 / 好人好事 / 今日执勤"""
    cfg = load_cfg()
    wt = (cfg.get('widget_token') or '').strip()
    if wt and request.args.get('token') != wt:
        return jsonify(ok=False, msg='token 无效'), 401
    cls = (request.args.get('cls') or '').strip()
    now = time.time()
    if _widget_cache['v'] is not None and _widget_cache['key'] == cls and now < _widget_cache['exp']:
        return jsonify(ok=True, **_widget_cache['v'])
    # 班级 → 年级
    classes = {}
    tid = cfg.get('tid_classes')
    if tid:
        try:
            for item in fe_list_cached(tid, 300):
                f = item.get('fields') or {}
                g, c = f.get('年级'), f.get('班级')
                if g and c:
                    classes.setdefault(g, [])
                    if c not in classes[g]:
                        classes[g].append(c)
        except Exception:
            pass
    if not classes:
        classes = cfg.get('classes', {})
    if not cls:
        for g in GRADE_ORDER:
            if classes.get(g):
                cls = classes[g][0]
                break
    grade = next((g for g, lst in classes.items() if cls in lst), '')
    # 记录
    recs = []
    try:
        recs = [norm_record(i) for i in fe_list_cached(cfg['tid_records'], 45)]
    except Exception:
        recs = []
    valid = [r for r in recs if r.get('status') == '有效']
    mine = [r for r in valid if r.get('cls') == cls]
    mine.sort(key=lambda x: -(x.get('_ts') or 0))
    if not grade and mine:
        grade = mine[0].get('grade') or ''
    day0 = time.mktime(time.strptime(time.strftime('%Y-%m-%d'), '%Y-%m-%d')) * 1000
    import datetime as _dt
    _now = _dt.datetime.now()
    mon0 = time.mktime((_now - _dt.timedelta(days=_now.weekday())).date().timetuple()) * 1000
    # 排名口径:week(默认) / month / total
    rank_mode = cfg.get('widget_rank_mode') or 'week'
    if rank_mode == 'total':
        rank0 = 0
    elif rank_mode == 'month':
        m0 = _now.replace(day=1, hour=0, minute=0, second=0, microsecond=0)
        rank0 = time.mktime(m0.timetuple()) * 1000
    else:
        rank0 = mon0

    # 每日基础分:每班每天 100 分初始分,一直累计。总分 = 基础分累计 + 净分
    BASE_PER_DAY = 100
    week_days = _now.weekday() + 1          # 周一起算
    month_days = _now.day                   # 月初起算
    sem_name = str(cfg.get('semester_name') or '').strip()
    sem_end = ''
    try:
        _ss = time.strptime(str(cfg.get('semester_start') or '2026-09-01'), '%Y-%m-%d')
        _sd = _dt.date(_ss.tm_year, _ss.tm_mon, _ss.tm_mday)
        semester_days = max((_now.date() - _sd).days + 1, 1)
        try:
            _ee = str(cfg.get('semester_end') or '').strip()
            if _ee:
                _et = time.strptime(_ee, '%Y-%m-%d')
                _ed = _dt.date(_et.tm_year, _et.tm_mon, _et.tm_mday)
                if _ed >= _sd:
                    sem_end = _ee
                    semester_days = min(semester_days, (_ed - _sd).days + 1)   # 学期结束后天数封顶
        except Exception:
            pass
    except Exception:
        semester_days = 1
    period_days = {'week': week_days, 'month': month_days, 'total': semester_days}.get(rank_mode, week_days)
    _deeds_days = num(cfg.get('deeds_board_days'), 7)   # 好人好事上榜天数,0=一直展示

    def agg(items):
        add = sum(r.get('score') or 0 for r in items if (r.get('score') or 0) > 0)
        deduct = sum(r.get('score') or 0 for r in items if (r.get('score') or 0) < 0)
        return {'add': add, 'deduct': deduct, 'net': add + deduct}

    # 年级排名(基础分累计+净分;全年级班级都参与,无记录班级净分记 0)
    rank, total_cls, grade_score, board_list = 0, 0, 0, []
    if grade:
        pool = {}
        for r in valid:
            if (r.get('grade') or '') == grade and r.get('cls') and (r.get('_ts') or 0) >= rank0:
                pool[r['cls']] = pool.get(r['cls'], 0) + (r.get('score') or 0)
        if cls and cls not in pool:
            pool[cls] = 0
        for c2 in classes.get(grade, []):
            if c2 not in pool:
                pool[c2] = 0
        base = BASE_PER_DAY * period_days
        ordered = sorted(pool.items(), key=lambda kv: -(kv[1] + base))
        for i, (c2, sc) in enumerate(ordered, 1):
            if c2 == cls:
                rank, grade_score = i, sc + base
        total_cls = len(ordered)
        board_list = [{'cls': c2, 'score': sc + base} for c2, sc in ordered[:10]]
    wn, bc = _collect_widget_notices(cls, grade, 6)
    sem_net = sum(r.get('score') or 0 for r in mine)
    sem_total = BASE_PER_DAY * semester_days + sem_net
    # 段位:每 2000 分一段,共 7 段(北斗七星,升一段点亮一星)
    _TIER_SPAN = 2000
    tier_lvl = min(7, max(1, sem_total // _TIER_SPAN + 1))
    tier_prog = sem_total - (tier_lvl - 1) * _TIER_SPAN
    tier = {'level': tier_lvl, 'progress': tier_prog, 'need': _TIER_SPAN,
            'to_next': None if tier_lvl >= 7 else _TIER_SPAN - tier_prog}
    # 好人好事竞赛榜:按学生累计(类型=加分、学生非空),分高在前
    _dr_pool = {}
    for r in mine:
        if r.get('type') == '加分':
            _s = (r.get('student') or '').strip()
            if not _s:
                continue
            _e = _dr_pool.setdefault(_s, {'student': _s, 'count': 0, 'score': 0})
            _e['count'] += 1
            _e['score'] += r.get('score') or 0
    deeds_rank = sorted(_dr_pool.values(), key=lambda x: (-x['score'], -x['count']))[:5]
    data = {
        'cls': cls, 'grade': grade,
        'today': agg([r for r in mine if (r.get('_ts') or 0) >= day0]),
        'week': agg([r for r in mine if (r.get('_ts') or 0) >= mon0]),
        'total': agg(mine),
        'semester': {'name': sem_name, 'start': str(cfg.get('semester_start') or '2026-09-01'), 'end': sem_end,
                     'days': semester_days, 'base': BASE_PER_DAY * semester_days,
                     'net': sem_net, 'total': sem_total, 'tier': tier},
        'rank': {'rank': rank, 'total': total_cls, 'score': grade_score, 'top': board_list,
                 'mode': rank_mode, 'days': period_days, 'base': BASE_PER_DAY},
        'latest': [{'time': r.get('time'), 'item': r.get('item'), 'score': r.get('score'),
                    'type': r.get('type'), 'student': r.get('student')}
                   for r in mine if (r.get('_ts') or 0) >= day0 - 6 * 86400000][:20],
        'deeds': [{'time': r.get('time'), 'item': r.get('item'), 'score': r.get('score'),
                   'student': r.get('student'), 'desc': r.get('desc')}
                  for r in mine if r.get('type') == '加分'
                  and (_deeds_days <= 0 or (r.get('_ts') or 0) >= now - _deeds_days * 86400)][:8],
        'deeds_rank': deeds_rank,
        'notices': wn,
        'broadcasts': bc,
        'duties': _collect_widget_duties(),
        'ts': int(now * 1000),
    }
    _widget_cache.update({'key': cls, 'v': data, 'exp': now + 20})
    return jsonify(ok=True, **data)

# ---------- 德育电子班牌:广播 / 好人好事审核 / 排名口径 ----------

def fe_base():
    return 'https://open.feishu.cn/open-apis/bitable/v1/apps/' + load_cfg()['app_token']

def fe_field_names(tid):
    cfg = load_cfg()
    d = HTTP.get(fe_base() + '/tables/' + tid + '/fields?page_size=100', headers=bh(), timeout=20).json()
    if d.get('code') != 0:
        return []
    return [f.get('field_name') for f in ((d.get('data') or {}).get('items') or [])]

def fe_create_field(tid, payload):
    d = HTTP.post(fe_base() + '/tables/' + tid + '/fields', headers=bh(), json=payload, timeout=20).json()
    return d.get('code') == 0

_notice_fields_ok = False
def ensure_notice_fields():
    """广播字段:范围(文本,逗号分隔)/紧急(复选框)/过期时间(数字ms),缺失自动创建"""
    global _notice_fields_ok
    if _notice_fields_ok:
        return
    try:
        tid = load_cfg().get('tid_notices')
        if not tid:
            return
        have = set(fe_field_names(tid))
        if '范围' not in have:
            fe_create_field(tid, {'field_name': '范围', 'type': 1})
        if '紧急' not in have:
            fe_create_field(tid, {'field_name': '紧急', 'type': 7})
        if '过期时间' not in have:
            fe_create_field(tid, {'field_name': '过期时间', 'type': 2})
        _notice_fields_ok = True
    except Exception:
        pass

_deeds_tid = ''
def deeds_tid():
    """好人好事表:config 配了就用,没有则自动建表"""
    global _deeds_tid
    if _deeds_tid:
        return _deeds_tid
    cfg = load_cfg()
    tid = cfg.get('tid_deeds')
    if tid:
        _deeds_tid = tid
        return tid
    fields = [
        {'field_name': '提交时间', 'type': 2},
        {'field_name': '发起人', 'type': 1},
        {'field_name': '班级', 'type': 1},
        {'field_name': '学生', 'type': 1},
        {'field_name': '事项', 'type': 1},
        {'field_name': '事实描述', 'type': 1},
        {'field_name': '建议分值', 'type': 2},
        {'field_name': '状态', 'type': 1},
        {'field_name': '处理意见', 'type': 1},
        {'field_name': '审核时间', 'type': 2},
        {'field_name': '关联记录', 'type': 1},
    ]
    d = HTTP.post(fe_base() + '/tables', headers=bh(),
                  json={'table': {'name': '好人好事(班牌)', 'fields': fields}}, timeout=25).json()
    if d.get('code') != 0:
        raise RuntimeError('创建好人好事表失败: ' + str(d.get('msg')))
    tid = (d.get('data') or {}).get('table_id') or ''
    if not tid:
        raise RuntimeError('创建好人好事表失败: 未返回 table_id')
    cfg['tid_deeds'] = tid
    save_cfg(cfg)
    _deeds_tid = tid
    write_log('自动建表', '好人好事(班牌)', 'tid=' + tid)
    return tid

def norm_deed(item):
    f = item.get('fields') or {}
    ts = num(f.get('提交时间'))
    ats = num(f.get('审核时间'))
    return {
        'did': item.get('record_id'),
        'time': time.strftime('%m-%d %H:%M', time.localtime(ts / 1000)) if ts else '',
        '_ts': ts,
        'by': rt(f.get('发起人')) or '', 'cls': rt(f.get('班级')) or '',
        'student': rt(f.get('学生')) or '', 'item': rt(f.get('事项')) or '',
        'desc': rt(f.get('事实描述')) or '', 'score': num(f.get('建议分值'), 1),
        'status': rt(f.get('状态')) or '待审核', 'opinion': rt(f.get('处理意见')) or '',
        'review_time': time.strftime('%m-%d %H:%M', time.localtime(ats / 1000)) if ats else '',
        'rid': rt(f.get('关联记录')) or '',
    }

@app.route('/api/deeds')
def list_deeds():
    auth = check_pw_any(_hdr_pw() or request.args.get('pw'), _hdr_grade())
    if not auth:
        return jsonify(ok=False, msg='口令验证失败'), 401
    try:
        tid = deeds_tid()
    except Exception as e:
        return jsonify(ok=False, msg=str(e)[:120]), 500
    out = [norm_deed(i) for i in fe_list_cached(tid, 45)]
    if auth[0] == 'grade':
        g = auth[1]
        out = [x for x in out if grade_of_cls(x.get('cls')) == g]
    out.sort(key=lambda x: (x['status'] != '待审核', -x['_ts']))
    return jsonify(ok=True, deeds=out[:100], grade=auth[1] if auth[0] == 'grade' else '')

@app.route('/api/deeds', methods=['POST'])
def add_deed():
    b = request.get_json(force=True)
    wt = (load_cfg().get('widget_token') or '').strip()
    if not (check_pw('admin', b.get('admin_password') or '') or check_pw('reg', b.get('reg_password') or '')
            or (wt and b.get('token') == wt)):
        return jsonify(ok=False, msg='口令验证失败(需登记口令/管理口令/挂件令牌)'), 401
    for k, lab in (('by', '发起人'), ('student', '学生'), ('item', '事项')):
        if not (b.get(k) or '').strip():
            return jsonify(ok=False, msg='请填写:' + lab), 400
    try:
        tid = deeds_tid()
    except Exception as e:
        return jsonify(ok=False, msg=str(e)[:120]), 500
    fields = {'提交时间': int(time.time() * 1000),
              '发起人': b['by'].strip(), '班级': (b.get('cls') or '').strip(),
              '学生': b['student'].strip(), '事项': b['item'].strip(),
              '事实描述': (b.get('desc') or '').strip(),
              '建议分值': num(b.get('score'), 1), '状态': '待审核'}
    d = HTTP.post(fe_url(tid), headers=bh(), json={'fields': fields}, timeout=20).json()
    if d.get('code') != 0:
        return jsonify(ok=False, msg='提交失败: ' + str(d.get('msg'))), 500
    write_log('发起好人好事', b['student'].strip() + '·' + b['item'].strip())
    return jsonify(ok=True)

@app.route('/api/deeds/<did>/approve', methods=['POST'])
def approve_deed(did):
    b = request.get_json(force=True) or {}
    auth = check_pw_any(_hdr_pw() or b.get('admin_password'), _hdr_grade())
    if not auth:
        return jsonify(ok=False, msg='口令验证失败（需管理口令或年级管理口令）'), 401
    role, ggrade = auth
    try:
        score = float(b.get('score'))
    except (TypeError, ValueError):
        return jsonify(ok=False, msg='加分分值必须是数字'), 400
    if score <= 0:
        return jsonify(ok=False, msg='加分分值必须大于 0'), 400
    try:
        tid = deeds_tid()
    except Exception as e:
        return jsonify(ok=False, msg=str(e)[:120]), 500
    d = HTTP.get(fe_url(tid) + '/' + did, headers=bh(), timeout=15).json()
    rec = ((d.get('data') or {}).get('record') or {}).get('fields') or {}
    if rt(rec.get('状态')) not in ('', '待审核'):
        return jsonify(ok=False, msg='该记录已处理过'), 400
    cls = rt(rec.get('班级')) or ''
    if role == 'grade':
        # 年级管理只能审核本年级班级发起的好人好事
        if grade_of_cls(cls) != ggrade:
            return jsonify(ok=False, msg='该好人好事来自「' + (cls or '未填班级') + '」，不属于「' + ggrade + '」，无法审核'), 403
    grade = ''
    try:
        cfg = load_cfg()
        for item in list_records_raw(cfg.get('tid_classes')):
            f = item.get('fields') or {}
            g, c = f.get('年级'), f.get('班级')
            if g and c:
                if c == cls:
                    grade = g
                    break
    except Exception:
        pass
    rfields = {'检查时间': int(time.time() * 1000), '年级': grade, '班级': cls,
               '部门': '班牌好人好事', '事项细项': rt(rec.get('事项')) or '好人好事',
               '类型': '加分', '分值': abs(score),
               '事实描述': (rt(rec.get('事实描述')) or '')[:200],
               '使用人': rt(rec.get('发起人')) or '班牌',
               '学生': rt(rec.get('学生')) or '', '登记来源': '班牌'}
    rd = HTTP.post(fe_url(load_cfg()['tid_records']), headers=bh(), json={'fields': rfields}, timeout=20).json()
    if rd.get('code') != 0:
        return jsonify(ok=False, msg='写入加分记录失败: ' + str(rd.get('msg'))), 500
    rid = rd['data']['record']['record_id']
    HTTP.put(fe_url(tid) + '/' + did, headers=bh(),
             json={'fields': {'状态': '已通过', '处理意见': (b.get('opinion') or '').strip()[:100],
                              '审核时间': int(time.time() * 1000), '关联记录': rid}}, timeout=20)
    write_log('好人好事通过', (rt(rec.get('学生')) or '') + '+' + str(score), 'rid=' + rid + ((' · 年级管理·' + ggrade) if role == 'grade' else ''))
    return jsonify(ok=True, rid=rid)

@app.route('/api/deeds/<did>/reject', methods=['POST'])
def reject_deed(did):
    b = request.get_json(force=True) or {}
    auth = check_pw_any(_hdr_pw() or b.get('admin_password'), _hdr_grade())
    if not auth:
        return jsonify(ok=False, msg='口令验证失败（需管理口令或年级管理口令）'), 401
    role, ggrade = auth
    try:
        tid = deeds_tid()
    except Exception as e:
        return jsonify(ok=False, msg=str(e)[:120]), 500
    if role == 'grade':
        d = HTTP.get(fe_url(tid) + '/' + did, headers=bh(), timeout=15).json()
        cls = rt(((d.get('data') or {}).get('record') or {}).get('fields', {}).get('班级')) or ''
        if grade_of_cls(cls) != ggrade:
            return jsonify(ok=False, msg='该好人好事来自「' + (cls or '未填班级') + '」，不属于「' + ggrade + '」，无法审核'), 403
    HTTP.put(fe_url(tid) + '/' + did, headers=bh(),
             json={'fields': {'状态': '已驳回', '处理意见': (b.get('opinion') or '不符合要求').strip()[:100],
                              '审核时间': int(time.time() * 1000)}}, timeout=20)
    write_log('好人好事驳回', 'did=' + did, ('年级管理·' + ggrade) if role == 'grade' else '')
    return jsonify(ok=True)

@app.route('/api/board/broadcast', methods=['POST'])
def board_broadcast():
    b = request.get_json(force=True)
    auth = check_pw_any(_hdr_pw() or b.get('admin_password'), _hdr_grade())
    if not auth:
        return jsonify(ok=False, msg='口令验证失败（需管理口令或年级管理口令）'), 401
    role, ggrade = auth
    if role == 'grade':
        # 年级管理：范围强制为本年级，紧急/置顶/自选范围全部丢弃
        b['scopes'] = [ggrade]
        b['urgent'] = False
        b['pin'] = False
    title = (b.get('title') or '').strip()
    content = (b.get('content') or '').strip()
    if not title or not content:
        return jsonify(ok=False, msg='标题与内容必填'), 400
    cfg = load_cfg()
    tid = cfg.get('tid_notices')
    if not tid:
        return jsonify(ok=False, msg='未配置公告表'), 500
    ensure_notice_fields()
    scopes = [str(s).strip() for s in (b.get('scopes') or []) if str(s).strip()]
    fields = {'标题': title, '内容': content,
              '发布人': (b.get('by') or '管理员').strip()[:20],
              '发布时间': int(time.time() * 1000)}
    if scopes:
        fields['范围'] = ','.join(scopes)
    if b.get('urgent'):
        fields['紧急'] = True
    if b.get('pin'):
        fields['置顶'] = ['置顶']
    if b.get('expire_str'):
        try:
            tt = time.strptime(b['expire_str'], '%Y-%m-%d %H:%M')
            fields['过期时间'] = int(time.mktime(tt) * 1000)
        except ValueError:
            return jsonify(ok=False, msg='过期时间格式应为 2026-10-18 18:00'), 400
    d = HTTP.post(fe_url(tid), headers=bh(), json={'fields': fields}, timeout=20).json()
    if d.get('code') != 0:
        return jsonify(ok=False, msg='发布失败: ' + str(d.get('msg'))), 500
    who = '年级管理·' + ggrade if role == 'grade' else '管理员'
    write_log('发布广播', title[:30] + (' [紧急]' if b.get('urgent') else ''), '范围=' + (','.join(scopes) or '全校') + ' · ' + who)
    return jsonify(ok=True)

@app.route('/api/board/settings', methods=['GET', 'POST'])
def board_settings():
    cfg = load_cfg()
    if request.method == 'POST':
        b = request.get_json(force=True)
        if not check_pw('admin', _hdr_pw() or b.get('admin_password')):
            return jsonify(ok=False, msg='管理口令验证失败'), 401
        mode = b.get('rank_mode')
        if mode not in ('week', 'month', 'total'):
            return jsonify(ok=False, msg='rank_mode 必须是 week / month / total'), 400
        cfg['widget_rank_mode'] = mode
        sstart = str(b.get('semester_start') or '').strip()
        if sstart:
            try:
                time.strptime(sstart, '%Y-%m-%d')
                cfg['semester_start'] = sstart
            except Exception:
                return jsonify(ok=False, msg='学期起始日需为 YYYY-MM-DD'), 400
        # 学期名称(如:2026年秋季学期)与结束日 —— 全系统统一口径,统计导出共用
        if 'semester_name' in b:
            cfg['semester_name'] = str(b.get('semester_name') or '').strip()[:30]
        if 'semester_end' in b:
            send = str(b.get('semester_end') or '').strip()
            if send:
                try:
                    time.strptime(send, '%Y-%m-%d')
                except Exception:
                    return jsonify(ok=False, msg='学期结束日需为 YYYY-MM-DD'), 400
                if sstart and send < sstart:
                    return jsonify(ok=False, msg='学期结束日不能早于起始日'), 400
                cfg['semester_end'] = send
            else:
                cfg['semester_end'] = ''
        # 好人好事上榜天数(0=一直展示,上限 365)
        if 'deeds_board_days' in b:
            try:
                dd = int(float(b.get('deeds_board_days')))
            except (TypeError, ValueError):
                return jsonify(ok=False, msg='上榜天数需为数字'), 400
            cfg['deeds_board_days'] = max(0, min(dd, 365))
        # 重复登记提醒窗口(分钟,0=关闭查重)
        if 'dedup_window_min' in b:
            try:
                dm = int(float(b.get('dedup_window_min')))
            except (TypeError, ValueError):
                return jsonify(ok=False, msg='重复提醒窗口需为数字'), 400
            cfg['dedup_window_min'] = max(0, min(dm, 720))
        save_cfg(cfg)
        _widget_cache['exp'] = 0
        write_log('班牌设置', '排名口径=' + mode
                  + ((' 学期=' + str(cfg.get('semester_name'))) if cfg.get('semester_name') else '')
                  + (' 起止=' + str(cfg.get('semester_start')) + '~' + str(cfg.get('semester_end') or '未设') if cfg.get('semester_end') else '')
                  + (' 好人好事上榜=' + str(cfg.get('deeds_board_days')) + '天' if 'deeds_board_days' in b else ''))
        return jsonify(ok=True, rank_mode=mode)
    return jsonify(ok=True, rank_mode=cfg.get('widget_rank_mode') or 'week',
                   semester_name=cfg.get('semester_name') or '',
                   semester_start=cfg.get('semester_start') or '2026-09-01',
                   semester_end=cfg.get('semester_end') or '',
                   deeds_board_days=num(cfg.get('deeds_board_days'), 7),
                   dedup_window_min=num(cfg.get('dedup_window_min'), 60))

@app.route('/api/widget/classes')
def widget_classes():
    cfg = load_cfg()
    wt = (cfg.get('widget_token') or '').strip()
    if wt and request.args.get('token') != wt:
        return jsonify(ok=False, msg='token 无效'), 401
    classes = {}
    tid = cfg.get('tid_classes')
    if tid:
        try:
            for item in fe_list_cached(tid, 300):
                f = item.get('fields') or {}
                g, c = f.get('年级'), f.get('班级')
                if g and c:
                    classes.setdefault(g, [])
                    if c not in classes[g]:
                        classes[g].append(c)
        except Exception:
            pass
    if not classes:
        classes = cfg.get('classes', {})
    for g in GRADE_ORDER:
        classes.setdefault(g, [])
    return jsonify(ok=True, classes=classes)

# ---------- 班牌挂件自动更新:updates/ 目录放新版安装包 + latest.yml ----------
UPDATES_DIR = os.path.join(BASE, 'updates')
os.makedirs(UPDATES_DIR, exist_ok=True)

@app.route('/updates/<path:fname>')
def widget_updates(fname):
    return send_from_directory(UPDATES_DIR, fname)

@app.route('/api/ping')
def ping():
    """桌面壳端口寻址的身份探测点：确认 127.0.0.1:<port> 上跑的是德育系统而非其他程序"""
    return jsonify(ok=True, app='deyu')

# ---------- 桌面版热更新:文件 SHA256 供客户端比对(app.py / templates/index.html) ----------
APP_VERSION = '2026.11.16c'

def _file_sha(path):
    try:
        with open(path, 'rb') as f:
            return hashlib.sha256(f.read()).hexdigest()
    except Exception:
        return ''

@app.route('/api/version')
def api_version():
    """桌面版启动时比对：服务端与本地 app.py / index.html / paper_ocr.py 内容是否一致"""
    return jsonify(ok=True, app_version=APP_VERSION,
                   app_sha=_file_sha(os.path.join(BASE, 'app.py')),
                   index_sha=_file_sha(os.path.join(BASE, 'templates', 'index.html')),
                   paper_ocr_sha=_file_sha(os.path.join(BASE, 'paper_ocr.py')))

@app.route('/api/export_save', methods=['POST'])
def export_save():
    """桌面版导出落盘：pywebview 内核会静默拦掉 a.download，
    改为前端把图片/CSV 交给本接口写到「桌面\\德育导出」，返回真实路径"""
    b = request.get_json(force=True)
    raw_name = (b.get('name') or 'export.png').strip()
    name = ''.join(ch for ch in raw_name if ch not in '\\/:*?"<>|')[:80] or 'export.png'
    desk = os.path.join(os.path.expanduser('~'), 'Desktop')
    if not os.path.isdir(desk):
        desk = os.path.expanduser('~')
    outdir = os.path.join(desk, '德育导出')
    try:
        os.makedirs(outdir, exist_ok=True)
        path = os.path.join(outdir, name)
        if b.get('data_url'):
            du = b['data_url']
            if not str(du).startswith('data:'):
                return jsonify(ok=False, msg='图片数据无效'), 400
            raw = base64.b64decode(str(du).split(',', 1)[1])
            with open(path, 'wb') as f:
                f.write(raw)
        elif b.get('text') is not None:
            with open(path, 'wb') as f:
                f.write(str(b['text']).encode('utf-8'))
        else:
            return jsonify(ok=False, msg='没有要保存的内容'), 400
        return jsonify(ok=True, path=path, size=os.path.getsize(path))
    except Exception as e:
        return jsonify(ok=False, msg='写入失败: ' + str(e)), 500

# ---------- 宿舍安排(房间×班级一行,替代床位表,防 2000 行超限) ----------
_dorm_assign_tid = ''

def find_table_id_by_name(name):
    """按表名查 table_id——建表撞名(TableNameDuplicated)或配置缺失时复用已有表"""
    try:
        d = HTTP.get(fe_base() + '/tables?page_size=100', headers=bh(), timeout=20).json()
        for t in ((d.get('data') or {}).get('items') or []):
            if (t.get('name') or '') == name:
                return t.get('table_id') or ''
    except Exception:
        pass
    return ''

def dorm_assign_tid():
    """宿舍安排表:config 配了就用;没配则先按名字找已有表复用,实在没有才新建"""
    global _dorm_assign_tid
    if _dorm_assign_tid:
        return _dorm_assign_tid
    cfg = load_cfg()
    tid = cfg.get('tid_dorm_assigns')
    if tid:
        _dorm_assign_tid = tid
        return tid
    # 配置缺失(如老安装包的 config)——先复用同名表,避免撞名报错
    tid = find_table_id_by_name('宿舍安排(班牌)')
    if tid:
        cfg['tid_dorm_assigns'] = tid
        save_cfg(cfg)
        _dorm_assign_tid = tid
        return tid
    fields = [
        {'field_name': '学期', 'type': 1},
        {'field_name': '楼栋', 'type': 1},
        {'field_name': '楼层', 'type': 2},
        {'field_name': '房间', 'type': 1},
        {'field_name': '班级', 'type': 1},
        {'field_name': '年级', 'type': 1},
        {'field_name': '人数', 'type': 2},
        {'field_name': '标签', 'type': 1},
        {'field_name': '学生名单', 'type': 1},
    ]
    d = HTTP.post(fe_base() + '/tables', headers=bh(),
                  json={'table': {'name': '宿舍安排(班牌)', 'fields': fields}}, timeout=25).json()
    if d.get('code') != 0:
        msg = str(d.get('msg') or '')
        if 'Duplicate' in msg or '同名' in msg:
            tid = find_table_id_by_name('宿舍安排(班牌)')
            if tid:
                cfg['tid_dorm_assigns'] = tid
                save_cfg(cfg)
                _dorm_assign_tid = tid
                return tid
        raise RuntimeError('创建宿舍安排表失败: ' + msg)
    tid = (d.get('data') or {}).get('table_id') or ''
    if not tid:
        raise RuntimeError('创建宿舍安排表失败: 未返回 table_id')
    cfg['tid_dorm_assigns'] = tid
    save_cfg(cfg)
    _dorm_assign_tid = tid
    write_log('自动建表', '宿舍安排(班牌)', 'tid=' + tid)
    return tid

def norm_dorm_assign(item):
    f = item.get('fields') or {}
    return {'rid': item.get('record_id'),
            'semester': rt(f.get('学期')) or '', 'building': rt(f.get('楼栋')) or '',
            'floor': int(num(f.get('楼层'), 0)), 'room': rt(f.get('房间')) or '',
            'cls': rt(f.get('班级')) or '', 'grade': rt(f.get('年级')) or '',
            'n': int(num(f.get('人数'), 0)), 'tag': rt(f.get('标签')) or '',
            'names': rt(f.get('学生名单')) or ''}

def _room_key(x):
    r = x.get('room') or ''
    return (x.get('building') or '', int(r) if r.isdigit() else 0, r, -(x.get('n') or 0))

@app.route('/api/dorm_assigns')
def get_dorm_assigns():
    try:
        tid = dorm_assign_tid()
    except Exception as e:
        return jsonify(ok=False, msg=str(e)[:120]), 500
    try:
        rows = [norm_dorm_assign(i) for i in fe_list_cached(tid, 60)]
    except Exception as e:
        return jsonify(ok=False, msg='读取宿舍安排失败: ' + str(e)[:100]), 500
    rows.sort(key=_room_key)
    sems = sorted({r['semester'] for r in rows if r['semester']}, reverse=True)
    return jsonify(ok=True, rows=rows, semesters=sems)

@app.route('/api/dorm_assigns', methods=['POST'])
def import_dorm_assigns():
    """批量导入;purge='all' 清全部旧学期(默认策略),'semester' 只清同学期"""
    b = request.get_json(force=True)
    if not check_pw('admin', b.get('admin_password')):
        return jsonify(ok=False, msg='管理口令验证失败'), 401
    purge = b.get('purge') or ''
    rows = b.get('rows') or []
    sem = str(b.get('semester') or '').strip()[:20]
    if not rows and purge not in ('all', 'semester'):
        return jsonify(ok=False, msg='没有可导入的安排'), 400
    if purge == 'semester' and not sem:
        return jsonify(ok=False, msg='按学期清理需指定学期'), 400
    try:
        tid = dorm_assign_tid()
    except Exception as e:
        return jsonify(ok=False, msg=str(e)[:120]), 500
    removed = 0
    if purge in ('all', 'semester'):
        stale = []
        for it in list_records_raw(tid):
            if purge == 'semester' and (rt((it.get('fields') or {}).get('学期')) or '') != sem:
                continue
            stale.append(it.get('record_id'))
        for i in range(0, len(stale), 500):
            chunk = stale[i:i + 500]
            r = HTTP.delete(fe_url(tid) + '/batch_delete', headers=bh(),
                            json={'records': chunk}, timeout=40).json()
            if r.get('code') == 0:
                removed += len(chunk)
            else:
                for rid in chunk:
                    try:
                        HTTP.delete(fe_url(tid) + '/' + rid, headers=bh(), timeout=20)
                        removed += 1
                    except Exception:
                        pass
    records = []
    for r in rows:
        room = str(r.get('room') or '')[:20]
        try:
            fl = int(float(r.get('floor') or 0))
        except (TypeError, ValueError):
            fl = 0
        if not fl and room[:1].isdigit():
            fl = int(room[:1])
        try:
            nn = int(float(r.get('n') or 0))
        except (TypeError, ValueError):
            nn = 0
        records.append({'fields': {
            '学期': str(r.get('semester') or sem)[:20],
            '楼栋': str(r.get('building') or '')[:30], '楼层': fl,
            '房间': room, '班级': str(r.get('cls') or '')[:30],
            '年级': str(r.get('grade') or '')[:10], '人数': nn,
            '标签': str(r.get('tag') or '')[:20],
            '学生名单': str(r.get('names') or '')[:200]}})
    n = 0
    for i in range(0, len(records), 400):
        chunk = records[i:i + 400]
        d = HTTP.post(fe_url(tid) + '/batch_create', headers=bh(),
                      json={'records': chunk}, timeout=60).json()
        if d.get('code') != 0:
            return jsonify(ok=False, msg='写入失败: ' + str(d.get('msg')), done=n, removed=removed), 500
        n += len(chunk)
    write_log('导入宿舍安排', (sem or '未标学期'), '共 %d 条%s' % (n, ('，清旧 %d 条' % removed) if removed else ''))
    return jsonify(ok=True, count=n, removed=removed)

@app.route('/api/dorm_assigns/<rid>', methods=['PUT'])
def edit_dorm_assign(rid):
    b = request.get_json(force=True) or {}
    # 管理员或持有登记口令的宿管登记员均可修正（宿舍安排表为宿管一线维护数据，操作写日志留痕）
    pw = _hdr_pw() or b.get('admin_password') or b.get('reg_password')
    if not (check_pw('admin', pw) or check_pw('reg', pw)):
        return jsonify(ok=False, msg='口令验证失败（需管理口令或登记口令）'), 401
    try:
        tid = dorm_assign_tid()
    except Exception as e:
        return jsonify(ok=False, msg=str(e)[:120]), 500
    fmap = {'semester': ('学期', 20), 'building': ('楼栋', 30), 'room': ('房间', 20),
            'cls': ('班级', 30), 'grade': ('年级', 10), 'tag': ('标签', 20), 'names': ('学生名单', 200)}
    fields = {}
    for k, (col, ln) in fmap.items():
        if k in b:
            fields[col] = str(b.get(k) or '')[:ln]
    if 'n' in b:
        try:
            fields['人数'] = int(float(b.get('n') or 0))
        except (TypeError, ValueError):
            pass
    if 'floor' in b:
        try:
            fields['楼层'] = int(float(b.get('floor') or 0))
        except (TypeError, ValueError):
            pass
    if not fields:
        return jsonify(ok=False, msg='没有要修改的内容'), 400
    d = HTTP.put(fe_url(tid) + '/' + rid, headers=bh(), json={'fields': fields}, timeout=20).json()
    if d.get('code') == 0:
        write_log('改宿舍安排', 'rid=' + rid, json.dumps(fields, ensure_ascii=False)[:200])
    return jsonify(ok=d.get('code') == 0, msg=d.get('msg'))

@app.route('/api/dorm_assigns/<rid>', methods=['DELETE'])
def del_dorm_assign(rid):
    if not check_pw('admin', _hdr_pw()):
        return jsonify(ok=False, msg='管理口令验证失败'), 401
    try:
        tid = dorm_assign_tid()
    except Exception as e:
        return jsonify(ok=False, msg=str(e)[:120]), 500
    d = HTTP.delete(fe_url(tid) + '/' + rid, headers=bh(), timeout=20).json()
    if d.get('code') == 0:
        write_log('删宿舍安排', 'rid=' + rid)
    return jsonify(ok=d.get('code') == 0, msg=d.get('msg'))

@app.route('/api/dorm_assigns/template')
def dorm_assign_template():
    wb = Workbook()
    ws = wb.active
    ws.title = '宿舍安排导入'
    ws.append(['学期', '楼栋', '楼层', '房间', '班级', '年级', '人数', '标签（可空）', '学生名单（可空）'])
    ws.append(['2026秋', '竹升楼', 6, '614', '高一（7）班', '高一', 13, '', ''])
    ws.append(['2026秋', '竹升楼', 6, '612', '高一（7）班', '高一', 8, '混寝', ''])
    ws.append(['2026秋', '竹升楼', 6, '612', '高一（8）班', '高一', 5, '混寝', ''])
    for col, w in zip('ABCDEFGHI', (10, 14, 8, 10, 18, 10, 8, 14, 22)):
        ws.column_dimensions[col].width = w
    for c in ws[1]:
        c.font = XlFont(bold=True)
    buf = io.BytesIO()
    wb.save(buf)
    return Response(buf.getvalue(), mimetype='application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
        headers={'Content-Disposition': 'attachment; filename=dorm_assign_template.xlsx'})

def _guess_grade(cls):
    for g in ('初一', '初二', '初三', '高一', '高二', '高三'):
        if (cls or '').startswith(g):
            return g
    return ''

@app.route('/api/dorm_assigns/parse_excel', methods=['POST'])
def parse_dorm_assign_excel():
    b = request.get_json(force=True)
    if not check_pw('admin', b.get('admin_password')):
        return jsonify(ok=False, msg='管理口令验证失败'), 401
    try:
        raw = base64.b64decode(b.get('data_b64') or '')
        wb = load_workbook(io.BytesIO(raw), read_only=True, data_only=True)
    except Exception:
        return jsonify(ok=False, msg='无法读取该文件，请用 .xlsx 格式（建议先下载模板填写）'), 400
    ws = wb.active
    sem0 = str(b.get('semester') or '').strip()[:20]
    rows, errors = [], []
    for i, row in enumerate(ws.iter_rows(min_row=2, values_only=True), start=2):
        vals = [_cell_str(v) for v in (list(row) + [None] * 9)[:9]]
        sem, building, floor, room, cls, grade, n, tag, names = vals
        if not any([sem, building, room, cls, n]):
            continue
        miss = [lbl for lbl, v in (('楼栋', building), ('房间', room), ('班级', cls)) if not v]
        if miss:
            errors.append('第 %d 行缺：%s' % (i, '、'.join(miss)))
            continue
        try:
            nn = int(float(n)) if n else 0
        except (TypeError, ValueError):
            nn = 0
        if nn <= 0:
            errors.append('第 %d 行人数无效：%s' % (i, n or '空'))
            continue
        try:
            fl = int(float(floor)) if floor else 0
        except (TypeError, ValueError):
            fl = 0
        if not fl and room[:1].isdigit():
            fl = int(room[:1])
        rows.append({'semester': (sem or sem0)[:20], 'building': building[:30], 'floor': fl,
                     'room': room[:20], 'cls': cls[:30], 'grade': (grade or _guess_grade(cls))[:10],
                     'n': nn, 'tag': tag[:20], 'names': names[:200]})
    if not rows and not errors:
        return jsonify(ok=False, msg='表格里没有数据行（第 1 行是表头，从第 2 行开始填）'), 400
    return jsonify(ok=True, rows=rows, errors=errors, total=len(rows))

# ---------- 宿舍床位：Excel 模板与导入 ----------
def _cell_str(v):
    """Excel 单元格统一转字符串（数字 302.0 -> '302'）"""
    if v is None:
        return ''
    if isinstance(v, float) and v.is_integer():
        return str(int(v))
    return str(v).strip()

@app.route('/api/dorms/template')
def dorm_template():
    cfg = load_cfg()
    wb = Workbook()
    ws = wb.active
    ws.title = '床位导入'
    ws.append(['楼栋', '房间', '床位', '年级', '班级', '姓名（可空）'])
    ws.append(['男生1栋', '302', '1', '高一', '高一（1）班', '张三'])
    ws.append(['男生1栋', '302', '2', '高一', '高一（5）班', '李四'])
    for col, w in zip('ABCDEF', (14, 10, 10, 10, 16, 14)):
        ws.column_dimensions[col].width = w
    for c in ws[1]:
        c.font = XlFont(bold=True)
    ws2 = wb.create_sheet('选项')
    ws2['A1'] = '年级'
    ws2['B1'] = '班级'
    grades = ['高一', '高二', '高三']
    classes = []
    for g in grades:
        classes += (cfg.get('classes') or {}).get(g) or []
    for i, g in enumerate(grades, start=2):
        ws2.cell(row=i, column=1, value=g)
    for i, cname in enumerate(classes, start=2):
        ws2.cell(row=i, column=2, value=cname)
    ws2.sheet_state = 'hidden'
    if classes:
        dv_g = DataValidation(type='list', formula1='=选项!$A$2:$A$4', allow_blank=True)
        dv_c = DataValidation(type='list', formula1='=选项!$B$2:$B$%d' % (len(classes) + 1), allow_blank=True)
        ws.add_data_validation(dv_g)
        ws.add_data_validation(dv_c)
        dv_g.add('D2:D1000')
        dv_c.add('E2:E1000')
    buf = io.BytesIO()
    wb.save(buf)
    return Response(buf.getvalue(), mimetype='application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
        headers={'Content-Disposition': 'attachment; filename=dorm_template.xlsx'})

@app.route('/api/dorms/parse_excel', methods=['POST'])
def parse_dorm_excel():
    b = request.get_json(force=True)
    if not check_pw('admin', b.get('admin_password')):
        return jsonify(ok=False, msg='管理口令验证失败'), 401
    try:
        raw = base64.b64decode(b.get('data_b64') or '')
        wb = load_workbook(io.BytesIO(raw), read_only=True, data_only=True)
    except Exception:
        return jsonify(ok=False, msg='无法读取该文件，请用 .xlsx 格式（建议先下载模板填写）'), 400
    ws = wb.active
    rows, errors = [], []
    for i, row in enumerate(ws.iter_rows(min_row=2, values_only=True), start=2):
        vals = [_cell_str(v) for v in (list(row) + [None] * 6)[:6]]
        building, room, bed, grade, cls, name = vals
        if not any([building, room, bed, cls, name]):
            continue
        miss = [lbl for lbl, v in (('楼栋', building), ('房间', room), ('床位', bed), ('班级', cls)) if not v]
        if miss:
            errors.append('第 %d 行缺：%s' % (i, '、'.join(miss)))
            continue
        rows.append({'building': building[:30], 'room': room[:20], 'bed': bed[:10],
                     'grade': grade[:10], 'cls': cls[:30], 'name': name[:30]})
    if not rows and not errors:
        return jsonify(ok=False, msg='表格里没有数据行（第 1 行是表头，从第 2 行开始填）'), 400
    return jsonify(ok=True, rows=rows, errors=errors, total=len(rows))

# ---------- 桌面版 _internal numpy 自愈（2026-11-06） ----------
def _auto_numpy_patch():
    """旧打包的 _internal 缺 numpy/core 等二进制（PyInstaller hook 未适配 numpy 2.5.3），
    桌面版启动时检测并自动从云端下载补丁解压到 _internal（仅 Windows 桌面执行一次）。"""
    try:
        if os.environ.get('DEYU_NO_NUMPY_PATCH') == '1':
            return
        import platform as _pf
        if _pf.system().lower() != 'windows':
            return
        exe_dir = os.path.dirname(sys.executable) if getattr(sys, 'frozen', False) else BASE
        marker = os.path.join(exe_dir, '_internal', 'numpy', 'core', 'multiarray.py')
        if os.path.isfile(marker):
            return
        def _work():
            try:
                url = (load_cfg().get('update_url') or 'https://deyu.cahym.cn').rstrip('/') + '/updates/engine/numpy_fix_hotfix.zip'
                tmp = os.path.join(exe_dir, '_internal', 'numpy_fix_dl.zip')
                r = HTTP.get(url, timeout=90)
                with open(tmp, 'wb') as f:
                    f.write(r.content)
                with _zipfile.ZipFile(tmp) as z:
                    z.extractall(os.path.join(exe_dir, '_internal'))
                os.remove(tmp)
                write_log('numpy自愈', '自动补齐 _internal/numpy')
            except Exception:
                pass
        threading.Thread(target=_work, daemon=True).start()
    except Exception:
        pass
_auto_numpy_patch()

if __name__ == '__main__':
    # DEYU_RELOAD=1 开启热更新:改 app.py / templates 后自动重启进程,无需手动重启服务
    _reload = os.environ.get('DEYU_RELOAD') == '1'
    if not os.environ.get('DEYU_NO_BROWSER') and (not _reload or os.environ.get('WERKZEUG_RUN_MAIN') == 'true'):
        threading.Thread(target=open_browser, daemon=True).start()
    app.run(host=os.environ.get('DEYU_HOST', '127.0.0.1'), port=int(os.environ.get('DEYU_PORT', '8765')), debug=False,
            use_reloader=_reload)
