# -*- coding: utf-8 -*-
"""校园德育量化登记系统 · 桌面应用（本地运行，数据存飞书多维表格）"""
import json, os, hashlib, time, threading, webbrowser, base64, io, uuid, re, sys
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_DIR = os.path.join(BASE, 'data', 'paper_scans')
os.makedirs(PAPER_DIR, exist_ok=True)
_PAPER_LOCK = threading.Lock()
_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 list_records_raw(tid):
                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；多个年级口令相同时用它定位年级。"""
    try:
        return (request.headers.get('X-GRADE') 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 = request.headers.get('X-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():
    users = [norm_user(i) for i in list_records_raw(load_cfg()['tid_users'])]
    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', request.headers.get('X-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 ('学号', '包干区', '纸表批次', '纸表模板', '纸表来源格', '识别置信度', '申诉结果'):
            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', request.headers.get('X-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', request.headers.get('X-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(request.headers.get('X-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(request.headers.get('X-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(request.headers.get('X-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():
    recs = {r['rid']: r for r in (norm_record(i) for i in list_records_raw(load_cfg()['tid_records']))}
    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(request.headers.get('X-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}', 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):
    path = _paper_batch_path(batch.get('batch_id'))
    if not path:
        return
    tmp = path + '.tmp'
    with open(tmp, 'w', encoding='utf-8') as f:
        json.dump(batch, f, ensure_ascii=False, indent=2)
    os.replace(tmp, path)

_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 list_records_raw(tid):
                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 list_records_raw(load_cfg()['tid_rules']):
            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)

@app.route('/api/paper/templates')
def paper_templates():
    eng = paper_engine_info()
    return jsonify(ok=True, templates=paper_public_templates(),
                   engine_ready=bool(eng.get('ready')), engine_name=eng.get('name', ''))

# ---------- 本地识别引擎外挂（桌面版可选下载，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():
    info = paper_engine_info()
    # 真实加载探测：目录判定可能失真（显示 PP-OCRv6 实际降级 PP-OCRv3），这里强制加载一次看真实结果
    try:
        _ok, _name, _err = paper_ocr_available()
    except Exception as _e:
        _ok, _name, _err = False, '', str(_e)[:120]
    return jsonify(ok=True,
                   installed=bool(paper_engine_installed()),
                   engine_ready=bool(info.get('ready')),
                   engine_name=info.get('name', ''),
                   loaded_ok=bool(_ok),
                   loaded_name=_name,
                   load_err=_err,
                   installable=(_platform.system().lower() == '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/ → 热重载。"""
    if _engine_dl['running']:
        return jsonify(ok=False, msg='下载已在进行中'), 409
    b = request.get_json(silent=True) or {}
    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
    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[:4].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_used = result.get('detected_date') or ctx['date']
    session_used = result.get('detected_session') or ctx['session']
    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_used,
        'session': session_used, 'grade': ctx['grade'], 'building': ctx['building'],
        'check_time': _paper_time_ms(date_used, 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': result.get('candidates') or [],
    }
    result['date_used'] = date_used
    result['session_used'] = session_used
    try:
        _paper_save_batch(batch)
    except Exception:
        pass
    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') == 'submitted':
        return jsonify(ok=False, msg='批次已提交，不能再次复核'), 400
    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 = [], []
    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
            updates.append({'id': cand.get('id'), 'ai': ai})
            _ai_count()
        except Exception as exc:
            if local_match:
                cand['match'] = local_match
            errors.append({'id': cand.get('id'), 'msg': str(exc)[:240]})
        time.sleep(0.15)

    try:
        _paper_save_batch(batch)
    except Exception:
        pass
    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
    if batch.get('status') == 'submitted':
        return jsonify(ok=True, duplicate_submit=True, count=batch.get('submitted_count', 0),
                       batch_id=batch_id, msg='该批次已提交，请勿重复写入')
    if batch.get('status') == 'writing':
        return jsonify(ok=False, msg='该批次正在写入，请稍后查看结果'), 409
    if batch.get('status') == 'partial':
        return jsonify(ok=False, msg='该批次上次写入中断，为避免重复扣分已锁定。请先在记录查询中核对，再联系管理员处理'), 409
    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
    dorm_map = {}
    if batch.get('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 = []
    for i, row in enumerate(incoming):
        if not isinstance(row, dict):
            return jsonify(ok=False, msg='第 %d 行数据异常' % (i + 1)), 400
        item = (row.get('item') or '').strip()
        desc = (row.get('desc') or '').strip()
        if not item:
            return jsonify(ok=False, msg='第 %d 行缺少事项细项' % (i + 1)), 400
        try:
            score = float(row.get('score'))
            qty = int(float(row.get('qty') or 1))
        except (TypeError, ValueError):
            return jsonify(ok=False, msg='第 %d 行分值或数量不是数字' % (i + 1)), 400
        if score <= 0 or score > 200:
            return jsonify(ok=False, msg='第 %d 行分值必须在 0.5—200 之间' % (i + 1)), 400
        qty = max(1, min(qty, 200))
        classes = []
        if batch.get('template') == 'dorm_log':
            room = str(row.get('room') or '').strip()
            classes = dorm_map.get(room) or [x for x in (row.get('classes') or []) if isinstance(x, str) and x.strip()]
            if not room or not classes:
                return jsonify(ok=False, msg='第 %d 行的宿舍房间未映射到班级，请先核对宿舍安排' % (i + 1)), 400
            building = (row.get('building') or batch.get('building') or '').strip()
            desc = (desc + '；房间 %s %s；整间扣分' % (building, room)).strip('；')[:500]
        else:
            cls = (row.get('cls') or row.get('target') or '').strip()
            if not cls or '待' in cls[:2]:
                return jsonify(ok=False, msg='第 %d 行未确定扣分班级' % (i + 1)), 400
            classes = [cls]
        if qty > 1 and ('数量' not in desc):
            desc = (desc + '；数量 %d%s' % (qty, row.get('unit') or '人')).strip('；')[:500]
        grade = (row.get('grade') or _paper_grade_from_cls(classes[0]) or batch.get('grade') or '').strip()
        for cls in classes:
            entries.append({
                'source_index': i, 'grade': _paper_grade_from_cls(cls) or grade, 'cls': cls.strip()[:30],
                'dept': ((row.get('dept') or batch.get('dept') or '').strip()[:10] or '纪检部'),
                'item': item[:40], 'score': score, 'desc': desc, 'user': (batch.get('user') or '').strip()[:20],
                'cell': (row.get('cell') or '').strip()[:60], 'confidence': int(row.get('confidence') or 0),
                'building': (row.get('building') or batch.get('building') or '').strip()[:30],
                'room': str(row.get('room') or '').strip()[:20],
                'check_time': int(batch.get('check_time') or time.time() * 1000),
            })
    if len(entries) > 500:
        return jsonify(ok=False, msg='展开后超过 500 条，请分批提交'), 400
    win_min = num(load_cfg().get('dedup_window_min'), 60)
    dups = []
    if win_min > 0 and not b.get('force'):
        recent = _dedup_recent()
        for i, row in enumerate(incoming):
            group = [e for e in entries if e['source_index'] == i]
            hits = []
            for e in group:
                hits.extend(_paper_recent_dups(e, win_min * 60000, recent))
            if hits:
                dups.append({'index': i, 'target': row.get('target') or row.get('cls') or '',
                             'item': row.get('item') or '', '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:
        fresh = _paper_load_batch(batch_id)
        if not fresh:
            return jsonify(ok=False, msg='识别批次已丢失'), 404
        if fresh.get('status') == 'submitted':
            return jsonify(ok=True, duplicate_submit=True, count=fresh.get('submitted_count', 0), batch_id=batch_id)
        if fresh.get('status') == 'writing':
            return jsonify(ok=False, msg='该批次正在写入，请稍后查看结果'), 409
        fresh['status'] = 'writing'
        fresh['writing_started'] = int(time.time() * 1000)
        fresh['submitted_rows'] = incoming
        fresh['submitted_at'] = int(time.time() * 1000)
        _paper_save_batch(fresh)
    if not ensure_record_fields():
        with _PAPER_LOCK:
            fresh = _paper_load_batch(batch_id) or {}
            fresh.update({'status': 'recognized', 'error': '检查记录表字段初始化失败'})
            _paper_save_batch(fresh)
        return jsonify(ok=False, msg='检查记录表缺少纸表识别字段且自动补建失败，请管理员检查飞书权限'), 500
    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['score']),
            '事实描述': e['desc'], '使用人': e['user'], '登记来源': '纸表识别',
            '纸表批次': batch_id, '纸表模板': batch.get('template_name', '')[:40],
            '纸表来源格': e['cell'], '识别置信度': str(e['confidence']),
            '楼栋': e['building'], '房间': e['room'],
        }})
    done = 0
    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:
                with _PAPER_LOCK:
                    fresh = _paper_load_batch(batch_id) or {}
                    fresh.update({'status': 'partial', 'done': done, 'error': str(d.get('msg'))[:200]})
                    _paper_save_batch(fresh)
                return jsonify(ok=False, msg='写入失败，已完成 %d 条；请勿直接重试，先核对记录' % done, done=done), 500
            done += len(chunk)
    except Exception as exc:
        with _PAPER_LOCK:
            fresh = _paper_load_batch(batch_id) or {}
            fresh.update({'status': 'partial', 'done': done, 'error': str(exc)[:200]})
            _paper_save_batch(fresh)
        return jsonify(ok=False, msg='写入中断，已完成 %d 条；请先核对记录再处理' % done, done=done), 500
    with _PAPER_LOCK:
        fresh = _paper_load_batch(batch_id) or {}
        fresh.update({'status': 'submitted', 'submitted_count': done, 'submitted_at': int(time.time() * 1000)})
        _paper_save_batch(fresh)
    write_log('纸表识别扣分', '%s %s' % (batch.get('template_name', ''), batch_id),
              '候选 %d 项，写入 %d 条；%s' % (len(incoming), done, batch.get('user', '')))
    return jsonify(ok=True, count=done, batch_id=batch_id)

# ---------- 检查排班 ----------
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', request.headers.get('X-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', request.headers.get('X-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 list_records_raw(tid):
                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', request.headers.get('X-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', request.headers.get('X-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', request.headers.get('X-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(request.headers.get('X-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(request.headers.get('X-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(request.headers.get('X-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(request.headers.get('X-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', request.headers.get('X-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.02'

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 = request.headers.get('X-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', request.headers.get('X-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:
        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)
