package auth

import (
	"context"
	"testing"
	"time"

	"github.com/google/uuid"
	"github.com/stretchr/testify/assert"
	"github.com/stretchr/testify/require"

	domainAuth "base/internal/domain/auth"
)

func TestUserRoleRepository_Create(t *testing.T) {
	db := setupTestDB(t)
	repo := createTestUserRoleRepository(db)
	userRepo := createTestUserRepository(db)
	roleRepo := createTestRoleRepository(db)
	ctx := context.Background()

	t.Run("create user role successfully", func(t *testing.T) {
		user := &domainAuth.User{
			ID:        uuid.New(),
			FirstName: "User",
			LastName:  "Role",
			Email:     "userrole@example.com",
			Status:    domainAuth.UserStatusActive,
			CreatedAt: time.Now(),
			UpdatedAt: time.Now(),
		}
		err := userRepo.Create(ctx, user)
		require.NoError(t, err)

		role := &domainAuth.Role{
			ID:        uuid.New(),
			Name:      "test",
			CreatedAt: time.Now(),
			UpdatedAt: time.Now(),
		}
		err = roleRepo.Create(ctx, role)
		require.NoError(t, err)

		err = repo.Create(ctx, user.ID, role.ID)
		assert.NoError(t, err)

		// Verify user role was created
		exists, err := repo.Exists(ctx, user.ID, role.ID)
		assert.NoError(t, err)
		assert.True(t, exists)
	})
}

func TestUserRoleRepository_FindByUserID(t *testing.T) {
	db := setupTestDB(t)
	repo := createTestUserRoleRepository(db)
	userRepo := createTestUserRepository(db)
	roleRepo := createTestRoleRepository(db)
	ctx := context.Background()

	t.Run("find roles by user id", func(t *testing.T) {
		user := &domainAuth.User{
			ID:        uuid.New(),
			FirstName: "Find",
			LastName:  "User",
			Email:     "find@example.com",
			Status:    domainAuth.UserStatusActive,
			CreatedAt: time.Now(),
			UpdatedAt: time.Now(),
		}
		err := userRepo.Create(ctx, user)
		require.NoError(t, err)

		role1 := &domainAuth.Role{
			ID:        uuid.New(),
			Name:      "role1",
			CreatedAt: time.Now(),
			UpdatedAt: time.Now(),
		}
		err = roleRepo.Create(ctx, role1)
		require.NoError(t, err)

		role2 := &domainAuth.Role{
			ID:        uuid.New(),
			Name:      "role2",
			CreatedAt: time.Now(),
			UpdatedAt: time.Now(),
		}
		err = roleRepo.Create(ctx, role2)
		require.NoError(t, err)

		err = repo.Create(ctx, user.ID, role1.ID)
		require.NoError(t, err)
		err = repo.Create(ctx, user.ID, role2.ID)
		require.NoError(t, err)

		roles, err := repo.FindByUserID(ctx, user.ID)
		assert.NoError(t, err)
		assert.Len(t, roles, 2)
	})
}

func TestUserRoleRepository_FindByRoleID(t *testing.T) {
	db := setupTestDB(t)
	repo := createTestUserRoleRepository(db)
	userRepo := createTestUserRepository(db)
	roleRepo := createTestRoleRepository(db)
	ctx := context.Background()

	t.Run("find users by role id", func(t *testing.T) {
		role := &domainAuth.Role{
			ID:        uuid.New(),
			Name:      "shared",
			CreatedAt: time.Now(),
			UpdatedAt: time.Now(),
		}
		err := roleRepo.Create(ctx, role)
		require.NoError(t, err)

		user1 := &domainAuth.User{
			ID:        uuid.New(),
			FirstName: "User",
			LastName:  "One",
			Email:     "user1@example.com",
			Status:    domainAuth.UserStatusActive,
			CreatedAt: time.Now(),
			UpdatedAt: time.Now(),
		}
		err = userRepo.Create(ctx, user1)
		require.NoError(t, err)

		user2 := &domainAuth.User{
			ID:        uuid.New(),
			FirstName: "User",
			LastName:  "Two",
			Email:     "user2@example.com",
			Status:    domainAuth.UserStatusActive,
			CreatedAt: time.Now(),
			UpdatedAt: time.Now(),
		}
		err = userRepo.Create(ctx, user2)
		require.NoError(t, err)

		err = repo.Create(ctx, user1.ID, role.ID)
		require.NoError(t, err)
		err = repo.Create(ctx, user2.ID, role.ID)
		require.NoError(t, err)

		users, err := repo.FindByRoleID(ctx, role.ID)
		assert.NoError(t, err)
		assert.Len(t, users, 2)
	})
}

func TestUserRoleRepository_Delete(t *testing.T) {
	db := setupTestDB(t)
	repo := createTestUserRoleRepository(db)
	userRepo := createTestUserRepository(db)
	roleRepo := createTestRoleRepository(db)
	ctx := context.Background()

	t.Run("delete user role successfully", func(t *testing.T) {
		user := &domainAuth.User{
			ID:        uuid.New(),
			FirstName: "Delete",
			LastName:  "User",
			Email:     "delete@example.com",
			Status:    domainAuth.UserStatusActive,
			CreatedAt: time.Now(),
			UpdatedAt: time.Now(),
		}
		err := userRepo.Create(ctx, user)
		require.NoError(t, err)

		role := &domainAuth.Role{
			ID:        uuid.New(),
			Name:      "delete",
			CreatedAt: time.Now(),
			UpdatedAt: time.Now(),
		}
		err = roleRepo.Create(ctx, role)
		require.NoError(t, err)

		err = repo.Create(ctx, user.ID, role.ID)
		require.NoError(t, err)

		err = repo.Delete(ctx, user.ID, role.ID)
		assert.NoError(t, err)

		// Verify deletion
		exists, err := repo.Exists(ctx, user.ID, role.ID)
		assert.NoError(t, err)
		assert.False(t, exists)
	})
}

func TestUserRoleRepository_DeleteByUserID(t *testing.T) {
	db := setupTestDB(t)
	repo := createTestUserRoleRepository(db)
	userRepo := createTestUserRepository(db)
	roleRepo := createTestRoleRepository(db)
	ctx := context.Background()

	t.Run("delete all roles for user", func(t *testing.T) {
		user := &domainAuth.User{
			ID:        uuid.New(),
			FirstName: "Delete",
			LastName:  "All",
			Email:     "deleteall@example.com",
			Status:    domainAuth.UserStatusActive,
			CreatedAt: time.Now(),
			UpdatedAt: time.Now(),
		}
		err := userRepo.Create(ctx, user)
		require.NoError(t, err)

		role1 := &domainAuth.Role{
			ID:        uuid.New(),
			Name:      "role1",
			CreatedAt: time.Now(),
			UpdatedAt: time.Now(),
		}
		err = roleRepo.Create(ctx, role1)
		require.NoError(t, err)

		role2 := &domainAuth.Role{
			ID:        uuid.New(),
			Name:      "role2",
			CreatedAt: time.Now(),
			UpdatedAt: time.Now(),
		}
		err = roleRepo.Create(ctx, role2)
		require.NoError(t, err)

		err = repo.Create(ctx, user.ID, role1.ID)
		require.NoError(t, err)
		err = repo.Create(ctx, user.ID, role2.ID)
		require.NoError(t, err)

		err = repo.DeleteByUserID(ctx, user.ID)
		assert.NoError(t, err)

		// Verify all roles deleted
		roles, err := repo.FindByUserID(ctx, user.ID)
		assert.NoError(t, err)
		assert.Len(t, roles, 0)
	})
}

func TestUserRoleRepository_DeleteByRoleID(t *testing.T) {
	db := setupTestDB(t)
	repo := createTestUserRoleRepository(db)
	userRepo := createTestUserRepository(db)
	roleRepo := createTestRoleRepository(db)
	ctx := context.Background()

	t.Run("delete role from all users", func(t *testing.T) {
		role := &domainAuth.Role{
			ID:        uuid.New(),
			Name:      "shared",
			CreatedAt: time.Now(),
			UpdatedAt: time.Now(),
		}
		err := roleRepo.Create(ctx, role)
		require.NoError(t, err)

		user1 := &domainAuth.User{
			ID:        uuid.New(),
			FirstName: "User",
			LastName:  "One",
			Email:     "user1@example.com",
			Status:    domainAuth.UserStatusActive,
			CreatedAt: time.Now(),
			UpdatedAt: time.Now(),
		}
		err = userRepo.Create(ctx, user1)
		require.NoError(t, err)

		user2 := &domainAuth.User{
			ID:        uuid.New(),
			FirstName: "User",
			LastName:  "Two",
			Email:     "user2@example.com",
			Status:    domainAuth.UserStatusActive,
			CreatedAt: time.Now(),
			UpdatedAt: time.Now(),
		}
		err = userRepo.Create(ctx, user2)
		require.NoError(t, err)

		err = repo.Create(ctx, user1.ID, role.ID)
		require.NoError(t, err)
		err = repo.Create(ctx, user2.ID, role.ID)
		require.NoError(t, err)

		err = repo.DeleteByRoleID(ctx, role.ID)
		assert.NoError(t, err)

		// Verify role deleted from all users
		users, err := repo.FindByRoleID(ctx, role.ID)
		assert.NoError(t, err)
		assert.Len(t, users, 0)
	})
}

func TestUserRoleRepository_Exists(t *testing.T) {
	db := setupTestDB(t)
	repo := createTestUserRoleRepository(db)
	userRepo := createTestUserRepository(db)
	roleRepo := createTestRoleRepository(db)
	ctx := context.Background()

	t.Run("exists returns true for existing user role", func(t *testing.T) {
		user := &domainAuth.User{
			ID:        uuid.New(),
			FirstName: "Exists",
			LastName:  "User",
			Email:     "exists@example.com",
			Status:    domainAuth.UserStatusActive,
			CreatedAt: time.Now(),
			UpdatedAt: time.Now(),
		}
		err := userRepo.Create(ctx, user)
		require.NoError(t, err)

		role := &domainAuth.Role{
			ID:        uuid.New(),
			Name:      "exists",
			CreatedAt: time.Now(),
			UpdatedAt: time.Now(),
		}
		err = roleRepo.Create(ctx, role)
		require.NoError(t, err)

		err = repo.Create(ctx, user.ID, role.ID)
		require.NoError(t, err)

		exists, err := repo.Exists(ctx, user.ID, role.ID)
		assert.NoError(t, err)
		assert.True(t, exists)
	})

	t.Run("exists returns false for non-existent user role", func(t *testing.T) {
		user := &domainAuth.User{
			ID:        uuid.New(),
			FirstName: "Not",
			LastName:  "Exists",
			Email:     "notexists@example.com",
			Status:    domainAuth.UserStatusActive,
			CreatedAt: time.Now(),
			UpdatedAt: time.Now(),
		}
		err := userRepo.Create(ctx, user)
		require.NoError(t, err)

		role := &domainAuth.Role{
			ID:        uuid.New(),
			Name:      "notexists",
			CreatedAt: time.Now(),
			UpdatedAt: time.Now(),
		}
		err = roleRepo.Create(ctx, role)
		require.NoError(t, err)

		exists, err := repo.Exists(ctx, user.ID, role.ID)
		assert.NoError(t, err)
		assert.False(t, exists)
	})
}