package services

import (
	"codeword/internal/models"
	"codeword/internal/utils/encrypt"
	"context"
	"go.uber.org/zap"
)

type CodewordRepository interface {
	StoreRecoveryRecord(ctx context.Context, userID string, email string, key []byte) (string, error)
	InsertToQueue(ctx context.Context, userID string, email string, key []byte, id string) error
	Ping(ctx context.Context) error
	GetRecoveryRecord(ctx context.Context, key []byte) (*models.RestoreRequest, error)
}

type UserRepository interface {
	FindByEmail(ctx context.Context, email string) (*models.User, error)
}

type Deps struct {
	Logger             *zap.Logger
	CodewordRepository CodewordRepository
	UserRepository     UserRepository
	EncryptService     *encrypt.Encrypt
}

type RecoveryService struct {
	logger             *zap.Logger
	repositoryCodeword CodewordRepository
	repositoryUser     UserRepository
	encryptService     *encrypt.Encrypt
}

func NewRecoveryService(deps Deps) *RecoveryService {
	return &RecoveryService{
		logger:             deps.Logger,
		repositoryCodeword: deps.CodewordRepository,
		repositoryUser:     deps.UserRepository,
		encryptService:     deps.EncryptService,
	}
}

// GenerateKey генерирует ключ, используя шифрование на основе эллиптической кривой
func (s *RecoveryService) GenerateKey() ([]byte, error) {
	key, err := s.encryptService.SignCommonSecret()
	if err != nil {
		return nil, err
	}
	return key, nil
}

func (s *RecoveryService) Ping(ctx context.Context) error {
	return s.repositoryCodeword.Ping(ctx)
}

// FindUserByEmail ищет пользователя по электронной почте
func (s *RecoveryService) FindUserByEmail(ctx context.Context, email string) (*models.User, error) {
	return s.repositoryUser.FindByEmail(ctx, email)
}

// StoreRecoveryRecord сохраняет запись восстановления в базе данных
func (s *RecoveryService) StoreRecoveryRecord(ctx context.Context, userID string, email string, key []byte) (string, error) {
	id, err := s.repositoryCodeword.StoreRecoveryRecord(ctx, userID, email, key)
	if err != nil {
		return "", err
	}
	return id, nil
}

// SendRecoveryEmail посылает письмо для восстановления доступа пользователю
func (s *RecoveryService) RecoveryEmailTask(ctx context.Context, userID string, email string, key []byte, id string) error {
	return s.repositoryCodeword.InsertToQueue(ctx, userID, email, key, id)
}

// GetRecoveryRecord получает запись восстановления из базы данных
func (s *RecoveryService) GetRecoveryRecord(ctx context.Context, key []byte) (*models.RestoreRequest, error) {
	return s.repositoryCodeword.GetRecoveryRecord(ctx, key)
}

// ExchangeForTokens обменивает ссылку восстановления на токены используя сервис аутентификации.
func (s *RecoveryService) ExchangeForTokens(userID string) (map[string]string, error) {
	// TODO
	return nil, nil
}