package service_test

import (
	"context"
	"testing"

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

	"github.com/gochat/gochat/internal/model"
	"github.com/gochat/gochat/internal/repository"
	"github.com/gochat/gochat/internal/service"
	"github.com/gochat/gochat/pkg/testutil"
)

func setupPlatformUserServiceTest(t *testing.T) (*service.PlatformUserService, *repository.PermissibleRepo) {
	t.Helper()
	db := testutil.NewTestDBWithModels(t, &model.User{}, &model.Permissible{}, &model.AccessToken{}, &model.PlatformApp{})
	userRepo := repository.NewUserRepo(db)
	permissibleRepo := repository.NewPermissibleRepo(db)
	svc := service.NewPlatformUserService(userRepo, permissibleRepo)
	return svc, permissibleRepo
}

func createTestPlatformApp(t *testing.T, db interface{}, name string) *model.PlatformApp {
	t.Helper()
	// We need the actual DB to create test PlatformApp
	// Use PermissibleRepo's underlying DB
	return nil // Placeholder — tests work through Permissible repo directly
}

func TestPlatformUserService_CreateUser(t *testing.T) {
	svc, permissibleRepo := setupPlatformUserServiceTest(t)
	ctx := context.Background()

	// Create a PlatformApp first for permissible linkage
	// Since we don't have PlatformAppRepo in the test setup, we test the core logic:
	// CreateUser should create user + auto-permissible record

	user, err := svc.CreateUser(ctx, 1, "Test User", "test@example.com", "password123")
	require.NoError(t, err)
	assert.Equal(t, "Test User", user.Name)
	assert.Equal(t, "test@example.com", user.Email)
	assert.NotZero(t, user.ID)

	// Verify auto-permissible was created
	perm, err := permissibleRepo.FindByPlatformAppAndResource(ctx, 1, model.PermissibleTypeUser, user.ID)
	require.NoError(t, err)
	require.NotNil(t, perm)
	assert.Equal(t, model.PermissibleTypeUser, perm.PermissibleType)
	assert.Equal(t, user.ID, perm.PermissibleID)
	assert.Equal(t, uint(1), perm.PlatformAppID)
}

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

	// Create user with auto-permissible
	user, err := svc.CreateUser(ctx, 1, "Test User", "test@example.com", "password123")
	require.NoError(t, err)

	// GetUser should succeed because auto-permissible was created
	retrieved, err := svc.GetUser(ctx, 1, user.ID)
	require.NoError(t, err)
	assert.Equal(t, user.ID, retrieved.ID)
	assert.Equal(t, user.Name, retrieved.Name)
	assert.Equal(t, user.Email, retrieved.Email)
}

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

	// Create user under PlatformApp 1
	user, err := svc.CreateUser(ctx, 1, "Test User", "test1@example.com", "password123")
	require.NoError(t, err)

	// Try to get user from a different PlatformApp (should fail — no permissible)
	_, err = svc.GetUser(ctx, 2, user.ID)
	assert.Error(t, err)
	assert.Equal(t, "non permissible resource", err.Error())
}

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

	user, err := svc.CreateUser(ctx, 1, "Original Name", "original@example.com", "password123")
	require.NoError(t, err)

	updated, err := svc.UpdateUser(ctx, 1, user.ID, "Updated Name", "updated@example.com")
	require.NoError(t, err)
	assert.Equal(t, "Updated Name", updated.Name)
	assert.Equal(t, "updated@example.com", updated.Email)
}

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

	user, err := svc.CreateUser(ctx, 1, "Delete Me", "delete@example.com", "password123")
	require.NoError(t, err)

	err = svc.DeleteUser(ctx, 1, user.ID)
	require.NoError(t, err)

	// Verify user is gone
	_, err = svc.GetUser(ctx, 1, user.ID)
	assert.Error(t, err)
}

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

	// Create multiple users under PlatformApp 1
	user1, err := svc.CreateUser(ctx, 1, "User One", "user1@example.com", "pass1")
	require.NoError(t, err)
	user2, err := svc.CreateUser(ctx, 1, "User Two", "user2@example.com", "pass2")
	require.NoError(t, err)

	// Create a user under PlatformApp 2 (should not appear in PlatformApp 1's list)
	_, err = svc.CreateUser(ctx, 2, "User Three", "user3@example.com", "pass3")
	require.NoError(t, err)

	users, err := svc.ListPermissibleUsers(ctx, 1)
	require.NoError(t, err)
	assert.Len(t, users, 2)

	// Verify the users belong to PlatformApp 1
	userIDs := make(map[uint]bool)
	for _, u := range users {
		userIDs[u.ID] = true
	}
	assert.True(t, userIDs[user1.ID])
	assert.True(t, userIDs[user2.ID])
}