package unit

import (
	"errors"
	"time"
	"wish-list-api/pkg/auth"
	"wish-list-api/pkg/entities"

	"github.com/golang-jwt/jwt/v5"
	"go.mongodb.org/mongo-driver/bson/primitive"
)

type MockAuthService struct {
	users map[primitive.ObjectID]*entities.User
	tokens map[string]primitive.ObjectID
}

func NewMockAuthService() auth.Service {
	return &MockAuthService{
		users:  make(map[primitive.ObjectID]*entities.User),
		tokens: make(map[string]primitive.ObjectID),
	}
}

func (m *MockAuthService) AddMockUser(user *entities.User, token string) {
	m.users[user.ID] = user
	m.tokens[token] = user.ID
}

func (m *MockAuthService) Login(credentials *entities.LoginRequest) (*entities.TokenPair, error) {
	for _, user := range m.users {
		if user.Email == credentials.Email && m.ComparePasswords(user.Password, credentials.Password) {
			token := "mock-token-for-" + user.ID.Hex()
			m.tokens[token] = user.ID
			return &entities.TokenPair{
				AccessToken:  token,
				RefreshToken: "refresh-" + token,
			}, nil
		}
	}
	return nil, errors.New("invalid credentials")
}

func (m *MockAuthService) Register(userData *entities.RegisterRequest) (*entities.User, error) {
	for _, existingUser := range m.users {
		if existingUser.Email == userData.Email {
			return nil, errors.New("email already exists")
		}
	}

	hashedPassword, _ := m.HashPassword(userData.Password)
	user := &entities.User{
		ID:        primitive.NewObjectID(),
		Email:     userData.Email,
		Password:  hashedPassword,
		CreatedAt: time.Now(),
		UpdatedAt: time.Now(),
	}

	m.users[user.ID] = user

	return user, nil
}

func (m *MockAuthService) RefreshToken(refreshToken string) (*entities.TokenPair, error) {
	if len(refreshToken) < 8 {
		return nil, errors.New("invalid refresh token")
	}

	accessToken := refreshToken[8:]
	userID, ok := m.tokens[accessToken]
	if !ok {
		return nil, errors.New("invalid refresh token")
	}

	newToken := "mock-token-for-" + userID.Hex() + "-refreshed"
	m.tokens[newToken] = userID

	return &entities.TokenPair{
		AccessToken:  newToken,
		RefreshToken: "refresh-" + newToken,
	}, nil
}

func (m *MockAuthService) ValidateToken(tokenString string) (*jwt.Token, error) {
	if len(tokenString) > 7 && tokenString[:7] == "Bearer " {
		tokenString = tokenString[7:]
	}

	userID, ok := m.tokens[tokenString]
	if !ok {
		return nil, errors.New("invalid token")
	}

	token := jwt.NewWithClaims(jwt.SigningMethodHS256, jwt.MapClaims{
		"user_id": userID.Hex(),
		"exp":     time.Now().Add(time.Hour).Unix(),
	})

	return token, nil
}

func (m *MockAuthService) GetUserIDFromToken(tokenString string) (string, error) {
	if len(tokenString) > 7 && tokenString[:7] == "Bearer " {
		tokenString = tokenString[7:]
	}

	userID, ok := m.tokens[tokenString]
	if !ok {
		return "", errors.New("invalid token")
	}
	return userID.Hex(), nil
}

func (m *MockAuthService) HashPassword(password string) (string, error) {
	return "hashed_" + password, nil
}

func (m *MockAuthService) ComparePasswords(hashedPassword string, plainPassword string) bool {
	return hashedPassword == "hashed_"+plainPassword
}