package main

import (
	"bytes"
	"context"
	"fmt"
	"gitea.pena/PenaSide/common/mongo"
	"gitea.pena/PenaSide/common/validate"
	"gitea.pena/PenaSide/heruvym/internal/initialize"
	minioDal "gitea.pena/PenaSide/heruvym/internal/repository/minio"
	"github.com/minio/minio-go/v7"
	"github.com/pioz/faker"
	"log"
	"os"
	"strconv"
	"strings"
)

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

	if cfg.ClientHttpUrl == "" {
		log.Fatalf("error client http url is empty")
	}

	if cfg.AdminHttpUrl == "" {
		log.Fatalf("error admin http url is empty")
	}

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

	err = validate.ValidateTgToken(cfg.TelegramToken)
	if err != nil {
		log.Fatalf("error validating telegram token: %v", err)
	}

	if cfg.TelegramChannelID == 0 {
		log.Fatalf("telegram channel id must be set")
	}

	err = validateRedis(cfg)
	if err != nil {
		log.Fatalf("error validating redis: %v", err)
	}

	err = validateS3(cfg)
	if err != nil {
		log.Fatalf("error validating s3: %v", err)
	}
}

func loadConfig() (initialize.Config, error) {
	config := initialize.Config{
		ExternalCfg: initialize.ExternalCfg{
			Database: mongo.Configuration{
				URL:          os.Getenv("MONGO_URL"),
				DatabaseName: os.Getenv("MONGO_DB_NAME"),
			},
		},
		IsProd:            envToBool(os.Getenv("IS_PROD")),
		S3Endpoint:        os.Getenv("S3_ENDPOINT"),
		S3AccessKey:       os.Getenv("S3_ACCESS_KEY"),
		S3SecretKey:       os.Getenv("S3_SECRET_KEY"),
		S3Token:           os.Getenv("S3_TOKEN"),
		TelegramToken:     os.Getenv("TELEGRAM_TOKEN"),
		RedisHost:         os.Getenv("REDIS_HOST"),
		RedisPassword:     os.Getenv("REDIS_PASSWORD"),
		RedisDB:           int(envToInt64(os.Getenv("REDIS_DB"))),
		TelegramChannelID: envToInt64(os.Getenv("TELEGRAM_CHANNEL_ID")),
		ClientHttpUrl:     os.Getenv("CLIENT_HTTP_URL"),
		AdminHttpUrl:      os.Getenv("ADMIN_HTTP_URL"),
	}

	return config, nil
}

func envToInt64(str string) int64 {
	n, err := strconv.ParseInt(str, 10, 64)
	if err != nil {
		panic(err)
	}
	return n
}

func envToBool(str string) bool {
	switch strings.ToLower(strings.TrimSpace(str)) {
	case "1", "true":
		return true
	case "0", "false":
		return false
	default:
		panic(fmt.Sprintf("invalid boolean value: %s", str))
	}
}

func validateRedis(cfg initialize.Config) error {
	if cfg.RedisHost == "" {
		return fmt.Errorf("redis host is empty")
	}

	_, err := initialize.Redis(context.TODO(), cfg)
	if err != nil {
		return err
	}
	return nil
}

func validateS3(cfg initialize.Config) error {
	if cfg.S3Endpoint == "" {
		return fmt.Errorf("s3 endpoint is empty")
	}
	if cfg.S3AccessKey == "" {
		return fmt.Errorf("s3 access key is empty")
	}
	if cfg.S3SecretKey == "" {
		return fmt.Errorf("s3 secret key is empty")
	}

	ctx := context.TODO()

	client, err := initialize.Minio(cfg)
	if err != nil {
		return fmt.Errorf("error connect s3 in validate: %w", err)
	}

	objectName := faker.String()
	content := []byte(faker.String())
	contentType := "text/plain"

	exist, err := client.BucketExists(ctx, minioDal.Bucket)
	if err != nil {
		return fmt.Errorf("error find s3 bucket in validate: %w", err)
	}

	// не создаем бакет так как бакет могут не дать создать
	if !exist {
		return fmt.Errorf("bucket does not exist")
	}

	_, err = client.PutObject(ctx, minioDal.Bucket, objectName,
		bytes.NewReader(content), int64(len(content)),
		minio.PutObjectOptions{ContentType: contentType})
	if err != nil {
		return fmt.Errorf("error create test object: %w", err)
	}

	err = client.RemoveObject(ctx, minioDal.Bucket, objectName, minio.RemoveObjectOptions{})
	if err != nil {
		return fmt.Errorf("error remove test object: %w", err)
	}

	return nil
}