package product

import (
	"context"
	"database/sql"
	"testing"
	"time"

	"perms-system-server/internal/svc"
	"perms-system-server/internal/testutil"
	"perms-system-server/internal/testutil/ctxhelper"
	"perms-system-server/internal/types"

	"github.com/stretchr/testify/assert"
	"github.com/stretchr/testify/require"
	"github.com/zeromicro/go-zero/core/stores/redis"
	"github.com/zeromicro/go-zero/core/stores/sqlx"
)

// ---------------------------------------------------------------------------
// 覆盖目标：审计 M-1（第 8 轮）—— CreateProduct 的 DB 事务提交后，ticket 生成 / JSON marshal /
// Redis SetexCtx 任一步骤失败都必须走补偿：把 product / user / product_member 三行一并删除，
// 让副作用回到"从未创建"。如果不补偿，新建的 admin 明文密码只留在本次内存里，一旦响应 500/503，
// 账号就成了永久孤儿，必须手动改库。
//
// 注入手法：测试用例通过一个**无法连通**的 Redis 替换 svcCtx.Redis，让 SetexCtx 必然失败。
//   - CacheRedis 不动，所以 Model 层缓存 / Loader 行为保持正常；
//   - 只替换 svcCtx.Redis 这一个指针，CreateProduct 里就会打到挂线的 Redis，落入 503 分支；
//   - 补偿事务会同步跑一次 DB，验收的点就是 DB 里 **不存在** 任何残留行。
//
// 命名规则：TC-0976 ~ TC-0978
// ---------------------------------------------------------------------------

// newBrokenSvcCtxForM1 返回一个"真实 DB + CacheRedis 正常 + svcCtx.Redis 指向黑洞"的 svcCtx。
// 黑洞 Redis 通过 `127.0.0.1:1` 构造，任何 Setex 都会立刻拿到 connection refused，不会把测试拖很久。
func newBrokenSvcCtxForM1(t *testing.T) *svc.ServiceContext {
	t.Helper()
	cfg := testutil.GetTestConfig()
	svcCtx := svc.NewServiceContext(cfg)
	// 把 svcCtx.Redis 换掉；注意 MustNewRedis 不立即拨号，只有真正调 Setex 才会爆。
	// NonBlock=true 避免构造期强制 ping；PingTimeout 只在 NonBlock=false 时生效，这里保留是为
	// 防御未来默认值漂移。真正的失败发生在运行 SetexCtx 时，连不通 127.0.0.1:1 会立刻返 err。
	broken := redis.MustNewRedis(redis.RedisConf{
		Host:        "127.0.0.1:1",
		Type:        "node",
		NonBlock:    true,
		PingTimeout: 200 * time.Millisecond,
	})
	svcCtx.Redis = broken
	return svcCtx
}

// assertNoOrphanRowsLeft 在补偿完成后，按 (productCode, adminUsername) 反查 DB 是否还有脏行。
// 三张表都必须干净 —— 这是补偿契约的硬不变式。
func assertNoOrphanRowsLeft(t *testing.T, ctx context.Context, conn sqlx.SqlConn, productCode, adminUsername string) {
	t.Helper()

	var productId int64
	err := conn.QueryRowCtx(ctx, &productId, "SELECT `id` FROM `sys_product` WHERE `code` = ? LIMIT 1", productCode)
	assert.ErrorIs(t, err, sql.ErrNoRows,
		"M-1：补偿后 sys_product 不得留下 code=%s 的行", productCode)

	var userId int64
	err = conn.QueryRowCtx(ctx, &userId, "SELECT `id` FROM `sys_user` WHERE `username` = ? LIMIT 1", adminUsername)
	assert.ErrorIs(t, err, sql.ErrNoRows,
		"M-1：补偿后 sys_user 不得留下 username=%s 的行", adminUsername)

	var memberId int64
	err = conn.QueryRowCtx(ctx, &memberId,
		"SELECT `id` FROM `sys_product_member` WHERE `productCode` = ? LIMIT 1", productCode)
	assert.ErrorIs(t, err, sql.ErrNoRows,
		"M-1：补偿后 sys_product_member 不得留下 productCode=%s 的行", productCode)
}

// TC-0976: Redis SetexCtx 失败时走补偿 —— DB 三张表必须回到"从未创建"。
func TestCreateProduct_RedisSetexFail_CompensatesAllRows(t *testing.T) {
	ctx := ctxhelper.SuperAdminCtx()
	svcCtx := newBrokenSvcCtxForM1(t)
	conn := testutil.GetTestSqlConn()

	code := "m1_cpf_" + testutil.UniqueId()
	adminUsername := "admin_" + code

	// 兜底清理，防止断言失败后把孤儿行留下来污染下一次运行。
	t.Cleanup(func() {
		testutil.CleanTableByField(ctx, conn, "`sys_product_member`", "productCode", code)
		testutil.CleanTableByField(ctx, conn, "`sys_user`", "username", adminUsername)
		testutil.CleanTableByField(ctx, conn, "`sys_product`", "code", code)
	})

	// 审计 M-1 补偿路径必须在"入库 → SetexCtx 失败 → 补偿"整条链路生效。L-R10-1 要求传 AdminDeptId：
	// 这里必须用真实 DB（svcCtx.SysDeptModel 走 testutil 底层 conn），所以 seed 一条真实 dept。
	deptId := seedAdminDept(t, ctx, svcCtx)
	logic := NewCreateProductLogic(ctx, svcCtx)
	resp, err := logic.CreateProduct(&types.CreateProductReq{
		Code:        code,
		Name:        "m1压测产品",
		Remark:      "审计M-1补偿验证",
		AdminDeptId: deptId,
	})

	// 审计要求：返回 503 "暂存初始凭证失败，请稍后重试"；响应体不得携带 ticket / adminPassword。
	require.Error(t, err, "M-1：Redis 挂了时必须返回错误而不是静默吞掉")
	require.Nil(t, resp, "M-1：失败路径下不应把半成品 CreateProductResp 塞回给客户端")

	// 核心断言：补偿必须把产品 / admin 用户 / product_member 三行全部抹除。
	assertNoOrphanRowsLeft(t, ctx, conn, code, adminUsername)
}

// TC-0977: 同一 product code 在补偿后可以再次创建成功（幂等性）。
// 没有这条断言的话，"补偿把行删干净"还可能与"索引未释放"组合成 ErrConflict，运维的修复动作会
// 在二次尝试时被"产品编码已存在"挡回，补偿只是半成品。
func TestCreateProduct_RedisSetexFail_AfterCompensation_CanRecreate(t *testing.T) {
	ctx := ctxhelper.SuperAdminCtx()
	brokenCtx := newBrokenSvcCtxForM1(t)
	conn := testutil.GetTestSqlConn()

	code := "m1_recreate_" + testutil.UniqueId()
	adminUsername := "admin_" + code

	t.Cleanup(func() {
		testutil.CleanTableByField(ctx, conn, "`sys_product_member`", "productCode", code)
		testutil.CleanTableByField(ctx, conn, "`sys_user`", "username", adminUsername)
		testutil.CleanTableByField(ctx, conn, "`sys_product`", "code", code)
	})

	// 审计 L-R10-1：两次 CreateProduct 复用同一个有效 dept，seedAdminDept 在 brokenCtx 下创建
	// （brokenCtx 的 Models 共享底层 conn，所以 goodCtx 二次查询也能读到）。
	deptId := seedAdminDept(t, ctx, brokenCtx)
	// 第一次：Redis 坏 → 补偿 → 503
	_, err := NewCreateProductLogic(ctx, brokenCtx).CreateProduct(&types.CreateProductReq{
		Code: code, Name: "first_attempt", Remark: "redis_down", AdminDeptId: deptId,
	})
	require.Error(t, err)
	assertNoOrphanRowsLeft(t, ctx, conn, code, adminUsername)

	// 第二次：Redis 好 → 必须成功；若第一次补偿不彻底会在 FindOneByCode/FindOneByUsername 里被拦。
	goodCtx := svc.NewServiceContext(testutil.GetTestConfig())
	resp2, err := NewCreateProductLogic(ctx, goodCtx).CreateProduct(&types.CreateProductReq{
		Code: code, Name: "second_attempt", Remark: "redis_ok", AdminDeptId: deptId,
	})
	require.NoError(t, err, "M-1：补偿后二次创建必须成功；若失败说明有行没被清干净")
	require.NotNil(t, resp2)
	assert.Equal(t, code, resp2.Code)
	assert.NotEmpty(t, resp2.CredentialsTicket)
}

// TC-0978: 补偿的三张表删除顺序必须是"子 → 父"（product_member → user → product），
// 保证即使外键/缓存/唯一索引尚未释放也不会互相拦截。
//
// 验证手法：在第一次补偿完成后，直接用数据库元数据反查三张表里均无与 productCode 相关的残留；
// 如果删除顺序错误（例如先 product 后 member），product 会被外键/级联规则阻塞，member 行会留下。
//
// 注：sys_product 与 sys_product_member 之间没有强制外键（见 perm.sql 确认），所以 MySQL 不会在
// 引擎层阻止错序 DELETE。但错序在事务里依然会导致：
//   - 如果先删 product 再删 member，member 仍有引用的 productCode 已经没有对应 product，
//     再之后的 "ON DUPLICATE KEY UPDATE" 或外部查询会看到脏引用；
//   - 即便 DB 不拦，测试也要在更高一层用"三张表均为 0 行"来钉死补偿是否真正覆盖 3 行。
func TestCreateProduct_RedisSetexFail_CompensatesInChildFirstOrder(t *testing.T) {
	ctx := ctxhelper.SuperAdminCtx()
	svcCtx := newBrokenSvcCtxForM1(t)
	conn := testutil.GetTestSqlConn()

	code := "m1_order_" + testutil.UniqueId()
	adminUsername := "admin_" + code

	t.Cleanup(func() {
		testutil.CleanTableByField(ctx, conn, "`sys_product_member`", "productCode", code)
		testutil.CleanTableByField(ctx, conn, "`sys_user`", "username", adminUsername)
		testutil.CleanTableByField(ctx, conn, "`sys_product`", "code", code)
	})

	_, err := NewCreateProductLogic(ctx, svcCtx).CreateProduct(&types.CreateProductReq{
		Code: code, Name: "m1 order", Remark: "delete order", AdminDeptId: seedAdminDept(t, ctx, svcCtx),
	})
	require.Error(t, err)

	// 交叉验证：三张表按独立 SELECT COUNT 查询，每张都必须为 0。
	for _, tc := range []struct {
		sql   string
		arg   interface{}
		table string
	}{
		{"SELECT COUNT(*) FROM `sys_product_member` WHERE `productCode` = ?", code, "sys_product_member"},
		{"SELECT COUNT(*) FROM `sys_user` WHERE `username` = ?", adminUsername, "sys_user"},
		{"SELECT COUNT(*) FROM `sys_product` WHERE `code` = ?", code, "sys_product"},
	} {
		var n int64
		require.NoError(t, conn.QueryRowCtx(ctx, &n, tc.sql, tc.arg))
		assert.Equal(t, int64(0), n,
			"M-1：补偿完成后 %s 应 0 行（命名 code=%s / admin=%s）", tc.table, code, adminUsername)
	}
}