package app

import (
	"context"
	"fmt"
	"log/slog"

	"galaxy/mail/internal/adapters/smtp"
	"galaxy/mail/internal/adapters/stubprovider"
	templatedir "galaxy/mail/internal/adapters/templates"
	"galaxy/mail/internal/config"
	"galaxy/mail/internal/ports"
	"galaxy/mail/internal/telemetry"

	"github.com/redis/go-redis/extra/redisotel/v9"
	"github.com/redis/go-redis/v9"
)

func newRedisClient(cfg config.RedisConfig) *redis.Client {
	return redis.NewClient(&redis.Options{
		Addr:         cfg.Addr,
		Username:     cfg.Username,
		Password:     cfg.Password,
		DB:           cfg.DB,
		TLSConfig:    cfg.TLSConfig(),
		DialTimeout:  cfg.OperationTimeout,
		ReadTimeout:  cfg.OperationTimeout,
		WriteTimeout: cfg.OperationTimeout,
	})
}

func instrumentRedisClient(client *redis.Client, telemetryRuntime *telemetry.Runtime) error {
	if client == nil {
		return fmt.Errorf("instrument redis client: nil client")
	}
	if telemetryRuntime == nil {
		return nil
	}

	if err := redisotel.InstrumentTracing(
		client,
		redisotel.WithTracerProvider(telemetryRuntime.TracerProvider()),
		redisotel.WithDBStatement(false),
	); err != nil {
		return fmt.Errorf("instrument redis client tracing: %w", err)
	}
	if err := redisotel.InstrumentMetrics(
		client,
		redisotel.WithMeterProvider(telemetryRuntime.MeterProvider()),
	); err != nil {
		return fmt.Errorf("instrument redis client metrics: %w", err)
	}

	return nil
}

func pingRedis(ctx context.Context, cfg config.RedisConfig, client *redis.Client) error {
	if client == nil {
		return fmt.Errorf("ping redis: nil client")
	}

	pingCtx, cancel := context.WithTimeout(ctx, cfg.OperationTimeout)
	defer cancel()

	if err := client.Ping(pingCtx).Err(); err != nil {
		return fmt.Errorf("ping redis: %w", err)
	}

	return nil
}

func newTemplateCatalog(cfg config.TemplateConfig) (*templatedir.Catalog, error) {
	catalog, err := templatedir.NewCatalog(cfg.Dir)
	if err != nil {
		return nil, fmt.Errorf("new template catalog: %w", err)
	}

	return catalog, nil
}

func newProvider(cfg config.SMTPConfig, logger *slog.Logger) (ports.Provider, error) {
	if logger == nil {
		logger = slog.Default()
	}

	switch cfg.Mode {
	case config.SMTPModeStub:
		provider, err := stubprovider.New()
		if err != nil {
			return nil, fmt.Errorf("new stub provider: %w", err)
		}
		logger.Info("mail provider configured", "mode", cfg.Mode)
		return provider, nil
	case config.SMTPModeSMTP:
		provider, err := smtp.New(smtp.Config{
			Addr:               cfg.Addr,
			Username:           cfg.Username,
			Password:           cfg.Password,
			FromEmail:          cfg.FromEmail,
			FromName:           cfg.FromName,
			Timeout:            cfg.Timeout,
			InsecureSkipVerify: cfg.InsecureSkipVerify,
		})
		if err != nil {
			return nil, fmt.Errorf("new smtp provider: %w", err)
		}
		logger.Info("mail provider configured", "mode", cfg.Mode, "addr", cfg.Addr)
		return provider, nil
	default:
		return nil, fmt.Errorf("new provider: unsupported mode %q", cfg.Mode)
	}
}