package repositories

import (
	"testing"

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

	"github.com/treytartt/honeydue-api/internal/models"
	"github.com/treytartt/honeydue-api/internal/testutil"
)

func TestUserRepository_FindByUsername_CaseInsensitive(t *testing.T) {
	db := testutil.SetupTestDB(t)
	repo := NewUserRepository(db)

	testutil.CreateTestUser(t, db, "TestUser", "test@example.com", "Password123")

	// Should find with different cases
	found, err := repo.FindByUsername("testuser")
	require.NoError(t, err)
	assert.Equal(t, "TestUser", found.Username)

	found, err = repo.FindByUsername("TESTUSER")
	require.NoError(t, err)
	assert.Equal(t, "TestUser", found.Username)
}

func TestUserRepository_FindByUsername_NotFound(t *testing.T) {
	db := testutil.SetupTestDB(t)
	repo := NewUserRepository(db)

	_, err := repo.FindByUsername("nonexistent")
	assert.Error(t, err)
	assert.ErrorIs(t, err, ErrUserNotFound)
}

func TestUserRepository_FindByEmail_CaseInsensitive(t *testing.T) {
	db := testutil.SetupTestDB(t)
	repo := NewUserRepository(db)

	testutil.CreateTestUser(t, db, "testuser", "Test@Example.com", "Password123")

	found, err := repo.FindByEmail("test@example.com")
	require.NoError(t, err)
	assert.Equal(t, "Test@Example.com", found.Email)
}

func TestUserRepository_FindByEmail_NotFound(t *testing.T) {
	db := testutil.SetupTestDB(t)
	repo := NewUserRepository(db)

	_, err := repo.FindByEmail("nonexistent@example.com")
	assert.Error(t, err)
	assert.ErrorIs(t, err, ErrUserNotFound)
}

func TestUserRepository_ExistsByUsername_CaseInsensitive(t *testing.T) {
	db := testutil.SetupTestDB(t)
	repo := NewUserRepository(db)

	testutil.CreateTestUser(t, db, "TestUser", "test@example.com", "Password123")

	exists, err := repo.ExistsByUsername("TESTUSER")
	require.NoError(t, err)
	assert.True(t, exists)
}

func TestUserRepository_ExistsByEmail_CaseInsensitive(t *testing.T) {
	db := testutil.SetupTestDB(t)
	repo := NewUserRepository(db)

	testutil.CreateTestUser(t, db, "testuser", "Test@Example.com", "Password123")

	exists, err := repo.ExistsByEmail("test@example.com")
	require.NoError(t, err)
	assert.True(t, exists)
}

func TestUserRepository_FindByKratosID(t *testing.T) {
	db := testutil.SetupTestDB(t)
	repo := NewUserRepository(db)

	user := testutil.CreateTestUser(t, db, "kratosuser", "kratos@example.com", "")

	found, err := repo.FindByKratosID(user.KratosID)
	require.NoError(t, err)
	assert.Equal(t, user.ID, found.ID)
	assert.Equal(t, user.KratosID, found.KratosID)
}

func TestUserRepository_FindByKratosID_NotFound(t *testing.T) {
	db := testutil.SetupTestDB(t)
	repo := NewUserRepository(db)

	_, err := repo.FindByKratosID("nonexistent-kratos-id")
	assert.Error(t, err)
	assert.ErrorIs(t, err, ErrUserNotFound)
}

func TestUserRepository_UpdateLastLogin(t *testing.T) {
	db := testutil.SetupTestDB(t)
	repo := NewUserRepository(db)

	user := testutil.CreateTestUser(t, db, "testuser", "test@example.com", "Password123")

	err := repo.UpdateLastLogin(user.ID)
	require.NoError(t, err)

	found, err := repo.FindByID(user.ID)
	require.NoError(t, err)
	assert.NotNil(t, found.LastLogin)
}

func TestUserRepository_UpdateProfile(t *testing.T) {
	db := testutil.SetupTestDB(t)
	repo := NewUserRepository(db)

	user := testutil.CreateTestUser(t, db, "testuser", "test@example.com", "Password123")

	profile, err := repo.GetOrCreateProfile(user.ID)
	require.NoError(t, err)

	profile.Bio = "Test bio"
	profile.PhoneNumber = "+1-555-0100"
	err = repo.UpdateProfile(profile)
	require.NoError(t, err)

	updated, err := repo.GetOrCreateProfile(user.ID)
	require.NoError(t, err)
	assert.Equal(t, "Test bio", updated.Bio)
	assert.Equal(t, "+1-555-0100", updated.PhoneNumber)
}

func TestUserRepository_SetProfileVerified(t *testing.T) {
	db := testutil.SetupTestDB(t)
	repo := NewUserRepository(db)

	user := testutil.CreateTestUser(t, db, "testuser", "test@example.com", "Password123")

	// Create profile
	_, err := repo.GetOrCreateProfile(user.ID)
	require.NoError(t, err)

	err = repo.SetProfileVerified(user.ID, true)
	require.NoError(t, err)

	profile, err := repo.GetOrCreateProfile(user.ID)
	require.NoError(t, err)
	assert.True(t, profile.Verified)
}

func TestUserRepository_FindByIDWithProfile(t *testing.T) {
	db := testutil.SetupTestDB(t)
	repo := NewUserRepository(db)

	user := testutil.CreateTestUser(t, db, "testuser", "test@example.com", "Password123")

	// Create profile first
	profile := &models.UserProfile{
		UserID: user.ID,
		Bio:    "My bio",
	}
	err := db.Create(profile).Error
	require.NoError(t, err)

	found, err := repo.FindByIDWithProfile(user.ID)
	require.NoError(t, err)
	assert.Equal(t, user.ID, found.ID)
	require.NotNil(t, found.Profile)
	assert.Equal(t, "My bio", found.Profile.Bio)
}

func TestUserRepository_FindByIDWithProfile_NotFound(t *testing.T) {
	db := testutil.SetupTestDB(t)
	repo := NewUserRepository(db)

	_, err := repo.FindByIDWithProfile(9999)
	assert.Error(t, err)
	assert.ErrorIs(t, err, ErrUserNotFound)
}

func TestUserRepository_Transaction(t *testing.T) {
	db := testutil.SetupTestDB(t)
	repo := NewUserRepository(db)

	user := testutil.CreateTestUser(t, db, "testuser", "test@example.com", "Password123")

	err := repo.Transaction(func(txRepo *UserRepository) error {
		found, err := txRepo.FindByID(user.ID)
		if err != nil {
			return err
		}
		found.FirstName = "Updated"
		return txRepo.Update(found)
	})
	require.NoError(t, err)

	found, err := repo.FindByID(user.ID)
	require.NoError(t, err)
	assert.Equal(t, "Updated", found.FirstName)
}

func TestUserRepository_DB(t *testing.T) {
	db := testutil.SetupTestDB(t)
	repo := NewUserRepository(db)

	assert.NotNil(t, repo.DB())
}

func TestUserRepository_SearchUsers(t *testing.T) {
	db := testutil.SetupTestDB(t)
	repo := NewUserRepository(db)

	testutil.CreateTestUser(t, db, "john_doe", "john@example.com", "Password123")
	testutil.CreateTestUser(t, db, "jane_smith", "jane@example.com", "Password123")
	testutil.CreateTestUser(t, db, "bob_builder", "bob@example.com", "Password123")

	users, total, err := repo.SearchUsers("john", 10, 0)
	require.NoError(t, err)
	assert.Equal(t, int64(1), total)
	assert.Len(t, users, 1)
	assert.Equal(t, "john_doe", users[0].Username)
}

func TestUserRepository_ListUsers(t *testing.T) {
	db := testutil.SetupTestDB(t)
	repo := NewUserRepository(db)

	testutil.CreateTestUser(t, db, "user1", "user1@example.com", "Password123")
	testutil.CreateTestUser(t, db, "user2", "user2@example.com", "Password123")
	testutil.CreateTestUser(t, db, "user3", "user3@example.com", "Password123")

	users, total, err := repo.ListUsers(2, 0)
	require.NoError(t, err)
	assert.Equal(t, int64(3), total)
	assert.Len(t, users, 2) // Limited to 2

	users, total, err = repo.ListUsers(2, 2)
	require.NoError(t, err)
	assert.Equal(t, int64(3), total)
	assert.Len(t, users, 1) // Only 1 remaining
}