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.Account{}, &model.AccountUser{}, &model.Permissible{}, &model.AccessToken{}, &model.PlatformApp{})
	userRepo := repository.NewUserRepo(db)
	permissibleRepo := repository.NewPermissibleRepo(db)
	accessTokenRepo := repository.NewAccessTokenRepo(db)
	accountUserRepo := repository.NewAccountUserRepo(db)
	svc := service.NewPlatformUserService(userRepo, permissibleRepo, accessTokenRepo, accountUserRepo)
	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, service.PlatformUserRequest{Name: "Test User", Email: "test@example.com", Password: "password123"})
	require.NoError(t, err)
	assert.Equal(t, "Test User", user.User.Name)
	assert.Equal(t, "test@example.com", user.User.Email)
	assert.NotZero(t, user.User.ID)
	assert.NotEmpty(t, user.AccessToken)

	// Verify auto-permissible was created
	perm, err := permissibleRepo.FindByPlatformAppAndResource(ctx, 1, model.PermissibleTypeUser, user.User.ID)
	require.NoError(t, err)
	require.NotNil(t, perm)
	assert.Equal(t, model.PermissibleTypeUser, perm.PermissibleType)
	assert.Equal(t, user.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, service.PlatformUserRequest{Name: "Test User", Email: "test@example.com", Password: "password123"})
	require.NoError(t, err)

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

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

	first, err := svc.CreateUser(ctx, 1, service.PlatformUserRequest{Name: "Original", Email: "same@example.com", Password: "password123"})
	require.NoError(t, err)
	second, err := svc.CreateUser(ctx, 1, service.PlatformUserRequest{Name: "Changed", Email: "same@example.com", Password: "password456"})
	require.NoError(t, err)

	assert.Equal(t, first.User.ID, second.User.ID)
	assert.Equal(t, "Original", second.User.Name)
	_, err = permissibleRepo.FindByPlatformAppAndResource(ctx, 1, model.PermissibleTypeUser, second.User.ID)
	assert.NoError(t, err)
}

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

	// Create user under PlatformApp 1
	user, err := svc.CreateUser(ctx, 1, service.PlatformUserRequest{Name: "Test User", Email: "test1@example.com", Password: "password123"})
	require.NoError(t, err)

	// Try to get user from a different PlatformApp (should fail — no permissible)
	_, err = svc.GetUser(ctx, 2, user.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, service.PlatformUserRequest{Name: "Original Name", Email: "original@example.com", Password: "password123", CustomAttributes: map[string]any{"plan": "old"}})
	require.NoError(t, err)

	updated, err := svc.UpdateUser(ctx, 1, user.User.ID, service.PlatformUserRequest{Name: "Updated Name", Email: "updated@example.com", CustomAttributes: map[string]any{"tier": "gold"}})
	require.NoError(t, err)
	assert.Equal(t, "Updated Name", updated.User.Name)
	assert.Equal(t, "updated@example.com", updated.User.Email)
	assert.Contains(t, string(updated.User.CustomAttributes), "gold")
	assert.Contains(t, string(updated.User.CustomAttributes), "old")
}

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

	user, err := svc.CreateUser(ctx, 1, service.PlatformUserRequest{Name: "Delete Me", Email: "delete@example.com", Password: "password123"})
	require.NoError(t, err)

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

	// Verify user is gone
	_, err = svc.GetUser(ctx, 1, user.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, service.PlatformUserRequest{Name: "User One", Email: "user1@example.com", Password: "pass1"})
	require.NoError(t, err)
	user2, err := svc.CreateUser(ctx, 1, service.PlatformUserRequest{Name: "User Two", Email: "user2@example.com", Password: "pass2"})
	require.NoError(t, err)

	// Create a user under PlatformApp 2 (should not appear in PlatformApp 1's list)
	_, err = svc.CreateUser(ctx, 2, service.PlatformUserRequest{Name: "User Three", Email: "user3@example.com", Password: "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.User.ID])
	assert.True(t, userIDs[user2.User.ID])
}