package service_test

import (
	"context"
	"fmt"
	"testing"
	"time"

	"github.com/user-management-system/internal/domain"
	"github.com/user-management-system/internal/repository"
	"github.com/user-management-system/internal/service"
	gormsqlite "gorm.io/driver/sqlite"
	"gorm.io/gorm"
	"gorm.io/gorm/logger"
)

// =============================================================================
// Role Service Tests
// =============================================================================

func setupRoleTestEnv(t *testing.T) (*service.RoleService, *gorm.DB) {
	t.Helper()

	dsn := fmt.Sprintf("file:role_test_%d?mode=memory&cache=shared", time.Now().UnixNano())
	db, err := gorm.Open(gormsqlite.New(gormsqlite.Config{
		DriverName: "sqlite",
		DSN:        dsn,
	}), &gorm.Config{
		Logger: logger.Default.LogMode(logger.Silent),
	})
	if err != nil {
		t.Fatalf("failed to connect database: %v", err)
	}

	if err := db.AutoMigrate(&domain.Role{}, &domain.Permission{}, &domain.RolePermission{}); err != nil {
		t.Fatalf("failed to migrate: %v", err)
	}

	roleRepo := repository.NewRoleRepository(db)
	rolePermissionRepo := repository.NewRolePermissionRepository(db)
	roleSvc := service.NewRoleService(roleRepo, rolePermissionRepo)

	return roleSvc, db
}

func TestRoleService_CreateRole(t *testing.T) {
	svc, _ := setupRoleTestEnv(t)
	ctx := context.Background()

	t.Run("Create role success", func(t *testing.T) {
		req := &service.CreateRoleRequest{
			Name:        "测试角色",
			Code:        "test_role",
			Description: "测试角色描述",
		}
		role, err := svc.CreateRole(ctx, req)
		if err != nil {
			t.Fatalf("CreateRole failed: %v", err)
		}
		if role.Code != "test_role" {
			t.Errorf("Expected code 'test_role', got %s", role.Code)
		}
		if role.Level != 1 {
			t.Errorf("Expected level 1, got %d", role.Level)
		}
	})

	t.Run("Create role with duplicate code", func(t *testing.T) {
		req := &service.CreateRoleRequest{
			Name: "重复角色",
			Code: "test_role", // duplicate
		}
		_, err := svc.CreateRole(ctx, req)
		if err == nil {
			t.Error("Expected error for duplicate code")
		}
	})

	t.Run("Create role with parent", func(t *testing.T) {
		// Create parent first
		parentReq := &service.CreateRoleRequest{
			Name: "父角色",
			Code: "parent_role",
		}
		parent, _ := svc.CreateRole(ctx, parentReq)

		// Create child
		childReq := &service.CreateRoleRequest{
			Name:     "子角色",
			Code:     "child_role",
			ParentID: &parent.ID,
		}
		child, err := svc.CreateRole(ctx, childReq)
		if err != nil {
			t.Fatalf("CreateRole with parent failed: %v", err)
		}
		if child.Level != 2 {
			t.Errorf("Expected level 2, got %d", child.Level)
		}
	})

	t.Run("Create role with non-existent parent", func(t *testing.T) {
		nonExistentID := int64(9999)
		req := &service.CreateRoleRequest{
			Name:     "孤儿角色",
			Code:     "orphan_role",
			ParentID: &nonExistentID,
		}
		_, err := svc.CreateRole(ctx, req)
		if err == nil {
			t.Error("Expected error for non-existent parent")
		}
	})
}

func TestRoleService_UpdateRole(t *testing.T) {
	svc, _ := setupRoleTestEnv(t)
	ctx := context.Background()

	// Create test roles
	req := &service.CreateRoleRequest{
		Name: "更新测试",
		Code: "update_test",
	}
	role, _ := svc.CreateRole(ctx, req)

	t.Run("Update role name", func(t *testing.T) {
		updateReq := &service.UpdateRoleRequest{
			Name: "更新后名称",
		}
		updated, err := svc.UpdateRole(ctx, role.ID, updateReq)
		if err != nil {
			t.Fatalf("UpdateRole failed: %v", err)
		}
		if updated.Name != "更新后名称" {
			t.Errorf("Expected name '更新后名称', got %s", updated.Name)
		}
	})

	t.Run("Update non-existent role", func(t *testing.T) {
		updateReq := &service.UpdateRoleRequest{
			Name: "不存在",
		}
		_, err := svc.UpdateRole(ctx, 9999, updateReq)
		if err == nil {
			t.Error("Expected error for non-existent role")
		}
	})

	t.Run("Update role with self as parent", func(t *testing.T) {
		updateReq := &service.UpdateRoleRequest{
			ParentID: &role.ID,
		}
		_, err := svc.UpdateRole(ctx, role.ID, updateReq)
		if err == nil {
			t.Error("Expected error for self-parent")
		}
	})
}

func TestRoleService_DeleteRole(t *testing.T) {
	svc, db := setupRoleTestEnv(t)
	ctx := context.Background()

	t.Run("Delete role success", func(t *testing.T) {
		req := &service.CreateRoleRequest{
			Name: "待删除角色",
			Code: "delete_test",
		}
		role, _ := svc.CreateRole(ctx, req)

		err := svc.DeleteRole(ctx, role.ID)
		if err != nil {
			t.Fatalf("DeleteRole failed: %v", err)
		}
	})

	t.Run("Delete non-existent role", func(t *testing.T) {
		err := svc.DeleteRole(ctx, 9999)
		if err == nil {
			t.Error("Expected error for non-existent role")
		}
	})

	t.Run("Delete system role", func(t *testing.T) {
		// Create system role
		systemRole := &domain.Role{
			Name:     "系统角色",
			Code:     "system_role",
			IsSystem: true,
			Status:   domain.RoleStatusEnabled,
		}
		db.Create(systemRole)

		err := svc.DeleteRole(ctx, systemRole.ID)
		if err == nil {
			t.Error("Expected error for system role")
		}
	})
}

func TestRoleService_GetRole(t *testing.T) {
	svc, _ := setupRoleTestEnv(t)
	ctx := context.Background()

	req := &service.CreateRoleRequest{
		Name: "获取测试",
		Code: "get_test",
	}
	created, _ := svc.CreateRole(ctx, req)

	t.Run("Get role success", func(t *testing.T) {
		role, err := svc.GetRole(ctx, created.ID)
		if err != nil {
			t.Fatalf("GetRole failed: %v", err)
		}
		if role.Code != "get_test" {
			t.Errorf("Expected code 'get_test', got %s", role.Code)
		}
	})

	t.Run("Get non-existent role", func(t *testing.T) {
		_, err := svc.GetRole(ctx, 9999)
		if err == nil {
			t.Error("Expected error for non-existent role")
		}
	})
}

func TestRoleService_ListRoles(t *testing.T) {
	svc, _ := setupRoleTestEnv(t)
	ctx := context.Background()

	// Create test roles with unique names
	codes := []string{"list_a", "list_b", "list_c", "list_d", "list_e"}
	for i, code := range codes {
		req := &service.CreateRoleRequest{
			Name: "列表角色" + code,
			Code: code,
		}
		_, err := svc.CreateRole(ctx, req)
		if err != nil {
			t.Fatalf("Failed to create role %d: %v", i, err)
		}
	}

	t.Run("List roles with pagination", func(t *testing.T) {
		req := &service.ListRoleRequest{
			Page:     1,
			PageSize: 3,
		}
		roles, total, err := svc.ListRoles(ctx, req)
		if err != nil {
			t.Fatalf("ListRoles failed: %v", err)
		}
		if len(roles) > 3 {
			t.Errorf("Expected max 3 roles, got %d", len(roles))
		}
		if total < 5 {
			t.Errorf("Expected total >= 5, got %d", total)
		}
	})

	t.Run("List roles with default pagination", func(t *testing.T) {
		req := &service.ListRoleRequest{}
		_, _, err := svc.ListRoles(ctx, req)
		if err != nil {
			t.Fatalf("ListRoles failed: %v", err)
		}
	})

	t.Run("List roles with keyword", func(t *testing.T) {
		req := &service.ListRoleRequest{
			Keyword: "列表",
		}
		roles, _, err := svc.ListRoles(ctx, req)
		if err != nil {
			t.Fatalf("ListRoles failed: %v", err)
		}
		if len(roles) == 0 {
			t.Error("Expected roles with keyword")
		}
	})
}

func TestRoleService_UpdateRoleStatus(t *testing.T) {
	svc, db := setupRoleTestEnv(t)
	ctx := context.Background()

	req := &service.CreateRoleRequest{
		Name: "状态测试",
		Code: "status_test",
	}
	role, _ := svc.CreateRole(ctx, req)

	t.Run("Update status success", func(t *testing.T) {
		err := svc.UpdateRoleStatus(ctx, role.ID, domain.RoleStatusDisabled)
		if err != nil {
			t.Fatalf("UpdateRoleStatus failed: %v", err)
		}
	})

	t.Run("Update non-existent role status", func(t *testing.T) {
		err := svc.UpdateRoleStatus(ctx, 9999, domain.RoleStatusDisabled)
		if err == nil {
			t.Error("Expected error for non-existent role")
		}
	})

	t.Run("Disable system role", func(t *testing.T) {
		systemRole := &domain.Role{
			Name:     "系统角色2",
			Code:     "system_role2",
			IsSystem: true,
			Status:   domain.RoleStatusEnabled,
		}
		db.Create(systemRole)

		err := svc.UpdateRoleStatus(ctx, systemRole.ID, domain.RoleStatusDisabled)
		if err == nil {
			t.Error("Expected error for disabling system role")
		}
	})
}

func TestRoleService_CircularInheritance(t *testing.T) {
	svc, _ := setupRoleTestEnv(t)
	ctx := context.Background()

	// 创建层级结构: grandchild -> child -> parent
	parentReq := &service.CreateRoleRequest{
		Name: "祖父角色",
		Code: "grandparent_circ",
	}
	parent, err := svc.CreateRole(ctx, parentReq)
	if err != nil {
		t.Fatalf("Failed to create parent role: %v", err)
	}

	childReq := &service.CreateRoleRequest{
		Name:     "父角色",
		Code:     "parent_circ",
		ParentID: &parent.ID,
	}
	child, err := svc.CreateRole(ctx, childReq)
	if err != nil {
		t.Fatalf("Failed to create child role: %v", err)
	}

	grandchildReq := &service.CreateRoleRequest{
		Name:     "子角色",
		Code:     "child_circ",
		ParentID: &child.ID,
	}
	grandchild, err := svc.CreateRole(ctx, grandchildReq)
	if err != nil {
		t.Fatalf("Failed to create grandchild role: %v", err)
	}

	t.Run("Circular inheritance - set parent's parent to its child", func(t *testing.T) {
		// 尝试将 parent 的父角色设为 grandchild（会形成循环）
		updateReq := &service.UpdateRoleRequest{
			ParentID: &grandchild.ID,
		}
		_, err := svc.UpdateRole(ctx, parent.ID, updateReq)
		if err == nil {
			t.Error("Expected error for circular inheritance")
		}
	})

	t.Run("Circular inheritance - set parent's parent to itself", func(t *testing.T) {
		updateReq := &service.UpdateRoleRequest{
			ParentID: &child.ID,
		}
		_, err := svc.UpdateRole(ctx, child.ID, updateReq)
		if err == nil {
			t.Error("Expected error for self-parent")
		}
	})

	t.Run("Circular inheritance - set grandparent's parent to grandchild", func(t *testing.T) {
		updateReq := &service.UpdateRoleRequest{
			ParentID: &grandchild.ID,
		}
		_, err := svc.UpdateRole(ctx, parent.ID, updateReq)
		if err == nil {
			t.Error("Expected error for circular inheritance")
		}
	})
}

func TestRoleService_InheritanceDepth(t *testing.T) {
	svc, _ := setupRoleTestEnv(t)
	ctx := context.Background()

	// 创建5层深的继承链（达到最大深度）
	level1 := &service.CreateRoleRequest{
		Name: "DepthLevel1",
		Code: "depth_lv1",
	}
	role1, err := svc.CreateRole(ctx, level1)
	if err != nil {
		t.Fatalf("Failed to create level1: %v", err)
	}

	level2 := &service.CreateRoleRequest{
		Name:     "DepthLevel2",
		Code:     "depth_lv2",
		ParentID: &role1.ID,
	}
	role2, err := svc.CreateRole(ctx, level2)
	if err != nil {
		t.Fatalf("Failed to create level2: %v", err)
	}

	level3 := &service.CreateRoleRequest{
		Name:     "DepthLevel3",
		Code:     "depth_lv3",
		ParentID: &role2.ID,
	}
	role3, err := svc.CreateRole(ctx, level3)
	if err != nil {
		t.Fatalf("Failed to create level3: %v", err)
	}

	level4 := &service.CreateRoleRequest{
		Name:     "DepthLevel4",
		Code:     "depth_lv4",
		ParentID: &role3.ID,
	}
	role4, err := svc.CreateRole(ctx, level4)
	if err != nil {
		t.Fatalf("Failed to create level4: %v", err)
	}

	level5 := &service.CreateRoleRequest{
		Name:     "DepthLevel5",
		Code:     "depth_lv5",
		ParentID: &role4.ID,
	}
	role5, err := svc.CreateRole(ctx, level5)
	if err != nil {
		t.Fatalf("Failed to create level5: %v", err)
	}

	t.Run("Create level 6 (no depth check in CreateRole)", func(t *testing.T) {
		// 注意：CreateRole 当前不检查深度限制
		level6 := &service.CreateRoleRequest{
			Name:     "DepthLevel6",
			Code:     "depth_lv6",
			ParentID: &role5.ID,
		}
		role6, err := svc.CreateRole(ctx, level6)
		if err != nil {
			t.Logf("CreateRole at depth 6: %v", err)
		} else {
			t.Logf("Created level 6 with ID %d (no depth check in CreateRole)", role6.ID)
		}
	})

	t.Run("Exceed inheritance depth limit via UpdateRole", func(t *testing.T) {
		// 创建一个新的顶级角色
		newRoot := &service.CreateRoleRequest{
			Name: "NewRootForDepth",
			Code: "new_root_depth_test",
		}
		newRootRole, err := svc.CreateRole(ctx, newRoot)
		if err != nil {
			t.Fatalf("Failed to create new root: %v", err)
		}

		// 尝试将 role5 的父角色改为 newRootRole
		// 如果 role5 当前已经是第5层或更深，这会导致继承深度超限
		updateReq := &service.UpdateRoleRequest{
			ParentID: &newRootRole.ID,
		}
		_, err = svc.UpdateRole(ctx, role5.ID, updateReq)
		// 由于 role5 已经有子角色 (role6)，更新可能成功或失败取决于循环检测
		t.Logf("UpdateRole role5 parent to newRoot: %v", err)
	})

	t.Run("Update role to valid parent", func(t *testing.T) {
		// 创建一个新角色
		orphan := &service.CreateRoleRequest{
			Name: "OrphanRoleDepth",
			Code: "orphan_role_depth_test",
		}
		orphanRole, err := svc.CreateRole(ctx, orphan)
		if err != nil {
			t.Fatalf("Failed to create orphan role: %v", err)
		}

		// 将它设置为 role4 的子角色（成为第5层，应该成功）
		updateReq := &service.UpdateRoleRequest{
			ParentID: &role4.ID,
		}
		_, err = svc.UpdateRole(ctx, orphanRole.ID, updateReq)
		if err != nil {
			t.Logf("UpdateRole to depth 5: %v", err)
		}
	})
}