package dept

import (
	"context"
	"testing"

	"perms-system-server/internal/consts"
	"perms-system-server/internal/loaders"
	"perms-system-server/internal/middleware"
	deptModel "perms-system-server/internal/model/dept"
	"perms-system-server/internal/testutil/mocks"

	"github.com/stretchr/testify/assert"
	"github.com/stretchr/testify/require"
	"go.uber.org/mock/gomock"
)

// ---------------------------------------------------------------------------
// 覆盖目标：只有 SuperAdmin 才能拿到完整部门树；产品 ADMIN / DEVELOPER / MEMBER 一律
// 按 caller.DeptPath 前缀过滤，仅返回以其为根的子树。避免：
// * MEMBER 级账号枚举全公司组织结构；
// * 定位 DEV 部门再针对性申请权限；
// * 审计 L-R15-2：小产品 ADMIN 借 fullAccess 侦察大产品的 DEV/HR/财务部门命名，
//   为针对性社工 / 撞库提供前置输入——sys_dept 是全局命名空间，ADMIN 在产品 P1
//   的授权范围不应扩散到 P2 的组织结构视图。
//
// 测试数据：一棵 "/100/" 根下挂 "/100/1/"、"/100/1/5/"，以及一个平行分支 "/200/"。
// 期望：caller DeptPath="/100/1/" 只能看到 "/100/1/" 和 "/100/1/5/"；
//       SuperAdmin 看到完整的 `/100/` + `/200/` 两个根。
// ---------------------------------------------------------------------------

var allDepts = []*deptModel.SysDept{
	{Id: 100, ParentId: 0, Path: "/100/", Name: "root"},
	{Id: 1, ParentId: 100, Path: "/100/1/", Name: "childA"},
	{Id: 5, ParentId: 1, Path: "/100/1/5/", Name: "grandchild"},
	{Id: 2, ParentId: 100, Path: "/100/2/", Name: "childB"},
	{Id: 200, ParentId: 0, Path: "/200/", Name: "siblingRoot"},
}

func ctxWith(caller *loaders.UserDetails) context.Context {
	return middleware.WithUserDetails(context.Background(), caller)
}

// TC-0855: MEMBER DeptPath="/100/1/" 应只看到 "/100/1/" 和 "/100/1/5/"，且局部根就是 "/100/1/"。
func TestDeptTree_Member_PrunedToSubtree(t *testing.T) {
	ctrl := gomock.NewController(t)
	t.Cleanup(ctrl.Finish)

	deptMock := mocks.NewMockSysDeptModel(ctrl)
	deptMock.EXPECT().FindAll(gomock.Any()).Return(allDepts, nil)

	svcCtx := mocks.NewMockServiceContext(mocks.MockModels{Dept: deptMock})

	caller := &loaders.UserDetails{
		UserId: 42, IsSuperAdmin: false, MemberType: consts.MemberTypeMember,
		DeptId: 1, DeptPath: "/100/1/", ProductCode: "pA",
	}
	tree, err := NewDeptTreeLogic(ctxWith(caller), svcCtx).DeptTree()
	require.NoError(t, err)

	// 剪枝后只剩 2 个节点；根仍应只有一个（id=1，grandchild 挂在其下）。
	require.Len(t, tree, 1, "剪枝后根只剩 1 个（caller 所在部门）")
	assert.Equal(t, int64(1), tree[0].Id, "局部根必须是 /100/1/，不得把 /100/ 也暴露")
	assert.Equal(t, "/100/1/", tree[0].Path)
	require.Len(t, tree[0].Children, 1, "grandchild 必须挂在局部根下")
	assert.Equal(t, int64(5), tree[0].Children[0].Id)
}

// TC-0856: MEMBER DeptPath="" —— 返回空切片，即使 DB 有数据。
func TestDeptTree_OrphanMember_ReturnsEmpty(t *testing.T) {
	ctrl := gomock.NewController(t)
	t.Cleanup(ctrl.Finish)

	deptMock := mocks.NewMockSysDeptModel(ctrl)
	// 注意：当前实现会先 FindAll 再剪枝，空 DeptPath 直接走空返回，但 FindAll 仍被调用一次（有些成本），
	// 这里设置 AnyTimes 适配 "就算调用一次也可以"。
	deptMock.EXPECT().FindAll(gomock.Any()).Return(allDepts, nil).AnyTimes()

	svcCtx := mocks.NewMockServiceContext(mocks.MockModels{Dept: deptMock})

	caller := &loaders.UserDetails{
		UserId: 43, IsSuperAdmin: false, MemberType: consts.MemberTypeMember,
		DeptId: 0, DeptPath: "", ProductCode: "pA",
	}
	tree, err := NewDeptTreeLogic(ctxWith(caller), svcCtx).DeptTree()
	require.NoError(t, err)
	assert.Len(t, tree, 0, "DeptPath 为空必须返回空树，不能泄露组织结构")
}

// TC-0857（L-R15-2 后契约反转）：产品 ADMIN 不再拥有 fullAccess——只能看到以 DeptPath
// 为根的子树，与 MEMBER / DEVELOPER 同路径。
//
// 关键断言不只是"根只剩 1 个"，还要显式证明 "平行分支 /200/ 对 ADMIN 不可见"，
// 以免未来如果有人把条件从 `caller.IsSuperAdmin` 又放宽回 `|| MemberType == Admin`，
// 本测试能在第一次 run 立刻飘红。
func TestDeptTree_Admin_PrunedToSubtree(t *testing.T) {
	ctrl := gomock.NewController(t)
	t.Cleanup(ctrl.Finish)

	deptMock := mocks.NewMockSysDeptModel(ctrl)
	deptMock.EXPECT().FindAll(gomock.Any()).Return(allDepts, nil)

	svcCtx := mocks.NewMockServiceContext(mocks.MockModels{Dept: deptMock})

	caller := &loaders.UserDetails{
		UserId: 2, IsSuperAdmin: false, MemberType: consts.MemberTypeAdmin,
		DeptId: 1, DeptPath: "/100/1/", ProductCode: "pA",
	}
	tree, err := NewDeptTreeLogic(ctxWith(caller), svcCtx).DeptTree()
	require.NoError(t, err)

	require.Len(t, tree, 1,
		"L-R15-2：产品 ADMIN 不再享有 fullAccess，剪枝后局部根只有 1 个（caller 自己的 DeptPath）")
	assert.Equal(t, int64(1), tree[0].Id,
		"局部根必须是 /100/1/，父部门 /100/ 不应暴露给 ADMIN")
	assert.Equal(t, "/100/1/", tree[0].Path)
	require.Len(t, tree[0].Children, 1, "grandchild /100/1/5/ 必须挂在局部根下")
	assert.Equal(t, int64(5), tree[0].Children[0].Id)

	for _, r := range tree {
		assert.NotEqual(t, int64(200), r.Id,
			"平行分支 /200/ 对产品 ADMIN 必须不可见——若回归到旧 fullAccess，这里立刻飘红")
		assert.NotEqual(t, int64(100), r.Id,
			"父部门 /100/ 也不应暴露给 ADMIN（同上）")
	}
}

// TC-1128：SuperAdmin 仍然享有 fullAccess，完整树返回两个根（/100/ + /200/）。
// 这一条是 L-R15-2 收敛范围的正向回归：确认 `fullAccess = caller.IsSuperAdmin`
// 的 true 分支未被连带削弱（否则超管运营视角会瘫痪）。
func TestDeptTree_SuperAdmin_FullTree(t *testing.T) {
	ctrl := gomock.NewController(t)
	t.Cleanup(ctrl.Finish)

	deptMock := mocks.NewMockSysDeptModel(ctrl)
	deptMock.EXPECT().FindAll(gomock.Any()).Return(allDepts, nil)

	svcCtx := mocks.NewMockServiceContext(mocks.MockModels{Dept: deptMock})

	// 即便 DeptPath 指定成某具体子部门，SuperAdmin 也必须拿到全局树——
	// fullAccess 判定是 IsSuperAdmin 而不是 DeptPath。
	caller := &loaders.UserDetails{
		UserId: 1, IsSuperAdmin: true, MemberType: consts.MemberTypeAdmin,
		DeptId: 100, DeptPath: "/100/", ProductCode: "pA",
	}
	tree, err := NewDeptTreeLogic(ctxWith(caller), svcCtx).DeptTree()
	require.NoError(t, err)

	require.Len(t, tree, 2, "SuperAdmin 必须看到完整树，包含所有平行根")
	var rootIds []int64
	for _, r := range tree {
		rootIds = append(rootIds, r.Id)
	}
	assert.ElementsMatch(t, []int64{100, 200}, rootIds,
		"SuperAdmin 走 fullAccess 分支，平行根 /100/ 与 /200/ 必须同时出现")
}

// TC-1129：产品 DEVELOPER 与 MEMBER 同路径——只能看自己 DeptPath 的子树。
// 这一条补齐 L-R15-2 的"角色对称"覆盖：fullAccess 判定只认 SuperAdmin，
// ADMIN / DEVELOPER / MEMBER 三者剪枝语义必须完全一致。
func TestDeptTree_Developer_PrunedToSubtree(t *testing.T) {
	ctrl := gomock.NewController(t)
	t.Cleanup(ctrl.Finish)

	deptMock := mocks.NewMockSysDeptModel(ctrl)
	deptMock.EXPECT().FindAll(gomock.Any()).Return(allDepts, nil)

	svcCtx := mocks.NewMockServiceContext(mocks.MockModels{Dept: deptMock})

	caller := &loaders.UserDetails{
		UserId: 3, IsSuperAdmin: false, MemberType: consts.MemberTypeDeveloper,
		DeptId: 1, DeptPath: "/100/1/", ProductCode: "pA",
	}
	tree, err := NewDeptTreeLogic(ctxWith(caller), svcCtx).DeptTree()
	require.NoError(t, err)

	require.Len(t, tree, 1, "DEVELOPER 同样不享有 fullAccess，只能看到自己子树")
	assert.Equal(t, int64(1), tree[0].Id, "局部根必须是 /100/1/")
	for _, r := range tree {
		assert.NotEqual(t, int64(200), r.Id,
			"平行分支 /200/ 对 DEVELOPER 同样不可见")
	}
}