package service_test

import (
	"context"
	"testing"

	"github.com/stretchr/testify/assert"
	"github.com/stretchr/testify/suite"
	"golang.org/x/crypto/bcrypt"
	"gorm.io/driver/sqlite"
	"gorm.io/gorm"

	"bugulma/backend/internal/domain"
	"bugulma/backend/internal/repository"
	"bugulma/backend/internal/service"
)

type AuthServiceTestSuite struct {
	suite.Suite
	db       *gorm.DB
	userRepo domain.UserRepository
	authSvc  *service.AuthService
}

func (suite *AuthServiceTestSuite) SetupTest() {
	db, err := gorm.Open(sqlite.Open(":memory:"), &gorm.Config{})
	suite.Require().NoError(err)

	// Migrate
	err = db.AutoMigrate(&domain.User{})
	suite.Require().NoError(err)

	suite.db = db
	suite.userRepo = repository.NewUserRepository(db)
	suite.authSvc = service.NewAuthService(suite.userRepo, "test-secret-key")
}

func (suite *AuthServiceTestSuite) TearDownTest() {
	sqlDB, _ := suite.db.DB()
	sqlDB.Close()
}

func (suite *AuthServiceTestSuite) TestLoginSuccess() {
	// Create a test user
	hashedPassword, _ := bcrypt.GenerateFromPassword([]byte("password123"), bcrypt.DefaultCost)
	user := &domain.User{
		ID:       "user-1",
		Email:    "test@example.com",
		Name:     "Test User",
		Password: string(hashedPassword),
		Role:     domain.UserRoleUser,
	}
	err := suite.userRepo.Create(context.Background(), user)
	suite.Require().NoError(err)

	// Test login
	token, returnedUser, err := suite.authSvc.Login(context.Background(), "test@example.com", "password123")
	assert.NoError(suite.T(), err)
	assert.NotEmpty(suite.T(), token)
	assert.Equal(suite.T(), user.ID, returnedUser.ID)
	assert.Equal(suite.T(), user.Email, returnedUser.Email)
}

func (suite *AuthServiceTestSuite) TestLoginInvalidEmail() {
	token, user, err := suite.authSvc.Login(context.Background(), "nonexistent@example.com", "password123")
	assert.Error(suite.T(), err)
	assert.Empty(suite.T(), token)
	assert.Nil(suite.T(), user)
	assert.Equal(suite.T(), "invalid credentials", err.Error())
}

func (suite *AuthServiceTestSuite) TestLoginInvalidPassword() {
	// Create a test user
	hashedPassword, _ := bcrypt.GenerateFromPassword([]byte("password123"), bcrypt.DefaultCost)
	user := &domain.User{
		ID:       "user-1",
		Email:    "test@example.com",
		Name:     "Test User",
		Password: string(hashedPassword),
		Role:     domain.UserRoleUser,
	}
	err := suite.userRepo.Create(context.Background(), user)
	suite.Require().NoError(err)

	// Test login with wrong password
	token, returnedUser, err := suite.authSvc.Login(context.Background(), "test@example.com", "wrongpassword")
	assert.Error(suite.T(), err)
	assert.Empty(suite.T(), token)
	assert.Nil(suite.T(), returnedUser)
	assert.Equal(suite.T(), "invalid credentials", err.Error())
}

func (suite *AuthServiceTestSuite) TestValidateTokenSuccess() {
	// Create a test user
	hashedPassword, _ := bcrypt.GenerateFromPassword([]byte("password123"), bcrypt.DefaultCost)
	user := &domain.User{
		ID:       "user-1",
		Email:    "test@example.com",
		Name:     "Test User",
		Password: string(hashedPassword),
		Role:     domain.UserRoleUser,
	}
	err := suite.userRepo.Create(context.Background(), user)
	suite.Require().NoError(err)

	// Login to get token
	token, _, err := suite.authSvc.Login(context.Background(), "test@example.com", "password123")
	suite.Require().NoError(err)

	// Validate token
	returnedUser, err := suite.authSvc.ValidateToken(context.Background(), token)
	assert.NoError(suite.T(), err)
	assert.Equal(suite.T(), user.ID, returnedUser.ID)
	assert.Equal(suite.T(), user.Email, returnedUser.Email)
}

func (suite *AuthServiceTestSuite) TestValidateTokenInvalid() {
	returnedUser, err := suite.authSvc.ValidateToken(context.Background(), "invalid-token")
	assert.Error(suite.T(), err)
	assert.Nil(suite.T(), returnedUser)
}

func TestAuthServiceTestSuite(t *testing.T) {
	suite.Run(t, new(AuthServiceTestSuite))
}