package repository

import (
	"context"
	"testing"

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

	"github.com/gochat/gochat/internal/model"
)

func createTestPushToken(t *testing.T, db *gorm.DB, userID uint, token string, platform string, deviceID string) *model.PushToken {
	t.Helper()
	pt := &model.PushToken{
		UserID:   userID,
		Token:    token,
		Platform: platform,
		DeviceID: deviceID,
	}
	require.NoError(t, db.Create(pt).Error)
	return pt
}

func TestPushTokenRepo_FindByID(t *testing.T) {
	db := setupTestDB(t, &model.PushToken{})
	repo := NewPushTokenRepo(db)

	user := &model.User{Email: "ptfind@example.com", Name: "PTFindUser", Provider: "email"}
	require.NoError(t, db.Create(user).Error)

	pt := createTestPushToken(t, db, user.ID, "token-find-123", "web", "device-1")

	found, err := repo.FindByID(context.Background(), pt.ID)
	assert.NoError(t, err)
	assert.Equal(t, pt.ID, found.ID)
	assert.Equal(t, "token-find-123", found.Token)
	assert.Equal(t, "web", found.Platform)
}

func TestPushTokenRepo_FindByID_NotFound(t *testing.T) {
	db := setupTestDB(t, &model.PushToken{})
	repo := NewPushTokenRepo(db)

	found, err := repo.FindByID(context.Background(), 9999)
	assert.Error(t, err)
	assert.Nil(t, found)
}

func TestPushTokenRepo_ListByUser(t *testing.T) {
	db := setupTestDB(t, &model.PushToken{})
	repo := NewPushTokenRepo(db)

	user := &model.User{Email: "ptlist@example.com", Name: "PTListUser", Provider: "email"}
	require.NoError(t, db.Create(user).Error)

	otherUser := &model.User{Email: "ptother@example.com", Name: "PTOtherUser", Provider: "email"}
	require.NoError(t, db.Create(otherUser).Error)

	createTestPushToken(t, db, user.ID, "token-list-1", "web", "device-1")
	createTestPushToken(t, db, user.ID, "token-list-2", "ios", "device-2")
	createTestPushToken(t, db, otherUser.ID, "token-other-1", "android", "device-3")

	tokens, err := repo.ListByUser(context.Background(), user.ID)
	assert.NoError(t, err)
	assert.Len(t, tokens, 2)
	for _, tk := range tokens {
		assert.Equal(t, user.ID, tk.UserID)
	}
}

func TestPushTokenRepo_Create(t *testing.T) {
	db := setupTestDB(t, &model.PushToken{})
	repo := NewPushTokenRepo(db)

	user := &model.User{Email: "ptcreate@example.com", Name: "PTCreateUser", Provider: "email"}
	require.NoError(t, db.Create(user).Error)

	pt := &model.PushToken{
		UserID:   user.ID,
		Token:    "token-create-abc",
		Platform: "android",
		DeviceID: "device-create-1",
	}

	err := repo.Create(context.Background(), pt)
	assert.NoError(t, err)
	assert.NotZero(t, pt.ID)

	found, err := repo.FindByID(context.Background(), pt.ID)
	assert.NoError(t, err)
	assert.Equal(t, "token-create-abc", found.Token)
	assert.Equal(t, "android", found.Platform)
}

func TestPushTokenRepo_Delete(t *testing.T) {
	db := setupTestDB(t, &model.PushToken{})
	repo := NewPushTokenRepo(db)

	user := &model.User{Email: "ptdelete@example.com", Name: "PTDeleteUser", Provider: "email"}
	require.NoError(t, db.Create(user).Error)

	pt := createTestPushToken(t, db, user.ID, "token-delete-xyz", "ios", "device-del-1")

	err := repo.Delete(context.Background(), pt.ID)
	assert.NoError(t, err)

	found, err := repo.FindByID(context.Background(), pt.ID)
	assert.Error(t, err)
	assert.Nil(t, found)
}

func TestPushTokenRepo_DeleteByTokenAndUser(t *testing.T) {
	db := setupTestDB(t, &model.PushToken{})
	repo := NewPushTokenRepo(db)

	user := &model.User{Email: "ptdelby@example.com", Name: "PTDelByUser", Provider: "email"}
	require.NoError(t, db.Create(user).Error)

	pt := createTestPushToken(t, db, user.ID, "token-delcombo-1", "web", "device-dc-1")
	createTestPushToken(t, db, user.ID, "token-delcombo-2", "ios", "device-dc-2")

	err := repo.DeleteByTokenAndUser(context.Background(), "token-delcombo-1", user.ID)
	assert.NoError(t, err)

	// The targeted token should be gone
	found, err := repo.FindByID(context.Background(), pt.ID)
	assert.Error(t, err)
	assert.Nil(t, found)

	// Other tokens for the same user should still exist
	tokens, err := repo.ListByUser(context.Background(), user.ID)
	assert.NoError(t, err)
	assert.Len(t, tokens, 1)
	assert.Equal(t, "token-delcombo-2", tokens[0].Token)
}