package user

import (
	"context"
	"testing"
	"time"

	"github.com/youruser/base/internal/svc"
	"github.com/youruser/base/internal/types"
	"github.com/youruser/base/model"

	"github.com/stretchr/testify/assert"
	"github.com/stretchr/testify/require"
)

// Ensure imports are used
var _ = svc.ServiceContext{}
var _ = types.DeleteUserRequest{}

// TestDeleteUser_Success 测试成功删除用户
func TestDeleteUser_Success(t *testing.T) {
	svcCtx, cleanup := setupUserTestDB(t)
	defer cleanup()

	// 创建测试用户
	now := time.Now()
	user := &model.User{
		Username:  "testuser",
		Email:     "test@example.com",
		Password:  "encryptedpassword",
		Phone:     "13800138000",
		Status:    1,
		CreatedAt: now,
		UpdatedAt: now,
	}

	err := svcCtx.DB.Create(user).Error
	require.NoError(t, err)
	userId := user.Id

	// 创建上下文
	ctx := context.Background()

	// 创建 Logic 实例
	logic := NewDeleteUserLogic(ctx, svcCtx)

	// 准备删除请求
	req := &types.DeleteUserRequest{
		Id: userId,
	}

	// 执行测试
	resp, err := logic.DeleteUser(req)

	// 验证结果
	require.NoError(t, err)
	require.NotNil(t, resp)
	assert.Equal(t, 200, resp.Code)
	assert.Equal(t, "删除成功", resp.Message)
	assert.True(t, resp.Success)

	// 验证用户已被删除
	_, err = model.FindOne(context.Background(), svcCtx.DB, userId)
	require.Error(t, err)
	assert.Equal(t, model.ErrNotFound, err)
}

// TestDeleteUser_NotFound 测试删除不存在的用户
func TestDeleteUser_NotFound(t *testing.T) {
	svcCtx, cleanup := setupUserTestDB(t)
	defer cleanup()

	// 创建上下文
	ctx := context.Background()

	// 创建 Logic 实例
	logic := NewDeleteUserLogic(ctx, svcCtx)

	// 使用不存在的用户ID
	req := &types.DeleteUserRequest{
		Id: 99999,
	}

	// 执行测试
	resp, err := logic.DeleteUser(req)

	// 验证结果 - 应该返回响应但用户不存在
	require.NoError(t, err)
	require.NotNil(t, resp)
	assert.Equal(t, 404, resp.Code)
	assert.Equal(t, "用户不存在", resp.Message)
	assert.False(t, resp.Success)
}

// TestDeleteUser_NegativeId 测试使用负数ID删除
func TestDeleteUser_NegativeId(t *testing.T) {
	svcCtx, cleanup := setupUserTestDB(t)
	defer cleanup()

	// 创建上下文
	ctx := context.Background()

	// 创建 Logic 实例
	logic := NewDeleteUserLogic(ctx, svcCtx)

	// 使用负数ID
	req := &types.DeleteUserRequest{
		Id: -1,
	}

	// 执行测试
	resp, err := logic.DeleteUser(req)

	// 验证结果 - 应该返回响应但用户不存在
	require.NoError(t, err)
	require.NotNil(t, resp)
	assert.Equal(t, 404, resp.Code)
	assert.Equal(t, "用户不存在", resp.Message)
}

// TestDeleteUser_ZeroId 测试使用零ID删除
func TestDeleteUser_ZeroId(t *testing.T) {
	svcCtx, cleanup := setupUserTestDB(t)
	defer cleanup()

	// 创建上下文
	ctx := context.Background()

	// 创建 Logic 实例
	logic := NewDeleteUserLogic(ctx, svcCtx)

	// 使用零ID
	req := &types.DeleteUserRequest{
		Id: 0,
	}

	// 执行测试
	resp, err := logic.DeleteUser(req)

	// 验证结果 - 应该返回响应但用户不存在
	require.NoError(t, err)
	require.NotNil(t, resp)
	assert.Equal(t, 404, resp.Code)
	assert.Equal(t, "用户不存在", resp.Message)
}

// TestDeleteUser_ThenRecreate 测试删除后重建用户
func TestDeleteUser_ThenRecreate(t *testing.T) {
	svcCtx, cleanup := setupUserTestDB(t)
	defer cleanup()

	// 创建测试用户
	now := time.Now()
	user := &model.User{
		Username:  "testuser",
		Email:     "test@example.com",
		Password:  "encryptedpassword",
		Phone:     "13800138000",
		Status:    1,
		CreatedAt: now,
		UpdatedAt: now,
	}

	err := svcCtx.DB.Create(user).Error
	require.NoError(t, err)
	oldUserId := user.Id

	// 创建上下文
	ctx := context.Background()

	// 删除用户
	logic1 := NewDeleteUserLogic(ctx, svcCtx)
	req1 := &types.DeleteUserRequest{
		Id: oldUserId,
	}

	_, err = logic1.DeleteUser(req1)
	require.NoError(t, err)

	// 重建用户（使用相同的邮箱）
	createLogic := NewCreateUserLogic(ctx, svcCtx)
	createReq := &types.CreateUserRequest{
		Username: "testuser2",
		Email:    "test@example.com",
		Password: "newpassword",
	}

	newUser, err := createLogic.CreateUser(createReq)

	// 验证结果 - 新用户ID应该不同
	require.NoError(t, err)
	require.NotNil(t, newUser)
	assert.NotEqual(t, oldUserId, newUser.Id)
}

// TestDeleteUser_DeletedTwice 测试重复删除同一个用户
func TestDeleteUser_DeletedTwice(t *testing.T) {
	svcCtx, cleanup := setupUserTestDB(t)
	defer cleanup()

	// 创建测试用户
	now := time.Now()
	user := &model.User{
		Username:  "testuser",
		Email:     "test@example.com",
		Password:  "encryptedpassword",
		Phone:     "13800138000",
		Status:    1,
		CreatedAt: now,
		UpdatedAt: now,
	}

	err := svcCtx.DB.Create(user).Error
	require.NoError(t, err)
	userId := user.Id

	// 创建上下文
	ctx := context.Background()

	// 第一次删除
	logic1 := NewDeleteUserLogic(ctx, svcCtx)
	req := &types.DeleteUserRequest{
		Id: userId,
	}

	resp1, err := logic1.DeleteUser(req)
	require.NoError(t, err)
	assert.Equal(t, 200, resp1.Code)

	// 第二次删除（应该返回404）
	logic2 := NewDeleteUserLogic(ctx, svcCtx)
	resp2, err := logic2.DeleteUser(req)

	// 验证结果
	require.NoError(t, err)
	require.NotNil(t, resp2)
	assert.Equal(t, 404, resp2.Code)
	assert.Equal(t, "用户不存在", resp2.Message)
}

// TestDeleteUser_WithProfile 测试删除带个人资料的用户
func TestDeleteUser_WithProfile(t *testing.T) {
	svcCtx, cleanup := setupUserTestDB(t)
	defer cleanup()

	// 创建测试用户
	now := time.Now()
	user := &model.User{
		Username:  "testuser",
		Email:     "test@example.com",
		Password:  "encryptedpassword",
		Phone:     "13800138000",
		Status:    1,
		CreatedAt: now,
		UpdatedAt: now,
	}

	err := svcCtx.DB.Create(user).Error
	require.NoError(t, err)
	userId := user.Id

	// 创建个人资料
	profile := &model.Profile{
		UserId:    userId,
		Avatar:    "http://example.com/avatar.jpg",
		Bio:       "Test bio",
		CreatedAt: now,
		UpdatedAt: now,
	}

	err = svcCtx.DB.Create(profile).Error
	require.NoError(t, err)

	// 删除用户
	ctx := context.Background()
	logic := NewDeleteUserLogic(ctx, svcCtx)

	req := &types.DeleteUserRequest{
		Id: userId,
	}

	resp, err := logic.DeleteUser(req)

	// 验证结果
	require.NoError(t, err)
	assert.Equal(t, 200, resp.Code)

	// 验证用户和资料都已删除（或用户被删除后，profile变成孤数据）
	_, err = model.FindOne(context.Background(), svcCtx.DB, userId)
	assert.Error(t, err)
	assert.Equal(t, model.ErrNotFound, err)
}

// BenchmarkDeleteUser 性能测试
func BenchmarkDeleteUser(b *testing.B) {
	svcCtx, _ := setupUserTestDB(&testing.T{})
	defer func() {
		sqlDB, _ := svcCtx.DB.DB()
		if sqlDB != nil {
			sqlDB.Close()
		}
	}()

	ctx := context.Background()

	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		// 为每次迭代创建用户
		now := time.Now()
		user := &model.User{
			Username:  "testuser",
			Email:     "test@example.com",
			Password:  "encryptedpassword",
			Phone:     "13800138000",
			Status:    1,
			CreatedAt: now,
			UpdatedAt: now,
		}

		err := svcCtx.DB.Create(user).Error
		if err != nil {
			b.Fatal(err)
		}

		logic := NewDeleteUserLogic(ctx, svcCtx)
		req := &types.DeleteUserRequest{
			Id: user.Id,
		}

		_, _ = logic.DeleteUser(req)
	}
}