package services

import (
	"errors"
	"fmt"
	"sort"
	"strconv"
	"strings"
	"time"

	"server/models"

	"github.com/beego/beego/v2/client/orm"
)

// OA 文档管理业务逻辑层（文档库 + 文档图谱）。
// 只处理业务与数据访问，不感知 HTTP；错误以 error 向上抛出，由控制器转译。

// 业务错误
var (
	ErrDocCategoryNotFound   = errors.New("分类不存在")
	ErrDocCategoryHasChild   = errors.New("存在子分类，请先删除子分类")
	ErrDocCategoryHasDoc     = errors.New("分类下仍有文档，请先移动或删除")
	ErrDocCategoryNameEmpty  = errors.New("请输入分类名称")
	ErrDocCategoryCircular   = errors.New("不能将分类移动到自己或其子分类下")
	ErrDocNotFound           = errors.New("文档不存在")
	ErrDocTitleEmpty         = errors.New("请输入文档标题")
	ErrDocCategoryInvalid    = errors.New("所属分类不存在")
	ErrDocLinkSelf           = errors.New("不能关联文档自身")
	ErrDocLinkDuplicate      = errors.New("该关联关系已存在")
	ErrDocLinkTargetNotFound = errors.New("被关联的文档不存在")
	ErrDocLinkNotFound       = errors.New("关联关系不存在")
	ErrDocIDEmpty            = errors.New("请选择要操作的文档")
	ErrDocNoPermission       = errors.New("无权操作该私密文档")
)

// ---------------- 访问者上下文与可见性 ----------------

// OaDocActor 文档访问者上下文。
//
// 两级隔离：
//  1. 租户隔离：所有查询强制带 tid，tid 只取自 JWT，前端无法指定；
//  2. 用户隔离：visibility=1 的私密文档，仅创建者、被共享者（用户/部门）可见；
//     group_id=0 的用户沿用系统既有约定（未分配角色视为全权限），可查看全部私密文档。
type OaDocActor struct {
	Tid     int      // 租户ID
	UID     uint64   // 登录用户ID（yz_system_tenant_user.uid）
	OrgIDs  []uint64 // 所属部门及全部子部门ID
	IsAdmin bool     // 是否全权限（group_id=0）
}

// NewOaDocActor 构造访问者上下文。
// uid 为 backend 端 JWT 的 UserID，即 yz_system_tenant_user.uid。
func NewOaDocActor(tid int, uid uint64) OaDocActor {
	models.EnsureOaDocumentTables()
	models.EnsureTenantUserOrgColumn()

	actor := OaDocActor{Tid: tid, UID: uid, OrgIDs: []uint64{}}

	var user models.SystemTenantUser
	if err := models.Orm.QueryTable(new(models.SystemTenantUser)).
		Filter("tid", tid).
		Filter("uid", uid).
		Filter("delete_time__isnull", true).
		One(&user); err != nil {
		// 查不到归属信息时退化为"普通用户"，仅能看公开文档
		return actor
	}
	actor.IsAdmin = user.GroupID == 0
	if user.OrgID > 0 {
		actor.OrgIDs = oaDocOrgSubTree(tid, user.OrgID)
	}
	return actor
}

// oaDocOrgSubTree 返回指定组织及其全部子组织 ID（含自身）。
func oaDocOrgSubTree(tid int, rootID uint64) []uint64 {
	var orgs []models.BackendOrganization
	if _, err := models.Orm.QueryTable(new(models.BackendOrganization)).
		Filter("tid", tid).
		Filter("delete_time__isnull", true).
		All(&orgs); err != nil {
		return []uint64{rootID}
	}

	children := make(map[uint64][]uint64, len(orgs))
	for _, o := range orgs {
		children[o.ParentID] = append(children[o.ParentID], o.ID)
	}

	result := []uint64{rootID}
	var walk func(id uint64)
	walk = func(id uint64) {
		for _, cid := range children[id] {
			if cid == rootID {
				continue
			}
			result = append(result, cid)
			walk(cid)
		}
	}
	walk(rootID)
	return result
}

// oaDocSharedDocIDs 查询共享给该访问者（本人或所属部门）的文档 ID。
func oaDocSharedDocIDs(a OaDocActor) []uint64 {
	if a.UID == 0 && len(a.OrgIDs) == 0 {
		return nil
	}
	orgIDs := a.OrgIDs
	if len(orgIDs) == 0 {
		orgIDs = []uint64{0} // 避免 SQL 出现 IN ()
	}

	userCond := orm.NewCondition().
		And("share_type", models.DocShareTypeUser).
		And("target_id", a.UID)
	orgCond := orm.NewCondition().
		And("share_type", models.DocShareTypeOrg).
		And("target_id__in", orgIDs)
	cond := orm.NewCondition().
		And("tid", a.Tid).
		AndCond(orm.NewCondition().OrCond(userCond).OrCond(orgCond))

	var rows []models.OaDocShare
	if _, err := models.Orm.QueryTable(new(models.OaDocShare)).SetCond(cond).All(&rows); err != nil {
		return nil
	}

	seen := make(map[uint64]bool, len(rows))
	ids := make([]uint64, 0, len(rows))
	for _, r := range rows {
		if !seen[r.DocID] {
			seen[r.DocID] = true
			ids = append(ids, r.DocID)
		}
	}
	return ids
}

// oaDocVisibleCond 生成可见性条件；管理员返回 nil 表示不限制。
// 可见 = 公开 OR 本人创建 OR 已共享给本人/所属部门
func oaDocVisibleCond(a OaDocActor) *orm.Condition {
	if a.IsAdmin {
		return nil
	}
	shared := oaDocSharedDocIDs(a)
	if len(shared) == 0 {
		shared = []uint64{0} // 避免 SQL 出现 IN ()
	}
	return orm.NewCondition().
		Or("visibility", models.DocVisibilityPublic).
		Or("creator_id", a.UID).
		Or("id__in", shared)
}

// oaDocApplyVisible 给既有查询集叠加可见性条件（保留此前设置的过滤条件）。
func oaDocApplyVisible(qs orm.QuerySeter, a OaDocActor) orm.QuerySeter {
	cond := oaDocVisibleCond(a)
	if cond == nil {
		return qs
	}
	return qs.SetCond(qs.GetCond().AndCond(cond))
}

// oaDocVisibleIDSet 从给定文档 ID 中筛出当前访问者可见的部分。
func oaDocVisibleIDSet(a OaDocActor, ids []uint64) map[uint64]bool {
	out := make(map[uint64]bool, len(ids))
	if len(ids) == 0 {
		return out
	}
	var idList orm.ParamsList
	qs := oaDocApplyVisible(oaDocBase(a.Tid).Filter("id__in", ids), a)
	if _, err := qs.ValuesFlat(&idList, "Id"); err != nil {
		return out
	}
	for _, v := range idList {
		if id, err := strconv.ParseUint(fmt.Sprint(v), 10, 64); err == nil {
			out[id] = true
		}
	}
	return out
}

// oaDocCanManage 私密文档的管理权限：仅创建者与全权限用户可改删。
// 公开文档沿用租户内共享编辑的既有行为。
func oaDocCanManage(a OaDocActor, doc *models.OaDoc) bool {
	if a.IsAdmin || doc.Visibility != models.DocVisibilityPrivate {
		return true
	}
	return doc.CreatorID == a.UID
}

// 文档关系中文名
var docRelationLabel = map[string]string{
	models.DocRelationReference: "引用",
	models.DocRelationRelated:   "相关",
	models.DocRelationVersion:   "版本",
	models.DocRelationBelong:    "从属",
}

// DocRelationLabel 返回关系的中文名，未知关系原样返回。
func DocRelationLabel(relation string) string {
	if v, ok := docRelationLabel[relation]; ok {
		return v
	}
	return relation
}

// ---------------- 分类 ----------------

// OaDocCategoryItem 分类树节点（附带文档数量）
type OaDocCategoryItem struct {
	models.OaDocCategory
	DocCount int64                `json:"doc_count"`
	Children []*OaDocCategoryItem `json:"children"`
}

// oaDocCategoryBase 租户内未删除分类的基础查询集
func oaDocCategoryBase(tid int) orm.QuerySeter {
	return models.Orm.QueryTable(new(models.OaDocCategory)).
		Filter("tid", tid).
		Filter("is_deleted", 0)
}

// OaDocCategoryTree 返回分类树，每个节点附带该分类下的文档数量（仅统计直属文档）。
// 数量统计同样受可见性约束：无权限的私密文档不计入。
func OaDocCategoryTree(a OaDocActor) ([]*OaDocCategoryItem, error) {
	models.EnsureOaDocumentTables()

	var list []models.OaDocCategory
	if _, err := oaDocCategoryBase(a.Tid).OrderBy("sort", "id").All(&list); err != nil && err != orm.ErrNoRows {
		return nil, err
	}

	counts, err := OaDocCountByCategory(a)
	if err != nil {
		return nil, err
	}

	nodes := make(map[uint64]*OaDocCategoryItem, len(list))
	roots := make([]*OaDocCategoryItem, 0, len(list))
	for i := range list {
		item := &OaDocCategoryItem{
			OaDocCategory: list[i],
			DocCount:      counts[list[i].ID],
			Children:      []*OaDocCategoryItem{},
		}
		nodes[item.ID] = item
	}
	for i := range list {
		item := nodes[list[i].ID]
		if parent, ok := nodes[list[i].ParentID]; ok && list[i].ParentID != 0 {
			parent.Children = append(parent.Children, item)
		} else {
			roots = append(roots, item)
		}
	}
	return roots, nil
}

// OaDocCountByCategory 统计各分类下未删除文档的数量（仅统计当前访问者可见的文档）。
func OaDocCountByCategory(a OaDocActor) (map[uint64]int64, error) {
	models.EnsureOaDocumentTables()

	sql := "SELECT category_id, COUNT(*) AS cnt FROM yz_backend_oa_doc WHERE tid = ? AND is_deleted = 0"
	args := []interface{}{a.Tid}
	if !a.IsAdmin {
		shared := oaDocSharedDocIDs(a)
		if len(shared) == 0 {
			shared = []uint64{0}
		}
		placeholders := make([]string, len(shared))
		for i := range shared {
			placeholders[i] = "?"
		}
		// 占位符顺序需与 args 一致：先 creator_id，再 IN (...)
		args = append(args, a.UID)
		for _, id := range shared {
			args = append(args, id)
		}
		sql += fmt.Sprintf(
			" AND (visibility = 0 OR creator_id = ? OR id IN (%s))",
			strings.Join(placeholders, ","))
	}
	sql += " GROUP BY category_id"

	var rows []struct {
		CategoryID uint64 `orm:"column(category_id)"`
		Cnt        int64  `orm:"column(cnt)"`
	}
	if _, err := models.Orm.Raw(sql, args...).QueryRows(&rows); err != nil {
		return nil, err
	}
	result := make(map[uint64]int64, len(rows))
	for _, r := range rows {
		result[r.CategoryID] = r.Cnt
	}
	return result, nil
}

// OaDocCategoryCreate 新建分类。
func OaDocCategoryCreate(tid int, parentID uint64, name, remark string, sort int) (*models.OaDocCategory, error) {
	models.EnsureOaDocumentTables()

	name = strings.TrimSpace(name)
	if name == "" {
		return nil, ErrDocCategoryNameEmpty
	}
	if parentID != 0 {
		ok, err := oaDocCategoryExists(tid, parentID)
		if err != nil {
			return nil, err
		}
		if !ok {
			return nil, ErrDocCategoryNotFound
		}
	}

	item := &models.OaDocCategory{
		Tid:       tid,
		ParentID:  parentID,
		Name:      name,
		Remark:    strings.TrimSpace(remark),
		Sort:      sort,
		IsDeleted: 0,
	}
	if _, err := models.Orm.Insert(item); err != nil {
		return nil, err
	}
	return item, nil
}

// OaDocCategoryUpdate 修改分类名称/备注/排序，parentID < 0 表示不调整父级。
func OaDocCategoryUpdate(tid int, id uint64, name, remark string, sort int, parentID int64) (*models.OaDocCategory, error) {
	models.EnsureOaDocumentTables()

	var item models.OaDocCategory
	if err := oaDocCategoryBase(tid).Filter("id", id).One(&item); err != nil {
		return nil, ErrDocCategoryNotFound
	}

	fields := []string{"UpdateTime"}
	if name = strings.TrimSpace(name); name != "" && name != item.Name {
		item.Name = name
		fields = append(fields, "Name")
	}
	if remark = strings.TrimSpace(remark); remark != item.Remark {
		item.Remark = remark
		fields = append(fields, "Remark")
	}
	if sort >= 0 && sort != item.Sort {
		item.Sort = sort
		fields = append(fields, "Sort")
	}
	if parentID >= 0 && uint64(parentID) != item.ParentID {
		newParent := uint64(parentID)
		if newParent == id {
			return nil, ErrDocCategoryCircular
		}
		if newParent != 0 {
			ok, err := oaDocCategoryExists(tid, newParent)
			if err != nil {
				return nil, err
			}
			if !ok {
				return nil, ErrDocCategoryNotFound
			}
			// 禁止挂到自己的子孙节点下，避免形成环
			childIDs, err := OaDocCategoryDescendants(tid, id)
			if err != nil {
				return nil, err
			}
			for _, cid := range childIDs {
				if cid == newParent {
					return nil, ErrDocCategoryCircular
				}
			}
		}
		item.ParentID = newParent
		fields = append(fields, "ParentID")
	}

	if len(fields) == 1 {
		return &item, nil
	}
	now := time.Now()
	item.UpdateTime = &now
	if _, err := models.Orm.Update(&item, fields...); err != nil {
		return nil, err
	}
	return &item, nil
}

// OaDocCategoryDescendants 收集某分类的全部子孙 ID（不含自身）。
func OaDocCategoryDescendants(tid int, rootID uint64) ([]uint64, error) {
	var list []models.OaDocCategory
	if _, err := oaDocCategoryBase(tid).All(&list); err != nil && err != orm.ErrNoRows {
		return nil, err
	}
	children := make(map[uint64][]uint64)
	for _, c := range list {
		children[c.ParentID] = append(children[c.ParentID], c.ID)
	}

	result := make([]uint64, 0, len(list))
	var walk func(id uint64)
	walk = func(id uint64) {
		for _, cid := range children[id] {
			if cid == rootID {
				continue
			}
			result = append(result, cid)
			walk(cid)
		}
	}
	walk(rootID)
	return result, nil
}

// oaDocCategoryIDsWithChildren 返回指定分类及其所有子孙 ID；rootID=0 时返回 nil 表示不限制。
func oaDocCategoryIDsWithChildren(tid int, rootID uint64) ([]uint64, error) {
	if rootID == 0 {
		return nil, nil
	}
	children, err := OaDocCategoryDescendants(tid, rootID)
	if err != nil {
		return nil, err
	}
	return append([]uint64{rootID}, children...), nil
}

// OaDocCategoryDelete 删除分类：存在子分类或文档时拒绝删除。
func OaDocCategoryDelete(tid int, id uint64) error {
	models.EnsureOaDocumentTables()

	var item models.OaDocCategory
	if err := oaDocCategoryBase(tid).Filter("id", id).One(&item); err != nil {
		return ErrDocCategoryNotFound
	}

	childCount, err := oaDocCategoryBase(tid).Filter("parent_id", id).Count()
	if err != nil {
		return err
	}
	if childCount > 0 {
		return ErrDocCategoryHasChild
	}

	docCount, err := oaDocBase(tid).Filter("category_id", id).Count()
	if err != nil {
		return err
	}
	if docCount > 0 {
		return ErrDocCategoryHasDoc
	}

	now := time.Now()
	_, err = oaDocCategoryBase(tid).Filter("id", id).Update(orm.Params{
		"IsDeleted":  1,
		"DeleteTime": now,
		"UpdateTime": now,
	})
	return err
}

func oaDocCategoryExists(tid int, id uint64) (bool, error) {
	n, err := oaDocCategoryBase(tid).Filter("id", id).Count()
	if err != nil {
		return false, err
	}
	return n > 0, nil
}

// ---------------- 文档 ----------------

// oaDocBase 租户内未删除文档的基础查询集
func oaDocBase(tid int) orm.QuerySeter {
	return models.Orm.QueryTable(new(models.OaDoc)).
		Filter("tid", tid).
		Filter("is_deleted", 0)
}

// OaDocListParams 文档列表查询条件。
// Status/DocType/Star 使用 -1 表示"全部"；CategoryID > 0 时包含其全部子孙分类。
// Actor 为访问者上下文，用于租户内用户级可见性过滤（私密文档只对创建者/被共享者可见）。
type OaDocListParams struct {
	Actor        OaDocActor
	Keyword       string
	CategoryID    uint64
	Uncategorized bool // true 时只看未分类（category_id = 0）的文档
	Status        int
	DocType       int
	Tag           string
	Star          int
	Page          int
	PageSize      int
}

// OaDocList 分页查询文档（自动应用可见性过滤）。
func OaDocList(a OaDocActor, p OaDocListParams) ([]models.OaDoc, int64, error) {
	models.EnsureOaDocumentTables()

	qs := oaDocApplyVisible(oaDocBase(a.Tid), a)
	if kw := strings.TrimSpace(p.Keyword); kw != "" {
		cond := orm.NewCondition()
		cond = cond.Or("title__icontains", kw).
			Or("file_name__icontains", kw).
			Or("tags__icontains", kw).
			Or("summary__icontains", kw).
			Or("owner_name__icontains", kw)
		qs = qs.SetCond(qs.GetCond().AndCond(cond))
	}
	if p.Uncategorized {
		qs = qs.Filter("category_id", 0)
	} else if p.CategoryID > 0 {
		ids, err := oaDocCategoryIDsWithChildren(a.Tid, p.CategoryID)
		if err != nil {
			return nil, 0, err
		}
		if len(ids) > 0 {
			qs = qs.Filter("category_id__in", ids)
		}
	}
	if p.Status >= 0 {
		qs = qs.Filter("status", int8(p.Status))
	}
	if p.DocType >= 0 {
		qs = qs.Filter("doc_type", int8(p.DocType))
	}
	if tag := strings.TrimSpace(p.Tag); tag != "" {
		qs = qs.Filter("tags__icontains", tag)
	}
	if p.Star == 1 {
		qs = qs.Filter("is_star", 1)
	}

	total, err := qs.Count()
	if err != nil {
		return nil, 0, err
	}

	page, pageSize := p.Page, p.PageSize
	if page < 1 {
		page = 1
	}
	if pageSize < 1 {
		pageSize = 20
	}

	var list []models.OaDoc
	_, err = qs.OrderBy("-is_star", "-update_time", "-id").
		Limit(pageSize).Offset((page - 1) * pageSize).
		All(&list)
	if err != nil && err != orm.ErrNoRows {
		return nil, 0, err
	}
	if list == nil {
		list = []models.OaDoc{}
	}
	return list, total, nil
}

// OaDocGet 读取文档详情（不累加查看次数）。私密文档对无权限者返回未找到。
func OaDocGet(a OaDocActor, id uint64) (*models.OaDoc, error) {
	models.EnsureOaDocumentTables()

	var item models.OaDoc
	qs := oaDocApplyVisible(oaDocBase(a.Tid).Filter("id", id), a)
	if err := qs.One(&item); err != nil {
		return nil, ErrDocNotFound
	}
	return &item, nil
}

// OaDocView 读取文档详情并累加查看次数。
func OaDocView(a OaDocActor, id uint64) (*models.OaDoc, error) {
	item, err := OaDocGet(a, id)
	if err != nil {
		return nil, err
	}
	_, _ = models.Orm.Raw(
		"UPDATE yz_backend_oa_doc SET view_count = view_count + 1 WHERE id = ?", id).Exec()
	item.ViewCount++
	return item, nil
}

// OaDocDownload 记录一次下载并回传文档（供前端拿到下载地址）。
func OaDocDownload(a OaDocActor, id uint64) (*models.OaDoc, error) {
	item, err := OaDocGet(a, id)
	if err != nil {
		return nil, err
	}
	_, _ = models.Orm.Raw(
		"UPDATE yz_backend_oa_doc SET download_count = download_count + 1 WHERE id = ?", id).Exec()
	item.DownCount++
	return item, nil
}

// OaDocSaveParams 文档新增/编辑入参。
// SetCategory 为 true 时才以 CategoryID 覆盖原值（允许显式改为 0 即"未分类"）。
type OaDocSaveParams struct {
	SetCategory bool
	CategoryID  uint64
	Title      string
	FileID     uint64
	FileURL    string
	FileName   string
	Ext        string
	Size       uint64
	Tags       string
	Summary    string
	Status     int8
	Version    int
	OwnerID    uint64
	OwnerName  string
	IsStar     int8
	Visibility int8 // 0-租户公开 1-私密
}

// OaDocCreate 新增文档。
// 若未传标题则回退为原始文件名（去扩展名）；doc_type 由扩展名推断。
func OaDocCreate(a OaDocActor, operatorName string, p OaDocSaveParams) (*models.OaDoc, error) {
	models.EnsureOaDocumentTables()
	tid := a.Tid

	title := strings.TrimSpace(p.Title)
	if title == "" {
		title = strings.TrimSpace(strings.TrimSuffix(p.FileName, "."+p.Ext))
	}
	if title == "" {
		return nil, ErrDocTitleEmpty
	}
	if p.CategoryID > 0 {
		ok, err := oaDocCategoryExists(tid, p.CategoryID)
		if err != nil {
			return nil, err
		}
		if !ok {
			return nil, ErrDocCategoryInvalid
		}
	}

	ext := strings.ToLower(strings.TrimPrefix(strings.TrimSpace(p.Ext), "."))
	version := p.Version
	if version < 1 {
		version = 1
	}
	if p.Status < 0 || p.Status > 2 {
		p.Status = models.DocStatusDraft
	}
	if p.IsStar != 1 {
		p.IsStar = 0
	}

	item := &models.OaDoc{
		Tid:         tid,
		CategoryID:  p.CategoryID,
		Title:       title,
		FileID:      p.FileID,
		FileURL:     strings.TrimSpace(p.FileURL),
		FileName:    strings.TrimSpace(p.FileName),
		Ext:         ext,
		Size:        p.Size,
		DocType:     models.DocTypeByExt(ext),
		Tags:        strings.TrimSpace(p.Tags),
		Summary:     strings.TrimSpace(p.Summary),
		Status:      p.Status,
		Version:     version,
		IsStar:      p.IsStar,
		OwnerID:     p.OwnerID,
		OwnerName:   strings.TrimSpace(p.OwnerName),
		CreatorID:   a.UID,
		CreatorName: operatorName,
		Visibility:  visibilityOf(p.Visibility),
		IsDeleted:   0,
	}
	if _, err := models.Orm.Insert(item); err != nil {
		return nil, err
	}
	return item, nil
}

// visibilityOf 归一化可见性取值：仅 1 视为私密，其余一律公开。
func visibilityOf(v int8) int8 {
	if v == 1 {
		return 1
	}
	return 0
}

// OaDocUpdate 编辑文档（仅更新传入的字段）。
func OaDocUpdate(a OaDocActor, id uint64, p OaDocSaveParams) (*models.OaDoc, error) {
	models.EnsureOaDocumentTables()

	var item models.OaDoc
	if err := oaDocApplyVisible(oaDocBase(a.Tid).Filter("id", id), a).One(&item); err != nil {
		return nil, ErrDocNotFound
	}
	if !oaDocCanManage(a, &item) {
		return nil, ErrDocNoPermission
	}

	fields := []string{"UpdateTime"}
	if v := visibilityOf(p.Visibility); v != item.Visibility {
		item.Visibility = v
		fields = append(fields, "Visibility")
	}
	if p.SetCategory && p.CategoryID != item.CategoryID {
		if p.CategoryID > 0 {
			ok, err := oaDocCategoryExists(a.Tid, p.CategoryID)
			if err != nil {
				return nil, err
			}
			if !ok {
				return nil, ErrDocCategoryInvalid
			}
		}
		item.CategoryID = p.CategoryID
		fields = append(fields, "CategoryID")
	}
	if title := strings.TrimSpace(p.Title); title != "" && title != item.Title {
		item.Title = title
		fields = append(fields, "Title")
	}
	if url := strings.TrimSpace(p.FileURL); url != "" {
		item.FileURL = url
		fields = append(fields, "FileURL")
		if p.FileID > 0 {
			item.FileID = p.FileID
			fields = append(fields, "FileID")
		}
		if name := strings.TrimSpace(p.FileName); name != "" {
			item.FileName = name
			fields = append(fields, "FileName")
		}
		if ext := strings.ToLower(strings.TrimPrefix(strings.TrimSpace(p.Ext), ".")); ext != "" {
			item.Ext = ext
			item.DocType = models.DocTypeByExt(ext)
			fields = append(fields, "Ext", "DocType")
		}
		if p.Size > 0 {
			item.Size = p.Size
			fields = append(fields, "Size")
		}
	}
	if tags := strings.TrimSpace(p.Tags); tags != item.Tags {
		item.Tags = tags
		fields = append(fields, "Tags")
	}
	if summary := strings.TrimSpace(p.Summary); summary != item.Summary {
		item.Summary = summary
		fields = append(fields, "Summary")
	}
	if p.Status >= 0 && p.Status <= 2 && p.Status != item.Status {
		item.Status = p.Status
		fields = append(fields, "Status")
	}
	if p.Version > 0 && p.Version != item.Version {
		item.Version = p.Version
		fields = append(fields, "Version")
	}
	if p.IsStar == 0 || p.IsStar == 1 {
		if p.IsStar != item.IsStar {
			item.IsStar = p.IsStar
			fields = append(fields, "IsStar")
		}
	}
	if p.OwnerID > 0 {
		item.OwnerID = p.OwnerID
		fields = append(fields, "OwnerID")
	}
	if owner := strings.TrimSpace(p.OwnerName); owner != "" && owner != item.OwnerName {
		item.OwnerName = owner
		fields = append(fields, "OwnerName")
	}

	if len(fields) == 1 {
		return &item, nil
	}
	now := time.Now()
	item.UpdateTime = &now
	if _, err := models.Orm.Update(&item, fields...); err != nil {
		return nil, err
	}
	return &item, nil
}

// OaDocDelete 批量软删除文档，并清理与被删文档相关的关联关系。
// 仅对"可见且可管理"的文档生效；若给定 ID 全部无权操作则返回 ErrDocNoPermission。
func OaDocDelete(a OaDocActor, ids []uint64) (int64, error) {
	models.EnsureOaDocumentTables()

	ids = normalizeIDs(ids)
	if len(ids) == 0 {
		return 0, ErrDocIDEmpty
	}

	var list []models.OaDoc
	if _, err := oaDocApplyVisible(oaDocBase(a.Tid).Filter("id__in", ids), a).All(&list); err != nil && err != orm.ErrNoRows {
		return 0, err
	}
	allowed := make([]uint64, 0, len(list))
	for _, d := range list {
		if oaDocCanManage(a, &d) {
			allowed = append(allowed, d.ID)
		}
	}
	if len(allowed) == 0 {
		return 0, ErrDocNoPermission
	}

	now := time.Now()
	n, err := oaDocBase(a.Tid).Filter("id__in", allowed).Update(orm.Params{
		"IsDeleted":  1,
		"DeleteTime": now,
		"UpdateTime": now,
	})
	if err != nil {
		return 0, err
	}
	// 清理被删文档参与的全部关联关系，避免图谱出现悬挂连线
	// 注意：SetCond 会整体替换查询条件，tid 必须写进 cond，否则会误删其它租户的数据
	cond := orm.NewCondition().
		And("tid", a.Tid).
		AndCond(orm.NewCondition().
			Or("source_id__in", allowed).
			Or("target_id__in", allowed))
	_, _ = models.Orm.QueryTable(new(models.OaDocLink)).SetCond(cond).Delete()

	return n, nil
}

// OaDocMove 批量移动文档到目标分类（0 表示未分类）。仅对可管理文档生效。
func OaDocMove(a OaDocActor, ids []uint64, categoryID uint64) (int64, error) {
	models.EnsureOaDocumentTables()

	ids = normalizeIDs(ids)
	if len(ids) == 0 {
		return 0, ErrDocIDEmpty
	}
	if categoryID > 0 {
		ok, err := oaDocCategoryExists(a.Tid, categoryID)
		if err != nil {
			return 0, err
		}
		if !ok {
			return 0, ErrDocCategoryInvalid
		}
	}

	var list []models.OaDoc
	if _, err := oaDocApplyVisible(oaDocBase(a.Tid).Filter("id__in", ids), a).All(&list); err != nil && err != orm.ErrNoRows {
		return 0, err
	}
	allowed := make([]uint64, 0, len(list))
	for _, d := range list {
		if oaDocCanManage(a, &d) {
			allowed = append(allowed, d.ID)
		}
	}
	if len(allowed) == 0 {
		return 0, ErrDocNoPermission
	}

	now := time.Now()
	return oaDocBase(a.Tid).Filter("id__in", allowed).Update(orm.Params{
		"CategoryID": categoryID,
		"UpdateTime": now,
	})
}

// OaDocToggleStar 收藏 / 取消收藏切换，返回切换后的状态。
func OaDocToggleStar(a OaDocActor, id uint64) (int8, error) {
	models.EnsureOaDocumentTables()

	var item models.OaDoc
	if err := oaDocApplyVisible(oaDocBase(a.Tid).Filter("id", id), a).One(&item); err != nil {
		return 0, ErrDocNotFound
	}
	if item.IsStar == 1 {
		item.IsStar = 0
	} else {
		item.IsStar = 1
	}
	if _, err := models.Orm.Update(&item, "IsStar"); err != nil {
		return 0, err
	}
	return item.IsStar, nil
}

// OaDocStatsResult 文档库概览统计
type OaDocStatsResult struct {
	Total         int64            `json:"total"`
	Published     int64            `json:"published"`
	Draft         int64            `json:"draft"`
	Archived      int64            `json:"archived"`
	Starred       int64            `json:"starred"`
	Uncategorized int64            `json:"uncategorized"`
	LinkCount     int64            `json:"link_count"`
	TypeCounts    []OaDocTypeCount `json:"type_counts"`
	RecentDocs    []models.OaDoc   `json:"recent_docs"`
	HotDocs       []models.OaDoc   `json:"hot_docs"`
}

// OaDocTypeCount 按文档类型统计
type OaDocTypeCount struct {
	DocType int8  `json:"doc_type"`
	Count   int64 `json:"count"`
}

// OaDocStats 文档库概览：总数、状态分布、类型分布、最近更新与热门文档（均受可见性约束）。
func OaDocStats(a OaDocActor) (*OaDocStatsResult, error) {
	models.EnsureOaDocumentTables()

	base := oaDocApplyVisible(oaDocBase(a.Tid), a)
	total, _ := base.Count()
	published, _ := base.Filter("status", models.DocStatusPublish).Count()
	draft, _ := base.Filter("status", models.DocStatusDraft).Count()
	archived, _ := base.Filter("status", models.DocStatusArchive).Count()
	starred, _ := base.Filter("is_star", 1).Count()
	uncategorized, _ := base.Filter("category_id", 0).Count()
	linkCount, _ := models.Orm.QueryTable(new(models.OaDocLink)).Filter("tid", a.Tid).Count()

	var rows []struct {
		DocType int8  `orm:"column(doc_type)"`
		Cnt     int64 `orm:"column(cnt)"`
	}
	_, _ = models.Orm.Raw(
		"SELECT doc_type, COUNT(*) AS cnt FROM yz_backend_oa_doc WHERE tid = ? AND is_deleted = 0 GROUP BY doc_type ORDER BY cnt DESC",
		a.Tid).QueryRows(&rows)
	typeCounts := make([]OaDocTypeCount, 0, len(rows))
	for _, r := range rows {
		typeCounts = append(typeCounts, OaDocTypeCount{DocType: r.DocType, Count: r.Cnt})
	}

	var recent []models.OaDoc
	_, _ = base.OrderBy("-update_time", "-id").Limit(8).All(&recent)
	if recent == nil {
		recent = []models.OaDoc{}
	}
	var hot []models.OaDoc
	_, _ = base.OrderBy("-view_count", "-id").Limit(8).All(&hot)
	if hot == nil {
		hot = []models.OaDoc{}
	}

	return &OaDocStatsResult{
		Total:         total,
		Published:     published,
		Draft:         draft,
		Archived:      archived,
		Starred:       starred,
		Uncategorized: uncategorized,
		LinkCount:     linkCount,
		TypeCounts:    typeCounts,
		RecentDocs:    recent,
		HotDocs:       hot,
	}, nil
}

// ---------------- 文档关联 ----------------

// OaDocLinkItem 关联关系 + 两端文档标题，便于前端直接展示
type OaDocLinkItem struct {
	ID         uint64    `json:"id"`
	Tid        int       `json:"tid"`
	SourceID   uint64    `json:"source_id"`
	TargetID   uint64    `json:"target_id"`
	Relation   string    `json:"relation"`
	RelationCN string    `json:"relation_cn"`
	Remark     string    `json:"remark"`
	CreateTime time.Time `json:"create_time"`

	SourceTitle string `json:"source_title"`
	TargetTitle string `json:"target_title"`
}

// OaDocLinkCreate 建立两个文档之间的关联。
func OaDocLinkCreate(a OaDocActor, creatorID, sourceID, targetID uint64, relation, remark string) (*models.OaDocLink, error) {
	models.EnsureOaDocumentTables()
	tid := a.Tid

	if sourceID == 0 || targetID == 0 {
		return nil, ErrDocNotFound
	}
	if sourceID == targetID {
		return nil, ErrDocLinkSelf
	}
	relation = strings.TrimSpace(relation)
	if relation == "" {
		relation = models.DocRelationRelated
	}

	for _, id := range []uint64{sourceID, targetID} {
		// 关联两端文档必须对当前访问者可见，避免私密文档被越权串接
		if _, err := OaDocGet(a, id); err != nil {
			return nil, ErrDocLinkTargetNotFound
		}
	}

	qs := models.Orm.QueryTable(new(models.OaDocLink)).
		Filter("tid", tid).
		Filter("source_id", sourceID).
		Filter("target_id", targetID).
		Filter("relation", relation)
	if qs.Exist() {
		return nil, ErrDocLinkDuplicate
	}

	item := &models.OaDocLink{
		Tid:       tid,
		SourceID:  sourceID,
		TargetID:  targetID,
		Relation:  relation,
		Remark:    strings.TrimSpace(remark),
		CreatorID: creatorID,
	}
	if _, err := models.Orm.Insert(item); err != nil {
		return nil, err
	}

	// 反向补一条同类关系，使图谱连线无向展示
	reverse := *item
	reverse.ID = 0
	reverse.SourceID, reverse.TargetID = targetID, sourceID
	if _, err := models.Orm.Insert(&reverse); err != nil {
		// 唯一索引冲突说明反向关系已存在，忽略即可
		_ = err
	}
	return item, nil
}

// OaDocLinkDelete 删除关联关系（同时清理反向关系，保证图谱双向一致）。
func OaDocLinkDelete(a OaDocActor, id uint64) error {
	models.EnsureOaDocumentTables()
	tid := a.Tid

	var item models.OaDocLink
	if err := models.Orm.QueryTable(new(models.OaDocLink)).
		Filter("tid", tid).Filter("id", id).One(&item); err != nil {
		return ErrDocLinkNotFound
	}
	// 关联两端文档必须对当前访问者可见，避免私密文档被越权解除关联
	if _, err := OaDocGet(a, item.SourceID); err != nil {
		return ErrDocNoPermission
	}
	if _, err := OaDocGet(a, item.TargetID); err != nil {
		return ErrDocNoPermission
	}

	// SetCond 会整体替换查询条件，tid 必须写进 cond
	forward := orm.NewCondition().
		And("source_id", item.SourceID).
		And("target_id", item.TargetID).
		And("relation", item.Relation)
	backward := orm.NewCondition().
		And("source_id", item.TargetID).
		And("target_id", item.SourceID).
		And("relation", item.Relation)
	cond := orm.NewCondition().
		And("tid", tid).
		AndCond(orm.NewCondition().OrCond(forward).OrCond(backward))
	_, err := models.Orm.QueryTable(new(models.OaDocLink)).SetCond(cond).Delete()
	return err
}

// OaDocLinkList 查询与某文档相关的全部关联（含反向），all 为 true 时返回租户全部关联。
// 仅返回两端文档对当前访问者均可见的关联，避免私密文档被越权探查。
func OaDocLinkList(a OaDocActor, docID uint64, all bool) ([]OaDocLinkItem, error) {
	models.EnsureOaDocumentTables()

	sql := `
SELECT l.id, l.tid, l.source_id, l.target_id, l.relation, l.remark, l.create_time,
       IFNULL(s.title, '') AS source_title, IFNULL(t.title, '') AS target_title
FROM yz_backend_oa_doc_link l
LEFT JOIN yz_backend_oa_doc s ON s.id = l.source_id AND s.is_deleted = 0
LEFT JOIN yz_backend_oa_doc t ON t.id = l.target_id AND t.is_deleted = 0
`
	args := []interface{}{}
	if all {
		sql += "WHERE l.tid = ? ORDER BY l.id DESC LIMIT 500"
		args = append(args, a.Tid)
	} else {
		sql += "WHERE l.tid = ? AND (l.source_id = ? OR l.target_id = ?) ORDER BY l.id DESC LIMIT 200"
		args = append(args, a.Tid, docID, docID)
	}

	var rows []OaDocLinkItem
	if _, err := models.Orm.Raw(sql, args...).QueryRows(&rows); err != nil {
		return nil, err
	}

	// 收集所有涉及的文档 ID，批量判定可见性后过滤
	endpointIDs := make([]uint64, 0, len(rows)*2)
	seen := make(map[uint64]bool, len(rows)*2)
	for _, r := range rows {
		if !seen[r.SourceID] {
			seen[r.SourceID] = true
			endpointIDs = append(endpointIDs, r.SourceID)
		}
		if !seen[r.TargetID] {
			seen[r.TargetID] = true
			endpointIDs = append(endpointIDs, r.TargetID)
		}
	}
	visible := oaDocVisibleIDSet(a, endpointIDs)

	out := make([]OaDocLinkItem, 0, len(rows))
	for _, r := range rows {
		if !visible[r.SourceID] || !visible[r.TargetID] {
			continue
		}
		r.RelationCN = DocRelationLabel(r.Relation)
		out = append(out, r)
	}
	if out == nil {
		out = []OaDocLinkItem{}
	}
	return out, nil
}

// ---------------- 文档共享（私密文档可见性授权） ----------------

// OaDocShareItem 共享目标项（创建/更新入参）。
type OaDocShareItem struct {
	ShareType int8   `json:"share_type"` // 0-用户 1-部门
	TargetID  uint64 `json:"target_id"`
}

// OaDocShareView 共享项视图（含目标名称）。
type OaDocShareView struct {
	ID         uint64 `json:"id"`
	DocID      uint64 `json:"doc_id"`
	ShareType  int8   `json:"share_type"`
	TargetID   uint64 `json:"target_id"`
	TargetName string `json:"target_name"`
}

// OaDocShareList 读取文档的共享清单（仅可见文档）。
func OaDocShareList(a OaDocActor, docID uint64) ([]OaDocShareView, error) {
	if _, err := OaDocGet(a, docID); err != nil {
		return nil, err
	}
	var rows []models.OaDocShare
	if _, err := models.Orm.QueryTable(new(models.OaDocShare)).
		Filter("tid", a.Tid).Filter("doc_id", docID).OrderBy("id").All(&rows); err != nil && err != orm.ErrNoRows {
		return nil, err
	}
	views := make([]OaDocShareView, 0, len(rows))
	for _, r := range rows {
		views = append(views, OaDocShareView{
			ID:         r.ID,
			DocID:      r.DocID,
			ShareType:  r.ShareType,
			TargetID:   r.TargetID,
			TargetName: oaDocShareTargetName(a.Tid, r.ShareType, r.TargetID),
		})
	}
	if views == nil {
		views = []OaDocShareView{}
	}
	return views, nil
}

// oaDocShareTargetName 解析共享目标名称（用户姓名 / 部门名称）。
func oaDocShareTargetName(tid int, shareType int8, targetID uint64) string {
	if targetID == 0 {
		return ""
	}
	if shareType == models.DocShareTypeOrg {
		var org models.BackendOrganization
		if err := models.Orm.QueryTable(new(models.BackendOrganization)).
			Filter("tid", tid).Filter("id", targetID).One(&org); err == nil {
			return org.OrgName
		}
		return ""
	}
	var u models.SystemTenantUser
	if err := models.Orm.QueryTable(new(models.SystemTenantUser)).
		Filter("tid", tid).Filter("uid", targetID).Filter("delete_time__isnull", true).One(&u); err == nil {
		if u.Name != nil {
			return *u.Name
		}
	}
	return ""
}

// OaDocShareSet 全量替换文档的共享授权：仅创建者或全权限用户可设置。
func OaDocShareSet(a OaDocActor, docID uint64, items []OaDocShareItem) ([]OaDocShareView, error) {
	doc, err := OaDocGet(a, docID)
	if err != nil {
		return nil, err
	}
	if !oaDocCanManage(a, doc) {
		return nil, ErrDocNoPermission
	}

	seen := make(map[string]bool, len(items))
	clean := make([]OaDocShareItem, 0, len(items))
	for _, it := range items {
		if it.TargetID == 0 {
			continue
		}
		st := it.ShareType
		if st != models.DocShareTypeUser && st != models.DocShareTypeOrg {
			st = models.DocShareTypeUser
		}
		key := fmt.Sprintf("%d_%d", st, it.TargetID)
		if seen[key] {
			continue
		}
		seen[key] = true
		clean = append(clean, OaDocShareItem{ShareType: st, TargetID: it.TargetID})
	}

	// 全量替换：先清空再写入
	if _, err := models.Orm.QueryTable(new(models.OaDocShare)).
		Filter("tid", a.Tid).Filter("doc_id", docID).Delete(); err != nil {
		return nil, err
	}
	for _, it := range clean {
		rec := models.OaDocShare{
			Tid:       a.Tid,
			DocID:     docID,
			ShareType: it.ShareType,
			TargetID:  it.TargetID,
			CreatorID: a.UID,
		}
		if _, err := models.Orm.Insert(&rec); err != nil {
			return nil, err
		}
	}
	return OaDocShareList(a, docID)
}

// OaDocShareRemove 删除单条共享授权（需对文档可管理）。
func OaDocShareRemove(a OaDocActor, id uint64) error {
	var item models.OaDocShare
	if err := models.Orm.QueryTable(new(models.OaDocShare)).
		Filter("tid", a.Tid).Filter("id", id).One(&item); err != nil {
		return ErrDocLinkNotFound
	}
	doc, err := OaDocGet(a, item.DocID)
	if err != nil {
		return err
	}
	if !oaDocCanManage(a, doc) {
		return ErrDocNoPermission
	}
	_, err = models.Orm.QueryTable(new(models.OaDocShare)).
		Filter("tid", a.Tid).Filter("id", id).Delete()
	return err
}

// OaDocMemberItem 租户用户（供文档共享选人）。
type OaDocMemberItem struct {
	UID     uint64 `json:"uid"`
	Name    string `json:"name"`
	Account string `json:"account"`
	OrgID   uint64 `json:"org_id"`
	OrgName string `json:"org_name"`
}

// OaDocMembers 查询租户内用户（用于私密文档共享选人）。
func OaDocMembers(tid int, keyword string, limit int) ([]OaDocMemberItem, error) {
	models.EnsureOaDocumentTables()
	if limit < 1 || limit > 200 {
		limit = 100
	}
	qs := models.Orm.QueryTable(new(models.SystemTenantUser)).
		Filter("tid", tid).
		Filter("status", 1).
		Filter("delete_time__isnull", true)
	if kw := strings.TrimSpace(keyword); kw != "" {
		cond := orm.NewCondition().
			Or("name__icontains", kw).
			Or("account__icontains", kw)
		qs = qs.SetCond(qs.GetCond().AndCond(cond))
	}
	var users []models.SystemTenantUser
	if _, err := qs.OrderBy("-id").Limit(limit).All(&users); err != nil && err != orm.ErrNoRows {
		return nil, err
	}
	orgIDs := make([]uint64, 0, len(users))
	for _, u := range users {
		if u.OrgID > 0 {
			orgIDs = append(orgIDs, u.OrgID)
		}
	}
	orgName := make(map[uint64]string, len(orgIDs))
	if len(orgIDs) > 0 {
		var orgs []models.BackendOrganization
		if _, err := models.Orm.QueryTable(new(models.BackendOrganization)).
			Filter("tid", tid).Filter("id__in", orgIDs).All(&orgs); err == nil {
			for _, o := range orgs {
				orgName[o.ID] = o.OrgName
			}
		}
	}
	out := make([]OaDocMemberItem, 0, len(users))
	for _, u := range users {
		name := ""
		if u.Name != nil {
			name = *u.Name
		}
		account := ""
		if u.Account != nil {
			account = *u.Account
		}
		out = append(out, OaDocMemberItem{
			UID:     u.Uid,
			Name:    name,
			Account: account,
			OrgID:   u.OrgID,
			OrgName: orgName[u.OrgID],
		})
	}
	if out == nil {
		out = []OaDocMemberItem{}
	}
	return out, nil
}

// ---------------- 文档图谱 ----------------

// OaDocGraphParams 图谱查询条件
type OaDocGraphParams struct {
	Keyword         string
	CategoryID      uint64
	Relation        string
	IncludeCategory bool
	OnlyLinked      bool
	Limit           int
}

// OaDocGraphNode 图谱节点；Category=0 文档，Category=1 分类
type OaDocGraphNode struct {
	ID         string `json:"id"`
	Name       string `json:"name"`
	Category   int    `json:"category"`
	DocID      uint64 `json:"doc_id"`
	CategoryID uint64 `json:"category_id"`
	Ext        string `json:"ext"`
	DocType    int8   `json:"doc_type"`
	Status     int8   `json:"status"`
	Tags       string `json:"tags"`
	OwnerName  string `json:"owner_name"`
	ViewCount  int    `json:"view_count"`
	Degree     int    `json:"degree"`
	Value      int    `json:"value"`
}

// OaDocGraphLink 图谱连线；Kind=doc 为文档关联，Kind=belong 为文档归属分类
type OaDocGraphLink struct {
	Source   string `json:"source"`
	Target   string `json:"target"`
	Relation string `json:"relation"`
	Remark   string `json:"remark"`
	Label    string `json:"label"`
	Kind     string `json:"kind"`
}

// OaDocRelationCount 关系类型分布
type OaDocRelationCount struct {
	Relation string `json:"relation"`
	Label    string `json:"label"`
	Count    int64  `json:"count"`
}

// OaDocGraphStats 图谱概览统计
type OaDocGraphStats struct {
	DocCount       int64               `json:"doc_count"`
	LinkCount      int64               `json:"link_count"`
	CategoryCount  int64               `json:"category_count"`
	IsolatedCount  int64               `json:"isolated_count"`
	AvgDegree      float64             `json:"avg_degree"`
	RelationCounts []OaDocRelationCount `json:"relation_counts"`
	TopNodes       []OaDocGraphNode    `json:"top_nodes"`
}

// OaDocGraphResult 图谱数据
type OaDocGraphResult struct {
	Nodes      []OaDocGraphNode `json:"nodes"`
	Links      []OaDocGraphLink `json:"links"`
	Categories []string         `json:"categories"`
	Stats      OaDocGraphStats  `json:"stats"`
}

// OaDocGraph 构建文档知识图谱。
//
// 节点包含文档与（可选）分类中心；连线包含：
//   - kind=doc    ：文档之间的关联关系（yz_backend_oa_doc_link）
//   - kind=belong ：文档到所属分类的归属关系，使孤立文档也能在图谱中定位
func OaDocGraph(a OaDocActor, p OaDocGraphParams) (*OaDocGraphResult, error) {
	models.EnsureOaDocumentTables()

	limit := p.Limit
	if limit < 1 || limit > 1000 {
		limit = 300
	}

	docs, _, err := OaDocList(a, OaDocListParams{
		Actor:     a,
		Keyword:    p.Keyword,
		CategoryID: p.CategoryID,
		Status:     -1,
		DocType:    -1,
		Star:       -1,
		Page:       1,
		PageSize:   limit,
	})
	if err != nil {
		return nil, err
	}

	docIDs := make([]uint64, 0, len(docs))
	for _, d := range docs {
		docIDs = append(docIDs, d.ID)
	}

	nodes := make([]OaDocGraphNode, 0, len(docs)+8)
	links := make([]OaDocGraphLink, 0, len(docs)*2)
	degree := make(map[string]int)

	for _, d := range docs {
		nodes = append(nodes, OaDocGraphNode{
			ID:         fmt.Sprintf("d%d", d.ID),
			Name:       d.Title,
			Category:   0,
			DocID:      d.ID,
			CategoryID: d.CategoryID,
			Ext:        d.Ext,
			DocType:    d.DocType,
			Status:     d.Status,
			Tags:       d.Tags,
			OwnerName:  d.OwnerName,
			ViewCount:  d.ViewCount,
		})
	}

	// 文档之间的关联连线
	if len(docIDs) > 0 {
		// SetCond 会整体替换查询条件，tid 必须写进 cond
		cond := orm.NewCondition().
			And("tid", a.Tid).
			And("source_id__in", docIDs).
			And("target_id__in", docIDs)
		qs := models.Orm.QueryTable(new(models.OaDocLink)).SetCond(cond)
		if rel := strings.TrimSpace(p.Relation); rel != "" {
			qs = qs.Filter("relation", rel)
		}
		var linkList []models.OaDocLink
		if _, err := qs.OrderBy("id").All(&linkList); err != nil && err != orm.ErrNoRows {
			return nil, err
		}
		for _, l := range linkList {
			// 双向各存一条，按 id 去重避免出现两条重复连线
			if l.SourceID > l.TargetID {
				continue
			}
			links = append(links, OaDocGraphLink{
				Source:   fmt.Sprintf("d%d", l.SourceID),
				Target:   fmt.Sprintf("d%d", l.TargetID),
				Relation: l.Relation,
				Remark:   l.Remark,
				Label:    DocRelationLabel(l.Relation),
				Kind:     "doc",
			})
			degree[fmt.Sprintf("d%d", l.SourceID)]++
			degree[fmt.Sprintf("d%d", l.TargetID)]++
		}
	}

	// 归属分类连线 + 分类中心节点
	categoryCount := int64(0)
	if p.IncludeCategory {
		var cats []models.OaDocCategory
		if _, err := oaDocCategoryBase(a.Tid).OrderBy("sort", "id").All(&cats); err != nil && err != orm.ErrNoRows {
			return nil, err
		}
		categoryCount = int64(len(cats))

		used := make(map[uint64]bool, len(cats))
		for _, d := range docs {
			if d.CategoryID == 0 {
				continue
			}
			used[d.CategoryID] = true
			links = append(links, OaDocGraphLink{
				Source:   fmt.Sprintf("d%d", d.ID),
				Target:   fmt.Sprintf("c%d", d.CategoryID),
				Relation: models.DocRelationBelong,
				Label:    DocRelationLabel(models.DocRelationBelong),
				Kind:     "belong",
			})
			degree[fmt.Sprintf("d%d", d.ID)]++
			degree[fmt.Sprintf("c%d", d.CategoryID)]++
		}
		for _, c := range cats {
			if !used[c.ID] {
				continue
			}
			nodes = append(nodes, OaDocGraphNode{
				ID:         fmt.Sprintf("c%d", c.ID),
				Name:       c.Name,
				Category:   1,
				CategoryID: c.ID,
			})
		}
	}

	// 仅看有关系的文档：剔除孤立节点
	if p.OnlyLinked {
		kept := make([]OaDocGraphNode, 0, len(nodes))
		for _, n := range nodes {
			if degree[n.ID] > 0 {
				kept = append(kept, n)
			}
		}
		nodes = kept
	}

	for i := range nodes {
		nodes[i].Degree = degree[nodes[i].ID]
		nodes[i].Value = degree[nodes[i].ID] + 1
	}

	// 统计
	stats := OaDocGraphStats{
		DocCount:      int64(len(docs)),
		CategoryCount: categoryCount,
	}
	isolated := int64(0)
	for _, n := range nodes {
		if n.Category == 0 && n.Degree == 0 {
			isolated++
		}
	}
	stats.IsolatedCount = isolated
	docLinkCount := int64(0)
	for _, l := range links {
		if l.Kind == "doc" {
			docLinkCount++
		}
	}
	stats.LinkCount = docLinkCount
	if len(docs) > 0 {
		stats.AvgDegree = float64(docLinkCount*2) / float64(len(docs))
	}

	// 关系分布直接由已可见的关联连线统计（每条去重连线计 1，与图谱展示一致）
	relCountMap := make(map[string]int64, 4)
	for _, l := range links {
		if l.Kind != "doc" {
			continue
		}
		relCountMap[l.Relation]++
	}
	stats.RelationCounts = make([]OaDocRelationCount, 0, len(relCountMap))
	for rel, cnt := range relCountMap {
		stats.RelationCounts = append(stats.RelationCounts, OaDocRelationCount{
			Relation: rel,
			Label:    DocRelationLabel(rel),
			Count:    cnt,
		})
	}
	sort.Slice(stats.RelationCounts, func(i, j int) bool {
		return stats.RelationCounts[i].Count > stats.RelationCounts[j].Count
	})

	sorted := make([]OaDocGraphNode, 0, len(nodes))
	for _, n := range nodes {
		if n.Category == 0 {
			sorted = append(sorted, n)
		}
	}
	for i := 0; i < len(sorted); i++ {
		for j := i + 1; j < len(sorted); j++ {
			if sorted[j].Degree > sorted[i].Degree {
				sorted[i], sorted[j] = sorted[j], sorted[i]
			}
		}
	}
	if len(sorted) > 8 {
		sorted = sorted[:8]
	}
	stats.TopNodes = sorted

	return &OaDocGraphResult{
		Nodes:      nodes,
		Links:      links,
		Categories: []string{"文档", "分类"},
		Stats:      stats,
	}, nil
}

// normalizeIDs 过滤无效 ID 并去重
func normalizeIDs(ids []uint64) []uint64 {
	seen := make(map[uint64]bool, len(ids))
	result := make([]uint64, 0, len(ids))
	for _, id := range ids {
		if id > 0 && !seen[id] {
			seen[id] = true
			result = append(result, id)
		}
	}
	return result
}