from typing import Optional, List, Tuple, Any, Dict

from sqlalchemy import select, func, update as sa_update, desc, asc, text, case, literal_column, cast, String, or_, and_
from sqlalchemy.ext.asyncio import AsyncSession

from app.base_service import BaseService
from app.db_compat import get_db_type, json_extract, json_has_key
from zq_smart_table.model import SmartTable, SmartField, SmartRecord, SmartView, SmartTableLink, SmartTableComment, SmartDocumentVersion, SmartDocumentTemplate, SmartWikiSpace
from zq_smart_table.schema import (
    SmartTableCreate, SmartTableUpdate,
    SmartFieldCreate, SmartFieldUpdate,
    SmartRecordCreate, SmartRecordUpdate,
    SmartViewCreate, SmartViewUpdate,
    RecordFilterRule, RecordSortRule,
    LinkedRecordItem,
    WikiSpaceCreate, WikiSpaceUpdate,
)


class SmartTableService(BaseService[SmartTable, SmartTableCreate, SmartTableUpdate]):
    model = SmartTable
    RESOURCE_TYPE = "smart_table"

    @classmethod
    async def get_user_tables(
        cls, db: AsyncSession, page: int = 1, page_size: int = 1000,
        wiki_space_id: Optional[str] = None,
        user_id: Optional[str] = None,
        dept_id: Optional[str] = None,
        role_ids: Optional[List[str]] = None,
        is_superuser: bool = False,
    ) -> Tuple[List[SmartTable], int]:
        from zq_smart_table.permission.model import SmartTableCollaborator

        base_query = select(SmartTable).where(SmartTable.is_deleted == False)  # noqa: E712

        if wiki_space_id is not None:
            base_query = base_query.where(SmartTable.wiki_space_id == wiki_space_id)
        else:
            base_query = base_query.where(SmartTable.wiki_space_id.is_(None))

        if not is_superuser and user_id:
            subject_conds = [
                and_(
                    SmartTableCollaborator.subject_type == "user",
                    SmartTableCollaborator.subject_id == user_id,
                )
            ]
            if dept_id:
                subject_conds.append(
                    and_(
                        SmartTableCollaborator.subject_type == "dept",
                        SmartTableCollaborator.subject_id == dept_id,
                    )
                )
            if role_ids:
                for rid in role_ids:
                    subject_conds.append(
                        and_(
                            SmartTableCollaborator.subject_type == "role",
                            SmartTableCollaborator.subject_id == rid,
                        )
                    )

            collab_table_ids = (
                select(SmartTableCollaborator.table_id)
                .where(
                    SmartTableCollaborator.is_deleted == False,  # noqa: E712
                    or_(*subject_conds),
                )
                .distinct()
            )

            base_query = base_query.where(
                or_(
                    SmartTable.sys_creator_id == user_id,
                    SmartTable.id.in_(collab_table_ids),
                )
            )

        count_result = await db.execute(
            select(func.count()).select_from(base_query.subquery())
        )
        total = count_result.scalar() or 0

        offset = (page - 1) * page_size
        result = await db.execute(
            base_query.order_by(desc(SmartTable.sort), desc(SmartTable.sys_create_datetime))
            .offset(offset)
            .limit(page_size)
        )
        items = list(result.scalars().all())
        return items, total


class SmartFieldService(BaseService[SmartField, SmartFieldCreate, SmartFieldUpdate]):
    model = SmartField
    RESOURCE_TYPE = "smart_field"

    @classmethod
    async def get_by_table(cls, db: AsyncSession, table_id: str) -> List[SmartField]:
        result = await db.execute(
            select(SmartField)
            .where(SmartField.table_id == table_id, SmartField.is_deleted == False)  # noqa: E712
            .order_by(SmartField.sort, SmartField.sys_create_datetime)
        )
        return list(result.scalars().all())

    @classmethod
    async def reorder(cls, db: AsyncSession, table_id: str, field_ids: List[str]) -> None:
        """批量排序：一条 CASE WHEN SQL 替代 N 次 UPDATE"""
        if not field_ids:
            return
        whens = [(SmartField.id == fid, idx) for idx, fid in enumerate(field_ids)]
        await db.execute(
            sa_update(SmartField)
            .where(SmartField.table_id == table_id, SmartField.id.in_(field_ids))
            .values(sort=case(*whens, else_=SmartField.sort))
        )
        await db.commit()

    @classmethod
    async def delete_and_clean(cls, db: AsyncSession, field_id: str) -> bool:
        """删除字段并用一条 SQL 清理所有 record 的 values"""
        field = await cls.get_by_id(db, field_id)
        if not field:
            return False

        db_type = get_db_type()
        if db_type == "postgresql":
            await db.execute(
                text(
                    "UPDATE smart_record SET \"values\" = \"values\" - :field_id "
                    "WHERE table_id = :table_id AND is_deleted = false "
                    "AND \"values\" \\? :field_id"
                ),
                {"field_id": field_id, "table_id": field.table_id},
            )
        else:
            await db.execute(
                text(
                    "UPDATE smart_record SET `values` = JSON_REMOVE(`values`, CONCAT('$.', :field_id)) "
                    "WHERE table_id = :table_id AND is_deleted = 0 "
                    "AND JSON_CONTAINS_PATH(`values`, 'one', CONCAT('$.', :field_id))"
                ),
                {"field_id": field_id, "table_id": field.table_id},
            )

        field.is_deleted = True
        await db.commit()
        return True

    @classmethod
    async def get_next_sort(cls, db: AsyncSession, table_id: str) -> int:
        result = await db.execute(
            select(func.coalesce(func.max(SmartField.sort), -1))
            .where(SmartField.table_id == table_id, SmartField.is_deleted == False)  # noqa: E712
        )
        return (result.scalar() or 0) + 1


class SmartRecordService(BaseService[SmartRecord, SmartRecordCreate, SmartRecordUpdate]):
    model = SmartRecord
    RESOURCE_TYPE = "smart_record"

    @classmethod
    async def get_by_table_cursor(
        cls, db: AsyncSession, table_id: str,
        cursor: Optional[str] = None, limit: int = 200,
    ) -> Tuple[List[SmartRecord], Optional[str], int]:
        """
        游标分页查询（适用于大数据量滚动加载）。
        返回 (records, next_cursor, total)
        """
        base = select(SmartRecord).where(
            SmartRecord.table_id == table_id,
            SmartRecord.is_deleted == False,  # noqa: E712
        )
        count_result = await db.execute(
            select(func.count()).select_from(base.subquery())
        )
        total = count_result.scalar() or 0

        query = base.order_by(SmartRecord.sort, SmartRecord.id)
        if cursor:
            query = query.where(SmartRecord.id > cursor)
        query = query.limit(limit + 1)

        result = await db.execute(query)
        items = list(result.scalars().all())

        next_cursor = None
        if len(items) > limit:
            items = items[:limit]
            next_cursor = items[-1].id

        return items, next_cursor, total

    @classmethod
    async def get_by_table(
        cls, db: AsyncSession, table_id: str,
        page: int = 1, page_size: int = 200
    ) -> Tuple[List[SmartRecord], int]:
        filters = [SmartRecord.table_id == table_id]
        return await cls.get_list(db, page=page, page_size=page_size, filters=filters)

    @classmethod
    async def update_cell(
        cls, db: AsyncSession, record_id: str, field_id: str, value: Any
    ) -> Optional[SmartRecord]:
        """使用数据库原生 JSON 原子更新，避免读-改-写"""
        import json
        db_type = get_db_type()
        json_value = json.dumps(value)

        if db_type == "postgresql":
            await db.execute(
                text(
                    "UPDATE smart_record SET \"values\" = jsonb_set("
                    "COALESCE(\"values\", CAST('{}' AS jsonb)), "
                    ":path, CAST(:val AS jsonb)), "
                    "sys_update_datetime = now() "
                    "WHERE id = :id AND is_deleted = false"
                ),
                {"path": [field_id], "val": json_value, "id": record_id},
            )
        else:
            await db.execute(
                text(
                    "UPDATE smart_record SET `values` = JSON_SET("
                    "COALESCE(`values`, '{}'), "
                    "CONCAT('$.', :field_id), CAST(:val AS JSON)), "
                    "sys_update_datetime = NOW() "
                    "WHERE id = :id AND is_deleted = 0"
                ),
                {"field_id": field_id, "val": json_value, "id": record_id},
            )

        await db.commit()

        record = await cls.get_by_id(db, record_id)
        return record

    @classmethod
    async def batch_update_cells(
        cls, db: AsyncSession, record_id: str, cells: Dict[str, Any]
    ) -> Optional[SmartRecord]:
        """批量更新多个单元格（一次 SQL）"""
        import json
        record = await cls.get_by_id(db, record_id)
        if not record:
            return None

        current_values = dict(record.values) if record.values else {}
        current_values.update(cells)
        record.values = current_values
        await db.commit()
        await db.refresh(record)
        return record

    @classmethod
    async def batch_update_multi_records(
        cls, db: AsyncSession, updates: List[Dict[str, Any]]
    ) -> int:
        """
        批量更新多条记录的单元格，合并为单次事务。
        updates: [{ "record_id": "...", "cells": { fieldId: value, ... } }, ...]
        返回成功更新的记录数。
        """
        import json as _json
        db_type = get_db_type()
        count = 0

        for item in updates:
            record_id = item.get("record_id")
            cells = item.get("cells", {})
            if not record_id or not cells:
                continue

            if db_type == "postgresql":
                merge_obj = _json.dumps(cells)
                await db.execute(
                    text(
                        'UPDATE smart_record SET "values" = '
                        'COALESCE("values", \'{}\'::jsonb) || CAST(:merge AS jsonb), '
                        'sys_update_datetime = now() '
                        'WHERE id = :id AND is_deleted = false'
                    ),
                    {"merge": merge_obj, "id": record_id},
                )
            else:
                record = await cls.get_by_id(db, record_id)
                if not record:
                    continue
                current = dict(record.values) if record.values else {}
                current.update(cells)
                record.values = current

            count += 1

        await db.commit()
        return count

    @classmethod
    async def batch_remove_field(cls, db: AsyncSession, table_id: str, field_id: str) -> None:
        """用一条 SQL 从所有 record 中移除某个 field 的值"""
        db_type = get_db_type()
        if db_type == "postgresql":
            await db.execute(
                text(
                    "UPDATE smart_record SET \"values\" = \"values\" - :field_id "
                    "WHERE table_id = :table_id AND is_deleted = false "
                    "AND \"values\" \\? :field_id"
                ),
                {"field_id": field_id, "table_id": table_id},
            )
        else:
            await db.execute(
                text(
                    "UPDATE smart_record SET `values` = JSON_REMOVE(`values`, CONCAT('$.', :field_id)) "
                    "WHERE table_id = :table_id AND is_deleted = 0"
                ),
                {"field_id": field_id, "table_id": table_id},
            )
        await db.commit()

    @classmethod
    async def get_deleted_records(
        cls, db: AsyncSession, table_id: str,
        page: int = 1, page_size: int = 50,
    ) -> Tuple[List[SmartRecord], int]:
        """查询已删除的记录（回收站）"""
        base = select(SmartRecord).where(
            SmartRecord.table_id == table_id,
            SmartRecord.is_deleted == True,  # noqa: E712
        )
        count_result = await db.execute(
            select(func.count()).select_from(base.subquery())
        )
        total = count_result.scalar() or 0

        query = base.order_by(desc(SmartRecord.sys_update_datetime)).offset(
            (page - 1) * page_size
        ).limit(page_size)
        result = await db.execute(query)
        return list(result.scalars().all()), total

    @classmethod
    async def batch_restore_records(
        cls, db: AsyncSession, table_id: str, record_ids: List[str]
    ) -> int:
        """批量恢复已删除的记录（仅限指定表）"""
        result = await db.execute(
            sa_update(SmartRecord)
            .where(
                SmartRecord.id.in_(record_ids),
                SmartRecord.table_id == table_id,
                SmartRecord.is_deleted == True,  # noqa: E712
            )
            .values(is_deleted=False)
        )
        await db.commit()
        return result.rowcount  # type: ignore

    @classmethod
    async def permanent_delete(cls, db: AsyncSession, table_id: str, record_id: str) -> bool:
        """永久删除记录（仅限指定表的已删除记录）"""
        from sqlalchemy import delete as sa_del
        result = await db.execute(
            sa_del(SmartRecord).where(
                SmartRecord.id == record_id,
                SmartRecord.table_id == table_id,
                SmartRecord.is_deleted == True,  # noqa: E712
            )
        )
        await db.commit()
        return result.rowcount > 0  # type: ignore

    @classmethod
    async def empty_trash(cls, db: AsyncSession, table_id: str) -> int:
        """清空回收站"""
        from sqlalchemy import delete as sa_del
        result = await db.execute(
            sa_del(SmartRecord).where(
                SmartRecord.table_id == table_id,
                SmartRecord.is_deleted == True,  # noqa: E712
            )
        )
        await db.commit()
        return result.rowcount  # type: ignore

    @classmethod
    async def get_next_auto_number(cls, db: AsyncSession, table_id: str, field_id: str) -> int:
        """用 SQL 聚合查询获取 AutoNumber 最大值，避免全表加载到 Python"""
        db_type = get_db_type()
        if db_type == "postgresql":
            result = await db.execute(
                text(
                    "SELECT COALESCE(MAX(CAST(\"values\" ->> :field_id AS int)), 0) "
                    "FROM smart_record "
                    "WHERE table_id = :table_id AND is_deleted = false "
                    "AND \"values\" \\? :field_id "
                    "AND (\"values\" ->> :field_id) ~ '^[0-9]+$'"
                ),
                {"field_id": field_id, "table_id": table_id},
            )
        else:
            result = await db.execute(
                text(
                    "SELECT COALESCE(MAX(CAST(JSON_UNQUOTE(JSON_EXTRACT(`values`, CONCAT('$.', :field_id))) AS SIGNED)), 0) "
                    "FROM smart_record "
                    "WHERE table_id = :table_id AND is_deleted = 0 "
                    "AND JSON_CONTAINS_PATH(`values`, 'one', CONCAT('$.', :field_id))"
                ),
                {"field_id": field_id, "table_id": table_id},
            )
        return (result.scalar() or 0) + 1

    @classmethod
    async def get_record_count(cls, db: AsyncSession, table_id: str) -> int:
        result = await db.execute(
            select(func.count()).where(
                SmartRecord.table_id == table_id,
                SmartRecord.is_deleted == False,  # noqa: E712
            )
        )
        return result.scalar() or 0

    # ==================== Server-side filter / sort / search ====================

    @classmethod
    def _build_filter_condition(cls, rule: RecordFilterRule):
        """将单条 RecordFilterRule 转换为 SQLAlchemy 条件表达式"""
        col = json_extract(SmartRecord.values, rule.field_id)
        op = rule.operator
        val = rule.value

        if op == "isEmpty":
            return or_(
                ~json_has_key(SmartRecord.values, rule.field_id),
                col == None,  # noqa: E711
                col == "",
            )
        if op == "isNotEmpty":
            return and_(
                json_has_key(SmartRecord.values, rule.field_id),
                col != None,  # noqa: E711
                col != "",
            )
        if op == "equals":
            return col == str(val) if val is not None else col == None  # noqa: E711
        if op == "notEquals":
            return col != str(val) if val is not None else col != None  # noqa: E711
        if op == "contains":
            return col.ilike(f"%{val}%") if val else col == col
        if op == "notContains":
            return ~col.ilike(f"%{val}%") if val else col == col
        if op == "greaterThan":
            return cast(col, String) > str(val)
        if op == "lessThan":
            return cast(col, String) < str(val)
        if op == "greaterThanOrEqual":
            return cast(col, String) >= str(val)
        if op == "lessThanOrEqual":
            return cast(col, String) <= str(val)
        return True  # noqa: fallback

    @classmethod
    def _build_search_conditions(cls, keyword: str, search_field_ids: Optional[List[str]] = None):
        """构建全文搜索条件：在指定字段或所有字段中匹配关键词"""
        if not keyword:
            return None
        like_pattern = f"%{keyword}%"
        if search_field_ids:
            conds = [json_extract(SmartRecord.values, fid).ilike(like_pattern) for fid in search_field_ids]
        else:
            # 对 JSONB 整列做 cast(text) ILIKE，兼容所有字段
            conds = [cast(SmartRecord.values, String).ilike(like_pattern)]
        return or_(*conds) if conds else None

    @classmethod
    async def get_by_table_cursor_filtered(
        cls,
        db: AsyncSession,
        table_id: str,
        filters: Optional[List[RecordFilterRule]] = None,
        filter_logic: str = "and",
        sorts: Optional[List[RecordSortRule]] = None,
        search: Optional[str] = None,
        search_field_ids: Optional[List[str]] = None,
        extra_conditions: Optional[list] = None,
        cursor: Optional[str] = None,
        limit: int = 200,
        skip_count: bool = False,
    ) -> Tuple[List[SmartRecord], Optional[str], int]:
        """
        服务端筛选 + 排序 + 搜索 + 游标分页。
        extra_conditions: 外部传入的额外 SQLAlchemy 条件（如行权限）
        skip_count: 为True时跳过count查询(用于加载更多时提升性能)
        """
        base = select(SmartRecord).where(
            SmartRecord.table_id == table_id,
            SmartRecord.is_deleted == False,  # noqa: E712
        )

        has_complex_filter = False
        if filters:
            filter_conds = [cls._build_filter_condition(f) for f in filters]
            if filter_logic == "or":
                base = base.where(or_(*filter_conds))
            else:
                base = base.where(and_(*filter_conds))
            has_complex_filter = True

        if search and search.strip():
            search_cond = cls._build_search_conditions(search.strip(), search_field_ids)
            if search_cond is not None:
                base = base.where(search_cond)
            has_complex_filter = True

        if extra_conditions:
            for cond in extra_conditions:
                base = base.where(cond)
            has_complex_filter = True

        total = -1
        if not skip_count:
            if has_complex_filter:
                count_result = await db.execute(
                    select(func.count()).select_from(base.subquery())
                )
            else:
                count_result = await db.execute(
                    select(func.count()).where(
                        SmartRecord.table_id == table_id,
                        SmartRecord.is_deleted == False,  # noqa: E712
                    )
                )
            total = count_result.scalar() or 0

        query = base
        if sorts:
            for s in sorts:
                col = json_extract(SmartRecord.values, s.field_id)
                query = query.order_by(desc(col) if s.direction == "desc" else asc(col))
        query = query.order_by(SmartRecord.sort, SmartRecord.id)

        if cursor:
            query = query.where(SmartRecord.id > cursor)
        query = query.limit(limit + 1)

        result = await db.execute(query)
        items = list(result.scalars().all())

        next_cursor = None
        if len(items) > limit:
            items = items[:limit]
            next_cursor = items[-1].id

        return items, next_cursor, total

    @classmethod
    async def reorder(cls, db: AsyncSession, table_id: str, record_ids: List[str]) -> None:
        """批量更新记录排序"""
        if not record_ids:
            return
        whens = [(SmartRecord.id == rid, idx) for idx, rid in enumerate(record_ids)]
        await db.execute(
            sa_update(SmartRecord)
            .where(SmartRecord.table_id == table_id, SmartRecord.id.in_(record_ids))
            .values(sort=case(*whens, else_=SmartRecord.sort))
        )
        await db.commit()


class SmartViewService(BaseService[SmartView, SmartViewCreate, SmartViewUpdate]):
    model = SmartView
    RESOURCE_TYPE = "smart_view"

    @classmethod
    async def get_by_table(cls, db: AsyncSession, table_id: str) -> List[SmartView]:
        result = await db.execute(
            select(SmartView)
            .where(SmartView.table_id == table_id, SmartView.is_deleted == False)  # noqa: E712
            .order_by(SmartView.sort, SmartView.sys_create_datetime)
        )
        return list(result.scalars().all())


# ==================== Import / Export ====================

class SmartExportService:
    """CSV / Excel 导出"""

    @classmethod
    def _format_cell(cls, val: Any, field_type: str) -> str:
        if val is None:
            return ""
        if field_type == "link" and isinstance(val, list):
            return ", ".join(
                (item.get("title", "") if isinstance(item, dict) else str(item))
                for item in val
            )
        if isinstance(val, list):
            return ", ".join(str(v) for v in val)
        return str(val)

    @classmethod
    async def export_csv(
        cls, db: AsyncSession, table_id: str,
        fields: List[SmartField], records: List[SmartRecord],
    ) -> str:
        import csv
        import io

        output = io.StringIO()
        writer = csv.writer(output)
        writer.writerow([f.name for f in fields])

        for r in records:
            row = []
            for f in fields:
                val = (r.values or {}).get(f.id, "")
                row.append(cls._format_cell(val, f.type))
            writer.writerow(row)

        return output.getvalue()

    @classmethod
    async def export_xlsx(
        cls, db: AsyncSession, table_id: str,
        fields: List[SmartField], records: List[SmartRecord],
    ) -> bytes:
        from openpyxl import Workbook
        import io

        wb = Workbook()
        ws = wb.active
        ws.title = "Sheet1"
        ws.append([f.name for f in fields])

        for r in records:
            row = []
            for f in fields:
                val = (r.values or {}).get(f.id, "")
                row.append(cls._format_cell(val, f.type))
            ws.append(row)

        buf = io.BytesIO()
        wb.save(buf)
        return buf.getvalue()


class SmartImportService:
    """CSV / Excel 导入"""

    BATCH_SIZE = 500

    @classmethod
    async def import_csv(
        cls, db: AsyncSession, table_id: str,
        file_content: bytes, fields: List[SmartField],
    ) -> Dict[str, Any]:
        import csv
        import io

        text = file_content.decode("utf-8-sig")
        reader = csv.reader(io.StringIO(text))
        headers = next(reader, None)
        if not headers:
            return {"success": 0, "fail": 0, "errors": ["文件为空或无表头"]}

        return await cls._import_rows(db, table_id, headers, list(reader), fields)

    @classmethod
    async def import_xlsx(
        cls, db: AsyncSession, table_id: str,
        file_content: bytes, fields: List[SmartField],
    ) -> Dict[str, Any]:
        from openpyxl import load_workbook
        import io

        wb = load_workbook(io.BytesIO(file_content), read_only=True)
        ws = wb.active
        rows_iter = ws.iter_rows(values_only=True)
        header_row = next(rows_iter, None)
        if not header_row:
            return {"success": 0, "fail": 0, "errors": ["文件为空或无表头"]}

        headers = [str(h) if h else "" for h in header_row]
        data_rows = [[str(c) if c is not None else "" for c in row] for row in rows_iter]

        return await cls._import_rows(db, table_id, headers, data_rows, fields)

    @classmethod
    async def _import_rows(
        cls, db: AsyncSession, table_id: str,
        headers: List[str], rows: List[List[str]],
        fields: List[SmartField],
    ) -> Dict[str, Any]:
        field_map: Dict[str, SmartField] = {f.name: f for f in fields}
        col_to_field: List[Optional[SmartField]] = []
        new_fields_created = 0

        for h in headers:
            h = h.strip()
            if h in field_map:
                col_to_field.append(field_map[h])
            else:
                new_field = SmartField(
                    table_id=table_id,
                    name=h,
                    type="text",
                    width=150,
                    visible=True,
                    required=False,
                    config={},
                    sort=len(fields) + new_fields_created,
                )
                db.add(new_field)
                await db.flush()
                field_map[h] = new_field
                col_to_field.append(new_field)
                new_fields_created += 1

        success = 0
        errors: List[str] = []
        batch: List[SmartRecord] = []

        for row_idx, row in enumerate(rows):
            try:
                values: Dict[str, Any] = {}
                for col_idx, cell_val in enumerate(row):
                    if col_idx < len(col_to_field) and col_to_field[col_idx]:
                        field = col_to_field[col_idx]
                        if field.type in ("link", "lookup", "rollup"):
                            continue
                        values[field.id] = cls._parse_cell(cell_val, field.type)

                record = SmartRecord(table_id=table_id, values=values)
                batch.append(record)
                success += 1

                if len(batch) >= cls.BATCH_SIZE:
                    db.add_all(batch)
                    await db.commit()
                    batch = []
            except Exception as e:
                errors.append(f"第{row_idx + 2}行: {str(e)}")

        if batch:
            db.add_all(batch)
            await db.commit()

        return {
            "success": success,
            "fail": len(errors),
            "errors": errors[:50],
            "new_fields": new_fields_created,
        }

    @classmethod
    def _parse_cell(cls, val: str, field_type: str) -> Any:
        if not val:
            return None
        if field_type == "number":
            try:
                return float(val) if "." in val else int(val)
            except ValueError:
                return val
        if field_type == "checkbox":
            return val.lower() in ("true", "1", "yes", "是")
        if field_type == "rating":
            try:
                return int(float(val))
            except ValueError:
                return 0
        return val


# ==================== Link / Lookup / Rollup ====================

class SmartLinkService:
    """管理 Link / Lookup / Rollup 字段的创建、删除、关联值解析"""

    # ---------- Link 字段创建 / 删除 ----------

    @classmethod
    async def create_link_field(
        cls,
        db: AsyncSession,
        table_id: str,
        field_name: str,
        target_table_id: str,
        sort: int = 0,
    ) -> Tuple[SmartField, SmartField]:
        """
        创建 Link 字段及目标表的对称 Link 字段。
        返回 (source_field, symmetric_field)。
        """
        source_table = await SmartTableService.get_by_id(db, table_id)
        target_table = await SmartTableService.get_by_id(db, target_table_id)
        if not source_table or not target_table:
            raise ValueError("源表或目标表不存在")

        source_field_data = SmartFieldCreate(
            table_id=table_id,
            name=field_name,
            type="link",
            sort=sort or await SmartFieldService.get_next_sort(db, table_id),
            config={
                "linkedTableId": target_table_id,
            },
        )
        source_field = await SmartFieldService.create(db, source_field_data)

        sym_field_data = SmartFieldCreate(
            table_id=target_table_id,
            name=source_table.name,
            type="link",
            sort=await SmartFieldService.get_next_sort(db, target_table_id),
            config={
                "linkedTableId": table_id,
                "symmetricFieldId": source_field.id,
            },
        )
        sym_field = await SmartFieldService.create(db, sym_field_data)

        source_field.config = {
            **(source_field.config or {}),
            "symmetricFieldId": sym_field.id,
        }
        await db.commit()
        await db.refresh(source_field)

        return source_field, sym_field

    @classmethod
    async def delete_link_field(cls, db: AsyncSession, field_id: str) -> bool:
        """删除 Link 字段、对称字段和所有关联记录"""
        field = await SmartFieldService.get_by_id(db, field_id)
        if not field or field.type != "link":
            return False

        sym_field_id = (field.config or {}).get("symmetricFieldId")

        await db.execute(
            sa_update(SmartTableLink)
            .where(SmartTableLink.field_id == field_id)
            .values(is_deleted=True)
        )

        if sym_field_id:
            await db.execute(
                sa_update(SmartTableLink)
                .where(SmartTableLink.field_id == sym_field_id)
                .values(is_deleted=True)
            )
            sym_field = await SmartFieldService.get_by_id(db, sym_field_id)
            if sym_field:
                sym_field.is_deleted = True

        field.is_deleted = True
        await db.commit()
        return True

    # ---------- 关联记录操作 ----------

    @classmethod
    async def set_linked_records(
        cls,
        db: AsyncSession,
        field_id: str,
        source_record_id: str,
        target_record_ids: List[str],
    ) -> None:
        """
        全量设置关联：先移除旧关联，再插入新关联。
        同时维护对称方向。
        """
        field = await SmartFieldService.get_by_id(db, field_id)
        if not field or field.type != "link":
            return
        sym_field_id = (field.config or {}).get("symmetricFieldId")

        existing = await db.execute(
            select(SmartTableLink).where(
                SmartTableLink.field_id == field_id,
                SmartTableLink.source_record_id == source_record_id,
                SmartTableLink.is_deleted == False,  # noqa: E712
            )
        )
        existing_links = list(existing.scalars().all())
        existing_target_ids = {l.target_record_id for l in existing_links}

        to_add = set(target_record_ids) - existing_target_ids
        to_remove = existing_target_ids - set(target_record_ids)

        for link in existing_links:
            if link.target_record_id in to_remove:
                link.is_deleted = True

        if sym_field_id and to_remove:
            sym_result = await db.execute(
                select(SmartTableLink).where(
                    SmartTableLink.field_id == sym_field_id,
                    SmartTableLink.target_record_id == source_record_id,
                    SmartTableLink.source_record_id.in_(to_remove),
                    SmartTableLink.is_deleted == False,  # noqa: E712
                )
            )
            for sym_link in sym_result.scalars().all():
                sym_link.is_deleted = True

        for tid in to_add:
            db.add(SmartTableLink(
                field_id=field_id,
                source_record_id=source_record_id,
                target_record_id=tid,
            ))
            if sym_field_id:
                db.add(SmartTableLink(
                    field_id=sym_field_id,
                    source_record_id=tid,
                    target_record_id=source_record_id,
                ))

        await db.commit()

    @classmethod
    async def get_linked_record_ids(
        cls, db: AsyncSession, field_id: str, source_record_id: str
    ) -> List[str]:
        result = await db.execute(
            select(SmartTableLink.target_record_id).where(
                SmartTableLink.field_id == field_id,
                SmartTableLink.source_record_id == source_record_id,
                SmartTableLink.is_deleted == False,  # noqa: E712
            )
        )
        return list(result.scalars().all())

    # ---------- 解析关联值（批量注入到 records） ----------

    @classmethod
    async def resolve_link_values(
        cls,
        db: AsyncSession,
        fields: List[SmartField],
        records: List[SmartRecord],
    ) -> None:
        """批量解析 Link 字段值，注入 [{id, title}] 到 record.values"""
        link_fields = [f for f in fields if f.type == "link"]
        if not link_fields or not records:
            return

        record_ids = [r.id for r in records]

        for lf in link_fields:
            result = await db.execute(
                select(SmartTableLink.source_record_id, SmartTableLink.target_record_id)
                .where(
                    SmartTableLink.field_id == lf.id,
                    SmartTableLink.source_record_id.in_(record_ids),
                    SmartTableLink.is_deleted == False,  # noqa: E712
                )
            )
            links = result.all()

            target_ids = list({row[1] for row in links})
            title_map: Dict[str, str] = {}
            if target_ids:
                target_table_id = (lf.config or {}).get("linkedTableId")
                if target_table_id:
                    title_map = await cls._get_record_titles(db, target_table_id, target_ids)

            src_map: Dict[str, List[LinkedRecordItem]] = {}
            for src_id, tgt_id in links:
                src_map.setdefault(src_id, []).append(
                    LinkedRecordItem(id=tgt_id, title=title_map.get(tgt_id, ""))
                )

            for r in records:
                vals = dict(r.values) if r.values else {}
                items = src_map.get(r.id, [])
                vals[lf.id] = [item.model_dump() for item in items]
                r.values = vals

    @classmethod
    async def resolve_lookup_values(
        cls,
        db: AsyncSession,
        fields: List[SmartField],
        records: List[SmartRecord],
    ) -> None:
        """解析 Lookup 字段值：通过 linkFieldId 找到关联记录，取 lookupFieldId 的值"""
        lookup_fields = [f for f in fields if f.type == "lookup"]
        if not lookup_fields or not records:
            return

        record_ids = [r.id for r in records]

        for lkf in lookup_fields:
            cfg = lkf.config or {}
            link_field_id = cfg.get("linkFieldId")
            lookup_field_id = cfg.get("lookupFieldId")
            if not link_field_id or not lookup_field_id:
                continue

            result = await db.execute(
                select(SmartTableLink.source_record_id, SmartTableLink.target_record_id)
                .where(
                    SmartTableLink.field_id == link_field_id,
                    SmartTableLink.source_record_id.in_(record_ids),
                    SmartTableLink.is_deleted == False,  # noqa: E712
                )
            )
            links = result.all()
            target_ids = list({row[1] for row in links})

            target_values: Dict[str, Any] = {}
            if target_ids:
                tgt_result = await db.execute(
                    select(SmartRecord.id, SmartRecord.values).where(
                        SmartRecord.id.in_(target_ids),
                        SmartRecord.is_deleted == False,  # noqa: E712
                    )
                )
                for rid, vals in tgt_result.all():
                    target_values[rid] = (vals or {}).get(lookup_field_id)

            src_map: Dict[str, list] = {}
            for src_id, tgt_id in links:
                v = target_values.get(tgt_id)
                if v is not None:
                    src_map.setdefault(src_id, []).append(v)

            for r in records:
                vals = dict(r.values) if r.values else {}
                vals[lkf.id] = src_map.get(r.id, [])
                r.values = vals

    @classmethod
    async def resolve_rollup_values(
        cls,
        db: AsyncSession,
        fields: List[SmartField],
        records: List[SmartRecord],
    ) -> None:
        """解析 Rollup 字段值：聚合关联记录的某个字段"""
        rollup_fields = [f for f in fields if f.type == "rollup"]
        if not rollup_fields or not records:
            return

        record_ids = [r.id for r in records]

        for rf in rollup_fields:
            cfg = rf.config or {}
            link_field_id = cfg.get("linkFieldId")
            rollup_field_id = cfg.get("rollupFieldId")
            aggregation = cfg.get("aggregation", "COUNT")
            if not link_field_id or not rollup_field_id:
                continue

            result = await db.execute(
                select(SmartTableLink.source_record_id, SmartTableLink.target_record_id)
                .where(
                    SmartTableLink.field_id == link_field_id,
                    SmartTableLink.source_record_id.in_(record_ids),
                    SmartTableLink.is_deleted == False,  # noqa: E712
                )
            )
            links = result.all()
            target_ids = list({row[1] for row in links})

            target_values: Dict[str, Any] = {}
            if target_ids:
                tgt_result = await db.execute(
                    select(SmartRecord.id, SmartRecord.values).where(
                        SmartRecord.id.in_(target_ids),
                        SmartRecord.is_deleted == False,  # noqa: E712
                    )
                )
                for rid, vals in tgt_result.all():
                    target_values[rid] = (vals or {}).get(rollup_field_id)

            src_groups: Dict[str, list] = {}
            for src_id, tgt_id in links:
                v = target_values.get(tgt_id)
                src_groups.setdefault(src_id, []).append(v)

            for r in records:
                vals = dict(r.values) if r.values else {}
                group = src_groups.get(r.id, [])
                vals[rf.id] = cls._aggregate(group, aggregation)
                r.values = vals

    @classmethod
    def _aggregate(cls, values: List[Any], aggregation: str) -> Any:
        agg = aggregation.upper()
        if agg == "COUNT":
            return len(values)
        if agg == "COUNTA":
            return len([v for v in values if v is not None and v != ""])

        nums = []
        for v in values:
            if v is None:
                continue
            try:
                nums.append(float(v))
            except (TypeError, ValueError):
                pass

        if agg == "SUM":
            return sum(nums) if nums else 0
        if agg == "AVG":
            return sum(nums) / len(nums) if nums else None
        if agg == "MIN":
            return min(nums) if nums else None
        if agg == "MAX":
            return max(nums) if nums else None
        return len(values)

    # ---------- 记录删除时清理关联 ----------

    @classmethod
    async def cleanup_record_links(cls, db: AsyncSession, record_id: str) -> None:
        """删除记录时，软删除所有涉及该记录的关联"""
        await db.execute(
            sa_update(SmartTableLink)
            .where(
                or_(
                    SmartTableLink.source_record_id == record_id,
                    SmartTableLink.target_record_id == record_id,
                ),
                SmartTableLink.is_deleted == False,  # noqa: E712
            )
            .values(is_deleted=True)
        )

    # ---------- 搜索目标表记录 ----------

    @classmethod
    async def search_records(
        cls,
        db: AsyncSession,
        table_id: str,
        keyword: str = "",
        limit: int = 20,
    ) -> List[Dict[str, Any]]:
        """搜索指定表的记录，返回 [{id, title}]"""
        fields = await SmartFieldService.get_by_table(db, table_id)
        primary_field = fields[0] if fields else None

        base = select(SmartRecord).where(
            SmartRecord.table_id == table_id,
            SmartRecord.is_deleted == False,  # noqa: E712
        )

        if keyword.strip() and primary_field:
            col = json_extract(SmartRecord.values, primary_field.id)
            base = base.where(col.ilike(f"%{keyword.strip()}%"))

        base = base.order_by(SmartRecord.sort, SmartRecord.id).limit(limit)
        result = await db.execute(base)
        rows = list(result.scalars().all())

        items = []
        for r in rows:
            title = ""
            if primary_field:
                title = str((r.values or {}).get(primary_field.id, "") or "")
            items.append({"id": r.id, "title": title})
        return items

    # ---------- 内部工具 ----------

    @classmethod
    async def _get_record_titles(
        cls, db: AsyncSession, table_id: str, record_ids: List[str]
    ) -> Dict[str, str]:
        """批量获取记录的标题（取第一个字段的值）"""
        fields = await SmartFieldService.get_by_table(db, table_id)
        primary_field = fields[0] if fields else None
        if not primary_field:
            return {}

        result = await db.execute(
            select(SmartRecord.id, SmartRecord.values).where(
                SmartRecord.id.in_(record_ids),
                SmartRecord.is_deleted == False,  # noqa: E712
            )
        )
        title_map: Dict[str, str] = {}
        for rid, vals in result.all():
            title_map[rid] = str((vals or {}).get(primary_field.id, "") or "")
        return title_map


class SmartSummaryService:
    """字段汇总聚合计算 - 合并多字段聚合为尽量少的SQL"""

    SUPPORTED = {"SUM", "AVG", "MIN", "MAX", "COUNT", "COUNTA", "COUNT_EMPTY", "PERCENT_EMPTY", "PERCENT_FILLED"}

    @classmethod
    async def compute(
        cls,
        db: AsyncSession,
        table_id: str,
        field_agg_map: Dict[str, str],
        filters: Optional[List[RecordFilterRule]] = None,
        filter_logic: str = "and",
        search: Optional[str] = None,
        extra_conditions: Optional[list] = None,
    ) -> Tuple[Dict[str, Any], int]:
        """
        对指定字段执行聚合计算，将同类聚合合并为单条SQL减少查询次数。
        field_agg_map: {fieldId: aggregation_type}
        返回 ({fieldId: result_value}, total_count)
        """
        base = select(SmartRecord).where(
            SmartRecord.table_id == table_id,
            SmartRecord.is_deleted == False,  # noqa: E712
        )

        if filters:
            filter_conds = [SmartRecordService._build_filter_condition(f) for f in filters]
            if filter_logic == "or":
                base = base.where(or_(*filter_conds))
            else:
                base = base.where(and_(*filter_conds))

        if search and search.strip():
            search_cond = SmartRecordService._build_search_conditions(search.strip())
            if search_cond is not None:
                base = base.where(search_cond)

        if extra_conditions:
            for cond in extra_conditions:
                base = base.where(cond)

        subq = base.subquery()

        count_result = await db.execute(select(func.count()).select_from(subq))
        total = count_result.scalar() or 0

        if total == 0:
            return {fid: None for fid in field_agg_map}, 0

        summaries: Dict[str, Any] = {}
        db_type = get_db_type()

        numeric_fields: Dict[str, str] = {}
        count_needed_fields: Dict[str, str] = {}

        for field_id, agg_type in field_agg_map.items():
            agg_upper = agg_type.upper()
            if agg_upper not in cls.SUPPORTED:
                summaries[field_id] = None
            elif agg_upper == "COUNT":
                summaries[field_id] = total
            elif agg_upper in ("SUM", "AVG", "MIN", "MAX"):
                numeric_fields[field_id] = agg_upper
            else:
                count_needed_fields[field_id] = agg_upper

        alias = subq.alias("sub")
        agg_fn_map = {"SUM": func.sum, "AVG": func.avg, "MIN": func.min, "MAX": func.max}
        all_columns = []
        all_labels: List[Tuple[str, str, str]] = []

        for field_id, agg_type in numeric_fields.items():
            if db_type == "postgresql":
                num_expr = text(f"CAST(sub.\"values\" ->> '{field_id}' AS NUMERIC)")
                cond = text(f"(sub.\"values\" ->> '{field_id}') ~ '^-?[0-9]+(\\.[0-9]+)?$'")
            else:
                num_expr = text(
                    f"CAST(JSON_UNQUOTE(JSON_EXTRACT(sub.`values`, '$.{field_id}')) AS DECIMAL(20,6))"
                )
                cond = text(
                    f"JSON_UNQUOTE(JSON_EXTRACT(sub.`values`, '$.{field_id}')) REGEXP '^-?[0-9]+(\\\\.[0-9]+)?$'"
                )
            agg_fn = agg_fn_map[agg_type]
            label = f"num_{field_id}"
            all_columns.append(agg_fn(case((cond, num_expr), else_=None)).label(label))
            all_labels.append((field_id, label, "numeric"))

        unique_count_fields = set(count_needed_fields.keys())
        for field_id in unique_count_fields:
            if db_type == "postgresql":
                not_null_cond = text(
                    f"sub.\"values\" ->> '{field_id}' IS NOT NULL "
                    f"AND sub.\"values\" ->> '{field_id}' != ''"
                )
            else:
                not_null_cond = text(
                    f"JSON_EXTRACT(sub.`values`, '$.{field_id}') IS NOT NULL "
                    f"AND JSON_UNQUOTE(JSON_EXTRACT(sub.`values`, '$.{field_id}')) != ''"
                )
            label = f"cnt_{field_id}"
            all_columns.append(func.count(case((not_null_cond, 1), else_=None)).label(label))
            all_labels.append((field_id, label, "count"))

        if all_columns:
            stmt = select(*all_columns).select_from(alias)
            row = (await db.execute(stmt)).first()
            if row:
                for field_id, label, col_type in all_labels:
                    val = getattr(row, label, None)
                    if col_type == "numeric":
                        summaries[field_id] = round(float(val), 6) if val is not None else None
                    else:
                        non_empty = val or 0
                        agg_type = count_needed_fields[field_id]
                        if agg_type == "COUNTA":
                            summaries[field_id] = non_empty
                        elif agg_type == "COUNT_EMPTY":
                            summaries[field_id] = total - non_empty
                        elif agg_type == "PERCENT_EMPTY":
                            summaries[field_id] = round((total - non_empty) / total * 100, 1) if total > 0 else 0
                        elif agg_type == "PERCENT_FILLED":
                            summaries[field_id] = round(non_empty / total * 100, 1) if total > 0 else 0

        return summaries, total


class SmartFormulaService:
    """公式字段计算服务：在返回记录时动态计算公式字段的值"""

    @classmethod
    def resolve_formula_values(
        cls, fields: List[SmartField], records: list
    ) -> None:
        """遍历公式字段，对每条记录计算公式值并注入 record.values（同步，不需要 DB）"""
        from zq_smart_table.formula import compute_formula

        formula_fields = [
            f for f in fields
            if f.type == "formula" and f.config and f.config.get("formula")
        ]
        if not formula_fields:
            return

        field_name_map = {f.name: f.id for f in fields}

        for record in records:
            values = record.values if record.values else {}
            for ff in formula_fields:
                formula_str = ff.config["formula"]
                result = compute_formula(formula_str, values, field_name_map)
                result_type = ff.config.get("formulaResultType", "text")
                values[ff.id] = cls._cast_result(result, result_type)
            record.values = values

    @staticmethod
    def _cast_result(value: Any, result_type: str) -> Any:
        if value == "#ERROR":
            return value
        if result_type == "number":
            try:
                return float(value) if value is not None else None
            except (ValueError, TypeError):
                return "#ERROR"
        if result_type == "boolean":
            if isinstance(value, bool):
                return value
            return bool(value) if value is not None else False
        if result_type == "date":
            return str(value) if value is not None else None
        return str(value) if value is not None else ""


class SmartValidationService:
    """字段数据校验服务"""

    @classmethod
    async def validate_cell(
        cls,
        db: AsyncSession,
        field: SmartField,
        value: Any,
        record_id: Optional[str] = None,
    ) -> Optional[str]:
        """
        校验单个单元格值，返回错误消息或 None（通过）。
        校验规则存储在 field.config["validation"] 中。
        """
        import re as _re

        config = field.config or {}
        validation = config.get("validation")
        if not validation:
            return None

        if field.required and (value is None or value == "" or value == []):
            custom = validation.get("message")
            return custom or f"「{field.name}」不能为空"

        if value is None or value == "" or value == []:
            return None

        if "min" in validation and validation["min"] is not None:
            try:
                num_val = float(value)
                if num_val < float(validation["min"]):
                    return validation.get("message") or f"「{field.name}」不能小于 {validation['min']}"
            except (ValueError, TypeError):
                pass

        if "max" in validation and validation["max"] is not None:
            try:
                num_val = float(value)
                if num_val > float(validation["max"]):
                    return validation.get("message") or f"「{field.name}」不能大于 {validation['max']}"
            except (ValueError, TypeError):
                pass

        if "minLength" in validation and validation["minLength"] is not None:
            str_val = str(value)
            if len(str_val) < int(validation["minLength"]):
                return validation.get("message") or f"「{field.name}」长度不能少于 {validation['minLength']} 个字符"

        if "maxLength" in validation and validation["maxLength"] is not None:
            str_val = str(value)
            if len(str_val) > int(validation["maxLength"]):
                return validation.get("message") or f"「{field.name}」长度不能超过 {validation['maxLength']} 个字符"

        if "pattern" in validation and validation["pattern"]:
            str_val = str(value)
            try:
                if not _re.fullmatch(validation["pattern"], str_val):
                    return validation.get("message") or f"「{field.name}」格式不正确"
            except _re.error:
                pass

        if validation.get("unique"):
            is_dup = await cls._check_unique(db, field, value, record_id)
            if is_dup:
                return validation.get("message") or f"「{field.name}」的值已存在，不能重复"

        return None

    @classmethod
    async def _check_unique(
        cls,
        db: AsyncSession,
        field: SmartField,
        value: Any,
        exclude_record_id: Optional[str] = None,
    ) -> bool:
        db_type = get_db_type()
        str_val = str(value)

        if db_type == "postgresql":
            cond = text(f"\"values\" ->> '{field.id}' = :v")
        else:
            cond = text(f"JSON_UNQUOTE(JSON_EXTRACT(`values`, '$.{field.id}')) = :v")

        stmt = (
            select(func.count())
            .select_from(SmartRecord.__table__)
            .where(
                SmartRecord.table_id == field.table_id,
                SmartRecord.is_deleted == False,  # noqa: E712
                cond.bindparams(v=str_val),
            )
        )
        if exclude_record_id:
            stmt = stmt.where(SmartRecord.id != exclude_record_id)

        result = await db.execute(stmt)
        return (result.scalar() or 0) > 0

    @classmethod
    async def validate_cells_batch(
        cls,
        db: AsyncSession,
        table_id: str,
        cells: Dict[str, Any],
        record_id: Optional[str] = None,
    ) -> Dict[str, str]:
        """批量校验多个单元格，返回 {fieldId: errorMessage}"""
        fields = await SmartFieldService.get_by_table(db, table_id)
        field_map = {f.id: f for f in fields}
        errors: Dict[str, str] = {}

        for field_id, value in cells.items():
            field = field_map.get(field_id)
            if not field:
                continue
            err = await cls.validate_cell(db, field, value, record_id)
            if err:
                errors[field_id] = err

        return errors


class SmartCommentService:
    """记录评论服务"""

    @classmethod
    async def get_by_record(cls, db: AsyncSession, record_id: str) -> List[SmartTableComment]:
        result = await db.execute(
            select(SmartTableComment)
            .where(SmartTableComment.record_id == record_id, SmartTableComment.is_deleted == False)  # noqa: E712
            .order_by(SmartTableComment.sys_create_datetime.asc())
        )
        return list(result.scalars().all())

    @classmethod
    async def create(cls, db: AsyncSession, record_id: str, user_id: str, content: str,
                     mentions: List[str] = None, parent_id: str = None) -> SmartTableComment:
        comment = SmartTableComment(
            record_id=record_id,
            user_id=user_id,
            content=content,
            mentions=mentions or [],
            parent_id=parent_id,
            sys_creator_id=user_id,
        )
        db.add(comment)
        await db.commit()
        await db.refresh(comment)
        return comment

    @classmethod
    async def update(cls, db: AsyncSession, comment_id: str, user_id: str,
                     content: str, mentions: List[str] = None) -> Optional[SmartTableComment]:
        result = await db.execute(
            select(SmartTableComment)
            .where(SmartTableComment.id == comment_id, SmartTableComment.is_deleted == False)  # noqa: E712
        )
        comment = result.scalar_one_or_none()
        if not comment or comment.user_id != user_id:
            return None
        comment.content = content
        comment.mentions = mentions or []
        comment.sys_modifier_id = user_id
        await db.commit()
        await db.refresh(comment)
        return comment

    @classmethod
    async def delete(cls, db: AsyncSession, comment_id: str, user_id: str) -> bool:
        result = await db.execute(
            select(SmartTableComment)
            .where(SmartTableComment.id == comment_id, SmartTableComment.is_deleted == False)  # noqa: E712
        )
        comment = result.scalar_one_or_none()
        if not comment or comment.user_id != user_id:
            return False
        comment.is_deleted = True
        comment.sys_modifier_id = user_id
        await db.commit()
        return True


class SmartDocumentVersionService:
    """文档版本历史服务"""

    MAX_VERSIONS_PER_DOC = 100

    @classmethod
    async def get_next_version(cls, db: AsyncSession, document_id: str) -> int:
        result = await db.execute(
            select(func.coalesce(func.max(SmartDocumentVersion.version), 0))
            .where(
                SmartDocumentVersion.document_id == document_id,
                SmartDocumentVersion.is_deleted == False,  # noqa: E712
            )
        )
        return (result.scalar() or 0) + 1

    @classmethod
    async def create_version(
        cls,
        db: AsyncSession,
        document_id: str,
        content: Dict[str, Any],
        title: Optional[str] = None,
        change_summary: Optional[str] = None,
        user_id: Optional[str] = None,
    ) -> SmartDocumentVersion:
        import json
        version_num = await cls.get_next_version(db, document_id)
        content_size = len(json.dumps(content, ensure_ascii=False))

        version = SmartDocumentVersion(
            document_id=document_id,
            version=version_num,
            content=content,
            title=title,
            change_summary=change_summary,
            content_size=content_size,
            sys_creator_id=user_id,
        )
        db.add(version)
        await db.commit()
        await db.refresh(version)

        await cls._cleanup_old_versions(db, document_id)
        return version

    @classmethod
    async def _cleanup_old_versions(cls, db: AsyncSession, document_id: str) -> None:
        """保留最近 MAX_VERSIONS_PER_DOC 个版本，软删除更早的"""
        result = await db.execute(
            select(SmartDocumentVersion.id)
            .where(
                SmartDocumentVersion.document_id == document_id,
                SmartDocumentVersion.is_deleted == False,  # noqa: E712
            )
            .order_by(SmartDocumentVersion.version.desc())
            .offset(cls.MAX_VERSIONS_PER_DOC)
        )
        old_ids = [row[0] for row in result.all()]
        if old_ids:
            await db.execute(
                sa_update(SmartDocumentVersion)
                .where(SmartDocumentVersion.id.in_(old_ids))
                .values(is_deleted=True)
            )
            await db.commit()

    @classmethod
    async def get_versions(
        cls,
        db: AsyncSession,
        document_id: str,
        page: int = 1,
        page_size: int = 20,
    ) -> Tuple[List[SmartDocumentVersion], int]:
        base = (
            select(SmartDocumentVersion)
            .where(
                SmartDocumentVersion.document_id == document_id,
                SmartDocumentVersion.is_deleted == False,  # noqa: E712
            )
        )
        count_result = await db.execute(
            select(func.count()).select_from(base.subquery())
        )
        total = count_result.scalar() or 0

        result = await db.execute(
            base.order_by(SmartDocumentVersion.version.desc())
            .offset((page - 1) * page_size)
            .limit(page_size)
        )
        return list(result.scalars().all()), total

    @classmethod
    async def get_version_detail(
        cls, db: AsyncSession, version_id: str
    ) -> Optional[SmartDocumentVersion]:
        result = await db.execute(
            select(SmartDocumentVersion)
            .where(
                SmartDocumentVersion.id == version_id,
                SmartDocumentVersion.is_deleted == False,  # noqa: E712
            )
        )
        return result.scalar_one_or_none()

    @classmethod
    async def get_version_by_number(
        cls, db: AsyncSession, document_id: str, version: int
    ) -> Optional[SmartDocumentVersion]:
        result = await db.execute(
            select(SmartDocumentVersion)
            .where(
                SmartDocumentVersion.document_id == document_id,
                SmartDocumentVersion.version == version,
                SmartDocumentVersion.is_deleted == False,  # noqa: E712
            )
        )
        return result.scalar_one_or_none()

    @classmethod
    async def restore_version(
        cls, db: AsyncSession, document_id: str, version_id: str, user_id: Optional[str] = None
    ) -> Optional[SmartDocumentVersion]:
        """恢复到指定版本：先快照当前内容，再将目标版本内容写回文档"""
        version = await cls.get_version_detail(db, version_id)
        if not version or version.document_id != document_id:
            return None

        table = await db.execute(
            select(SmartTable)
            .where(SmartTable.id == document_id, SmartTable.is_deleted == False)  # noqa: E712
        )
        doc = table.scalar_one_or_none()
        if not doc:
            return None

        if doc.content:
            await cls.create_version(
                db, document_id, doc.content,
                title=doc.name,
                change_summary=f"恢复版本 {version.version} 前的自动快照",
                user_id=user_id,
            )

        doc.content = version.content
        doc.sys_modifier_id = user_id
        await db.commit()

        new_version = await cls.create_version(
            db, document_id, version.content,
            title=doc.name,
            change_summary=f"恢复至版本 {version.version}",
            user_id=user_id,
        )
        return new_version

    @classmethod
    async def delete_version(cls, db: AsyncSession, version_id: str) -> bool:
        result = await db.execute(
            select(SmartDocumentVersion)
            .where(
                SmartDocumentVersion.id == version_id,
                SmartDocumentVersion.is_deleted == False,  # noqa: E712
            )
        )
        version = result.scalar_one_or_none()
        if not version:
            return False
        version.is_deleted = True
        await db.commit()
        return True


class SmartDocumentTemplateService:
    """文档模板服务"""

    @classmethod
    async def get_list(
        cls,
        db: AsyncSession,
        category: Optional[str] = None,
        keyword: Optional[str] = None,
        page: int = 1,
        page_size: int = 50,
    ) -> Tuple[List[SmartDocumentTemplate], int]:
        base = select(SmartDocumentTemplate).where(
            SmartDocumentTemplate.is_deleted == False  # noqa: E712
        )
        if category:
            base = base.where(SmartDocumentTemplate.category == category)
        if keyword:
            base = base.where(
                or_(
                    SmartDocumentTemplate.name.ilike(f"%{keyword}%"),
                    SmartDocumentTemplate.description.ilike(f"%{keyword}%"),
                )
            )

        count_result = await db.execute(
            select(func.count()).select_from(base.subquery())
        )
        total = count_result.scalar() or 0

        result = await db.execute(
            base.order_by(
                SmartDocumentTemplate.is_system.desc(),
                SmartDocumentTemplate.use_count.desc(),
                SmartDocumentTemplate.sys_create_datetime.desc(),
            )
            .offset((page - 1) * page_size)
            .limit(page_size)
        )
        return list(result.scalars().all()), total

    @classmethod
    async def get_by_id(
        cls, db: AsyncSession, template_id: str
    ) -> Optional[SmartDocumentTemplate]:
        result = await db.execute(
            select(SmartDocumentTemplate)
            .where(
                SmartDocumentTemplate.id == template_id,
                SmartDocumentTemplate.is_deleted == False,  # noqa: E712
            )
        )
        return result.scalar_one_or_none()

    @classmethod
    async def create(
        cls,
        db: AsyncSession,
        name: str,
        content: Dict[str, Any],
        description: Optional[str] = None,
        icon: str = "FileText",
        category: str = "custom",
        preview_image: Optional[str] = None,
        user_id: Optional[str] = None,
    ) -> SmartDocumentTemplate:
        template = SmartDocumentTemplate(
            name=name,
            description=description,
            icon=icon,
            category=category,
            content=content,
            preview_image=preview_image,
            is_system=False,
            sys_creator_id=user_id,
        )
        db.add(template)
        await db.commit()
        await db.refresh(template)
        return template

    @classmethod
    async def update(
        cls,
        db: AsyncSession,
        template_id: str,
        data: Dict[str, Any],
        user_id: Optional[str] = None,
    ) -> Optional[SmartDocumentTemplate]:
        template = await cls.get_by_id(db, template_id)
        if not template:
            return None
        for key, value in data.items():
            if value is not None and hasattr(template, key):
                setattr(template, key, value)
        template.sys_modifier_id = user_id
        await db.commit()
        await db.refresh(template)
        return template

    @classmethod
    async def delete(cls, db: AsyncSession, template_id: str) -> bool:
        template = await cls.get_by_id(db, template_id)
        if not template:
            return False
        if template.is_system:
            return False
        template.is_deleted = True
        await db.commit()
        return True

    @classmethod
    async def increment_use_count(cls, db: AsyncSession, template_id: str) -> None:
        await db.execute(
            sa_update(SmartDocumentTemplate)
            .where(SmartDocumentTemplate.id == template_id)
            .values(use_count=SmartDocumentTemplate.use_count + 1)
        )
        await db.commit()

    @classmethod
    async def get_categories(cls, db: AsyncSession) -> List[str]:
        result = await db.execute(
            select(SmartDocumentTemplate.category)
            .where(SmartDocumentTemplate.is_deleted == False)  # noqa: E712
            .distinct()
        )
        return [row[0] for row in result.all()]

    @classmethod
    async def create_from_document(
        cls,
        db: AsyncSession,
        document_id: str,
        name: str,
        description: Optional[str] = None,
        category: str = "custom",
        user_id: Optional[str] = None,
    ) -> Optional[SmartDocumentTemplate]:
        """从现有文档创建模板"""
        doc_result = await db.execute(
            select(SmartTable)
            .where(SmartTable.id == document_id, SmartTable.is_deleted == False)  # noqa: E712
        )
        doc = doc_result.scalar_one_or_none()
        if not doc or getattr(doc, "type", "table") != "document" or not doc.content:
            return None

        return await cls.create(
            db, name=name, content=doc.content,
            description=description, category=category, user_id=user_id,
        )


class WikiSpaceService(BaseService[SmartWikiSpace, WikiSpaceCreate, WikiSpaceUpdate]):
    model = SmartWikiSpace
    RESOURCE_TYPE = "wiki_space"

    @classmethod
    async def get_list_with_count(
        cls, db: AsyncSession, page: int = 1, page_size: int = 100,
        user_id: Optional[str] = None,
        is_superuser: bool = False,
    ) -> Tuple[List[dict], int]:
        """获取文档库列表，附带每个库的文档数量。非超管只能看到自己创建的或 public/team 的"""
        base_query = select(SmartWikiSpace).where(SmartWikiSpace.is_deleted == False)  # noqa: E712

        if not is_superuser and user_id:
            base_query = base_query.where(
                or_(
                    SmartWikiSpace.sys_creator_id == user_id,
                    SmartWikiSpace.visibility.in_(["public", "team"]),
                )
            )
        elif not is_superuser:
            base_query = base_query.where(
                SmartWikiSpace.visibility.in_(["public", "team"])
            )

        count_result = await db.execute(
            select(func.count()).select_from(base_query.subquery())
        )
        total = count_result.scalar() or 0

        offset = (page - 1) * page_size
        spaces_result = await db.execute(
            base_query.order_by(desc(SmartWikiSpace.sort), desc(SmartWikiSpace.sys_create_datetime))
            .offset(offset)
            .limit(page_size)
        )
        spaces = list(spaces_result.scalars().all())

        result = []
        for space in spaces:
            count_q = await db.execute(
                select(func.count(SmartTable.id))
                .where(
                    SmartTable.wiki_space_id == space.id,
                    SmartTable.is_deleted == False,  # noqa: E712
                )
            )
            doc_count = count_q.scalar() or 0
            result.append({
                "space": space,
                "document_count": doc_count,
            })
        return result, total

    @classmethod
    async def get_documents(
        cls, db: AsyncSession, space_id: str,
        user_id: Optional[str] = None,
        dept_id: Optional[str] = None,
        role_ids: Optional[List[str]] = None,
        is_superuser: bool = False,
    ) -> List[SmartTable]:
        """获取文档库内的文档（按 sort 排序），非超管只能看到自己有权限的"""
        from zq_smart_table.permission.model import SmartTableCollaborator

        base_query = (
            select(SmartTable)
            .where(
                SmartTable.wiki_space_id == space_id,
                SmartTable.is_deleted == False,  # noqa: E712
            )
        )

        if not is_superuser and user_id:
            subject_conds = [
                and_(
                    SmartTableCollaborator.subject_type == "user",
                    SmartTableCollaborator.subject_id == user_id,
                )
            ]
            if dept_id:
                subject_conds.append(
                    and_(
                        SmartTableCollaborator.subject_type == "dept",
                        SmartTableCollaborator.subject_id == dept_id,
                    )
                )
            if role_ids:
                for rid in role_ids:
                    subject_conds.append(
                        and_(
                            SmartTableCollaborator.subject_type == "role",
                            SmartTableCollaborator.subject_id == rid,
                        )
                    )

            collab_table_ids = (
                select(SmartTableCollaborator.table_id)
                .where(
                    SmartTableCollaborator.is_deleted == False,  # noqa: E712
                    or_(*subject_conds),
                )
                .distinct()
            )

            base_query = base_query.where(
                or_(
                    SmartTable.sys_creator_id == user_id,
                    SmartTable.id.in_(collab_table_ids),
                )
            )

        result = await db.execute(
            base_query.order_by(SmartTable.sort, SmartTable.sys_create_datetime)
        )
        return list(result.scalars().all())

    @classmethod
    async def check_space_access(
        cls, space: SmartWikiSpace,
        user_id: Optional[str] = None,
        is_superuser: bool = False,
    ) -> bool:
        """检查用户是否有权访问该文档库"""
        if is_superuser:
            return True
        if space.visibility in ("public", "team"):
            return True
        if user_id and space.sys_creator_id == user_id:
            return True
        return False

    @classmethod
    async def add_document(
        cls,
        db: AsyncSession,
        space_id: str,
        name: str,
        parent_id: Optional[str] = None,
        content: Optional[dict] = None,
        user_id: Optional[str] = None,
    ) -> SmartTable:
        """在文档库中创建文档"""
        max_sort_q = await db.execute(
            select(func.coalesce(func.max(SmartTable.sort), 0))
            .where(
                SmartTable.wiki_space_id == space_id,
                SmartTable.is_deleted == False,  # noqa: E712
            )
        )
        next_sort = (max_sort_q.scalar() or 0) + 1

        doc = SmartTable(
            name=name,
            icon="FileText",
            type="document",
            wiki_space_id=space_id,
            parent_id=parent_id,
            content=content,
            sort=next_sort,
        )
        if user_id:
            doc.sys_creator_id = user_id
            doc.sys_modifier_id = user_id
        db.add(doc)
        await db.commit()
        await db.refresh(doc)
        return doc

    @classmethod
    async def delete_with_documents(cls, db: AsyncSession, space_id: str) -> bool:
        """软删除文档库及其所有文档"""
        space = await cls.get_by_id(db, space_id)
        if not space:
            return False

        await db.execute(
            sa_update(SmartTable)
            .where(
                SmartTable.wiki_space_id == space_id,
                SmartTable.is_deleted == False,  # noqa: E712
            )
            .values(is_deleted=True)
        )

        await cls.delete(db, space_id)
        return True