package main

import (
	"errors"
	"fmt"
	"gitea.pena/PenaSide/codeword/internal/initialize"
	"gitea.pena/PenaSide/codeword/internal/utils/encrypt"
	"gitea.pena/PenaSide/common/validate"
	"github.com/caarlos0/env/v8"
	"log"
)

func main() {
	config, err := loadConfig()
	if err != nil {
		log.Fatalf("error loading config: %v", err)
	}

	urls := []string{
		config.AuthMicroserviceURL,
		config.DiscountMicroserviceGRPC,
		config.TrashLogHost,
		config.ExternalCfg.MailClientCfg.ApiURL,
		config.DefaultRedirectionURL,
		config.MailRecoveryURL,
	}
	if err = validateURLs(urls); err != nil {
		log.Fatalf("error validating urls: %v", err)
	}

	if err = validateEncrypt(config); err != nil {
		log.Fatalf("error validating encrypt: %v", err)
	}

	if err = validate.ValidateRedis(config.RedisHost, config.RedisPassword, config.RedisDB); err != nil {
		log.Fatalf("error validating redis: %v", err)
	}

	if err = validate.ValidateKafka(config.KafkaBrokers, config.KafkaTopicTariff); err != nil {
		log.Fatalf("error validating kafka: %v", err)
	}

	if err = validate.ValidateSmtp(config.ExternalCfg.MailClientCfg.ApiKey); err != nil {
		log.Fatalf("error validating smtp: %v", err)
	}

	if err = validate.ValidateMongo(config.ExternalCfg.Database); err != nil {
		log.Fatalf("error validating mongodb: %v", err)
	}

}

func loadConfig() (*initialize.Config, error) {
	var config initialize.Config

	if err := env.Parse(&config); err != nil {
		return nil, err
	}

	return &config, nil
}

func validateURLs(urls []string) error {
	for index, u := range urls {
		if u == "" {
			return fmt.Errorf("empty url, index: %d", index)
		}
		// todo check the liveness of these URLs, many services do not support
	}
	return nil
}

func validateEncrypt(cfg *initialize.Config) error {
	if cfg.EncryptPrivateKey == "" {
		return errors.New("encrypt private key dont be empty")
	}

	if cfg.EncryptPublicKey == "" {
		return errors.New("encrypt public key dont be empty")
	}

	if cfg.EncryptSignSecret == "" {
		return errors.New("encrypt sign secret dont be empty")
	}

	encryptUtil := encrypt.New(&encrypt.EncryptDeps{
		PrivateKey: cfg.EncryptPrivateKey,
		PublicKey:  cfg.EncryptPublicKey,
		SignSecret: cfg.EncryptSignSecret,
	})

	sign, err := encryptUtil.SignCommonSecret()
	if err != nil {
		return err
	}

	ok, err := encryptUtil.VerifySignature(sign)
	if err != nil {
		return err
	}

	if !ok {
		return errors.New("failed verify signature, invalid keys")
	}

	return nil
}