"""Durable cross-page approval of a fixed, authorized set of knowledge drafts."""
from __future__ import annotations

import json
import time

import rbac
from archive_store import json_text, new_id, tenant_scope, utc_now
from knowledge_retriever import KnowledgeRetriever

REVIEW_SCHEMA = """
CREATE TABLE IF NOT EXISTS knowledge_review_job (
 id TEXT PRIMARY KEY, created_by INTEGER NOT NULL, account_id INTEGER NOT NULL,
 scope_label TEXT NOT NULL, status TEXT NOT NULL DEFAULT 'preview',
 total INTEGER NOT NULL DEFAULT 0, processed INTEGER NOT NULL DEFAULT 0,
 approved INTEGER NOT NULL DEFAULT 0, skipped INTEGER NOT NULL DEFAULT 0,
 preview_json TEXT NOT NULL DEFAULT '{}', expires_at REAL NOT NULL,
 error TEXT NOT NULL DEFAULT '', created_at TEXT NOT NULL, updated_at TEXT NOT NULL
);
CREATE INDEX IF NOT EXISTS idx_knowledge_review_queue ON knowledge_review_job(status,created_at,id);
CREATE INDEX IF NOT EXISTS idx_knowledge_review_owner ON knowledge_review_job(created_by,created_at DESC);
CREATE TABLE IF NOT EXISTS knowledge_review_target (
 job_id TEXT NOT NULL REFERENCES knowledge_review_job(id) ON DELETE CASCADE,
 item_id TEXT NOT NULL, tenant_id TEXT NOT NULL, revision INTEGER NOT NULL,
 item_updated_at TEXT NOT NULL, preview_reason TEXT NOT NULL DEFAULT '',
 result TEXT NOT NULL DEFAULT 'pending', reason TEXT NOT NULL DEFAULT '',
 PRIMARY KEY(job_id,item_id)
);
CREATE INDEX IF NOT EXISTS idx_knowledge_review_pending ON knowledge_review_target(job_id,result,item_id);
"""

REASONS = {
    '': '符合校验条件', 'missing_conditions': '缺少适用条件，需编辑补充',
    'invalid_fields': '知识字段不完整、过长或类型无效', 'expired': '已超过有效期',
    'missing_source': '缺少来源记录', 'changed_source': '来源已变化，请重新整理',
    'changed_item': '预览后知识版本或状态已变化', 'deleted': '知识已删除',
    'unauthorized': '该账号已不在当前授权范围',
}
REVIEW_PERMISSIONS = {'knowledge:read', 'knowledge:review', 'im:content:read'}


def reason_sql(alias='k'):
    """The same eligibility predicate is used by preview and execution."""
    k = alias
    return f"""CASE
        WHEN trim({k}.conditions)='' THEN 'missing_conditions'
        WHEN trim({k}.title)='' OR length({k}.title)>160 OR trim({k}.question)=''
          OR length({k}.question)>4000 OR trim({k}.answer)='' OR length({k}.answer)>8000
          OR length({k}.conditions)>2000 OR length({k}.category)>100
          OR {k}.kind NOT IN ('qa','procedure','case') THEN 'invalid_fields'
        WHEN {k}.valid_until!='' AND {k}.valid_until<? THEN 'expired'
        WHEN NOT EXISTS(SELECT 1 FROM knowledge_source s WHERE s.item_id={k}.id) THEN 'missing_source'
        WHEN EXISTS(SELECT 1 FROM knowledge_source s LEFT JOIN archive_message m ON m.id=s.message_id
          WHERE s.item_id={k}.id AND (m.id IS NULL OR m.tenant_id!={k}.tenant_id OR m.status!='normal'
            OR s.version_no!=(SELECT MAX(version_no) FROM archive_message_version WHERE message_id=s.message_id)))
          THEN 'changed_source'
        ELSE '' END"""


def reviewer_scope(db, actor):
    user = db.execute('SELECT role,active FROM users WHERE id=?', (actor,)).fetchone()
    permissions = rbac.permissions_of(db, user['role']) if user and user['active'] else set()
    if not REVIEW_PERMISSIONS <= permissions:
        raise ValueError('审核权限已变化或账号已停用，请恢复权限后继续')
    scoped = db.execute('SELECT desktop_account_id FROM admin_account_scope WHERE admin_user_id=?', (actor,)).fetchall()
    if 'desktop-account:all' in permissions or not scoped:
        return None  # Matches the existing "all authorized accounts" resolver.
    return {r[0] for r in db.execute('SELECT d.tenant_id FROM desktop_accounts d JOIN admin_account_scope a '
                                   'ON a.desktop_account_id=d.id WHERE a.admin_user_id=?', (actor,))}


class KnowledgeReviewStore:
    def __init__(self, store):
        self.store = store
        self.database = store.database

    @staticmethod
    def public(row):
        result = dict(row)
        result['preview'] = json.loads(result.pop('preview_json'))
        result['progress_percent'] = (100 if result['status'] == 'completed' else
            min(99, int(result['processed'] * 100 / result['total'])) if result['total'] else 0)
        return result

    @staticmethod
    def owned(db, job_id, actor):
        row = db.execute('SELECT * FROM knowledge_review_job WHERE id=? AND created_by=?', (job_id, actor)).fetchone()
        if row is None:
            raise KeyError('审核任务不存在或不属于当前用户')
        return row

    def get(self, job_id, actor):
        with self.database.connect() as db:
            return self.public(self.owned(db, job_id, actor))

    def jobs(self, actor):
        with self.database.connect() as db:
            return [self.public(row) for row in db.execute("SELECT * FROM knowledge_review_job WHERE created_by=? "
                "AND status NOT IN ('preview','expired') ORDER BY created_at DESC,id LIMIT 30", (actor,))]

    def preview(self, scope, account_id, actor, ip):
        scope = tenant_scope(scope)
        job_id, now = new_id(), utc_now()
        with self.database.connect() as db:
            db.execute('BEGIN IMMEDIATE')
            authorized = reviewer_scope(db, actor)
            # Scope comes from the API resolver, and is rechecked under the writer lock.
            if authorized is not None and (scope.everything or not set(scope.tenants) <= authorized):
                raise ValueError('账号授权已变化，请刷新后重新选择范围')
            label = '全部授权账号' if account_id == -1 else '旧版未归属数据'
            if account_id > 0:
                account = db.execute('SELECT nickname,zyt_sn FROM desktop_accounts WHERE id=?', (account_id,)).fetchone()
                if account is None:
                    raise ValueError('所选账号不存在')
                label = f"{account['nickname'] or account['zyt_sn']}（{account['zyt_sn']}）"
            db.execute("UPDATE knowledge_review_job SET status='expired' WHERE created_by=? AND status='preview'", (actor,))
            db.execute('INSERT INTO knowledge_review_job(id,created_by,account_id,scope_label,expires_at,created_at,updated_at) '
                       'VALUES (?,?,?,?,?,?,?)', (job_id, actor, account_id, label, time.time() + 1800, now, now))
            # Snapshot only IDs and versions, never load every draft into application memory.
            db.execute(f"""INSERT INTO knowledge_review_target(job_id,item_id,tenant_id,revision,item_updated_at,preview_reason)
                SELECT ?,k.id,k.tenant_id,k.revision,k.updated_at,{reason_sql()}
                FROM knowledge_item k WHERE k.status='draft' AND {scope.clause('k')}""",
                [job_id, KnowledgeRetriever._today(), *scope.params])
            reasons = dict(db.execute('SELECT preview_reason,COUNT(*) FROM knowledge_review_target WHERE job_id=? '
                                      'GROUP BY preview_reason', (job_id,)))
            accounts = [dict(row) for row in db.execute("""SELECT t.tenant_id,COUNT(*) total,
                SUM(t.preview_reason='') eligible,COALESCE((SELECT CASE WHEN d.nickname='' THEN d.zyt_sn
                ELSE d.nickname||'（'||d.zyt_sn||'）' END FROM desktop_accounts d WHERE d.tenant_id=t.tenant_id LIMIT 1),
                '旧版未归属数据') name FROM knowledge_review_target t WHERE t.job_id=? GROUP BY t.tenant_id""", (job_id,))]
            total = sum(reasons.values())
            preview = {'total': total, 'eligible': reasons.get('', 0), 'blocked': total - reasons.get('', 0),
                       'reasons': [{'code': key, 'reason': REASONS[key], 'count': count} for key, count in reasons.items() if key],
                       'accounts': accounts, 'snapshot_at': now}
            db.execute('UPDATE knowledge_review_job SET total=?,preview_json=? WHERE id=?', (total, json_text(preview), job_id))
            self.database._audit(db, actor, 'knowledge.review.preview', f'job={job_id} total={total}', ip)
        return self.get(job_id, actor)

    def action(self, job_id, action, actor, ip, confirmed=False):
        if action not in {'start', 'pause', 'resume', 'cancel'}:
            raise ValueError('未知审核任务操作')
        with self.database.connect() as db:
            db.execute('BEGIN IMMEDIATE')
            reviewer_scope(db, actor)
            row = self.owned(db, job_id, actor)
            if action == 'start':
                if not confirmed:
                    raise ValueError('请确认当前范围内的知识已完成必要审核，再批量通过')
                # A repeated HTTP submission cannot create or enqueue a second job.
                if row['status'] in {'queued', 'running', 'completed'}:
                    return self.public(row)
                if row['status'] != 'preview' or row['expires_at'] < time.time():
                    raise ValueError('预览已失效，请重新预览审核范围')
                if row['total'] == 0:
                    raise ValueError('当前范围没有待审核草稿')
                status = 'queued'
            else:
                allowed = {'pause': {'queued', 'running'}, 'resume': {'paused', 'failed'},
                           'cancel': {'preview', 'queued', 'running', 'paused', 'failed'}}[action]
                if row['status'] not in allowed:
                    raise ValueError('当前状态不能执行此操作')
                status = {'pause': 'paused', 'resume': 'queued', 'cancel': 'cancelled'}[action]
            db.execute("UPDATE knowledge_review_job SET status=?,error='',updated_at=? WHERE id=?", (status, utc_now(), job_id))
            self.database._audit(db, actor, 'knowledge.review.' + action, f'job={job_id}', ip)
        return self.get(job_id, actor)

    def results(self, job_id, actor, scope, result='skipped', page=1, page_size=30):
        scope = tenant_scope(scope)
        if result not in {'', 'pending', 'approved', 'skipped'}:
            raise ValueError('未知审核结果筛选')
        where, args = f't.job_id=? AND {scope.clause("t")}', [job_id, *scope.params]
        if result:
            where += ' AND t.result=?'; args.append(result)
        with self.database.connect() as db:
            self.owned(db, job_id, actor)
            total = db.execute(f'SELECT COUNT(*) FROM knowledge_review_target t WHERE {where}', args).fetchone()[0]
            rows = db.execute(f"""SELECT t.item_id,t.tenant_id,t.revision,t.result,t.reason,t.preview_reason,
                COALESCE(k.title,'知识已删除') title,
                COALESCE((SELECT id FROM desktop_accounts WHERE tenant_id=t.tenant_id LIMIT 1),0) account_id,
                COALESCE((SELECT CASE WHEN nickname='' THEN zyt_sn ELSE nickname||'（'||zyt_sn||'）' END
                    FROM desktop_accounts WHERE tenant_id=t.tenant_id LIMIT 1),'旧版未归属数据') account_name FROM knowledge_review_target t LEFT JOIN knowledge_item k
                ON k.id=t.item_id AND k.tenant_id=t.tenant_id WHERE {where} ORDER BY t.item_id LIMIT ? OFFSET ?""",
                [*args, page_size, (page - 1) * page_size]).fetchall()
        return {'items': [{**dict(row), 'reason_text': REASONS.get(row['reason'] or row['preview_reason'], '')} for row in rows],
                'total': total}


class KnowledgeReviewWorker:
    """Short SQL-only transactions; crash/pause cannot half-commit an approval batch."""
    def __init__(self, store):
        self.store = store
        self.database = store.database

    def step(self, batch_size=100):
        batch_size = max(1, min(100, batch_size))
        with self.database.connect() as db:
            db.execute('BEGIN IMMEDIATE')
            job = db.execute("SELECT * FROM knowledge_review_job WHERE status IN ('queued','running') "
                             'ORDER BY created_at,id LIMIT 1').fetchone()
            if job is None:
                return self.cleanup(db)
            try:
                authorized = reviewer_scope(db, job['created_by'])
            except ValueError as error:
                db.execute("UPDATE knowledge_review_job SET status='failed',error=?,updated_at=? WHERE id=?",
                           (str(error), utc_now(), job['id']))
                return True
            rows = db.execute(f"""SELECT t.*,k.id current_id,k.revision current_revision,k.status current_status,
                k.updated_at current_updated_at,{reason_sql()} eligibility FROM knowledge_review_target t
                LEFT JOIN knowledge_item k ON k.id=t.item_id AND k.tenant_id=t.tenant_id
                WHERE t.job_id=? AND t.result='pending' ORDER BY t.item_id LIMIT ?""",
                (KnowledgeRetriever._today(), job['id'], batch_size)).fetchall()
            approved = 0
            for row in rows:
                reason = ('unauthorized' if authorized is not None and row['tenant_id'] not in authorized else
                          'deleted' if row['current_id'] is None else
                          'changed_item' if row['current_revision'] != row['revision'] or row['current_status'] != 'draft'
                          or row['current_updated_at'] != row['item_updated_at'] else row['eligibility'])
                if not reason:
                    db.execute("UPDATE knowledge_item SET status='approved',updated_at=? WHERE id=?", (utc_now(), row['item_id']))
                    db.execute('DELETE FROM knowledge_fts WHERE item_id=?', (row['item_id'],))
                    self.store._record(db, row['item_id'], job['created_by'], 'approve')
                    approved += 1
                db.execute('UPDATE knowledge_review_target SET result=?,reason=? WHERE job_id=? AND item_id=?',
                           ('skipped' if reason else 'approved', reason, job['id'], row['item_id']))
            done = job['processed'] + len(rows) >= job['total']
            db.execute('UPDATE knowledge_review_job SET status=?,processed=processed+?,approved=approved+?,skipped=skipped+?,updated_at=? WHERE id=?',
                       ('completed' if done else 'running', len(rows), approved, len(rows) - approved, utc_now(), job['id']))
            if done:
                self.database._audit(db, job['created_by'], 'knowledge.review.complete', f"job={job['id']} approved={job['approved'] + approved}", '')
        return True

    @staticmethod
    def cleanup(db):
        # Abandoned previews expire. Delete a bounded number of IDs per idle tick.
        row = db.execute("SELECT id FROM knowledge_review_job WHERE (status='preview' AND expires_at<?) OR status='expired' "
                         'ORDER BY created_at LIMIT 1', (time.time(),)).fetchone()
        if row is None:
            return False
        db.execute("UPDATE knowledge_review_job SET status='expired' WHERE id=?", (row['id'],))
        db.execute('DELETE FROM knowledge_review_target WHERE rowid IN (SELECT rowid FROM knowledge_review_target WHERE job_id=? LIMIT 1000)', (row['id'],))
        if not db.execute('SELECT 1 FROM knowledge_review_target WHERE job_id=? LIMIT 1', (row['id'],)).fetchone():
            db.execute('DELETE FROM knowledge_review_job WHERE id=?', (row['id'],))
        return True