package natsb

import (
	"fmt"
	"net"
	"net/url"
	"os"
	"strconv"
	"strings"
	"sync"
	"time"

	"github.com/nats-io/nats.go"
	"github.com/tech/sendico/pkg/merrors"
	nc "github.com/tech/sendico/pkg/messaging/internal/natsb/config"
	"github.com/tech/sendico/pkg/mlogger"
	"go.uber.org/zap"
)

type natsSubscriotions = map[string]*TopicSubscription

type NatsBroker struct {
	nc        *nats.Conn
	js        nats.JetStreamContext
	logger    *zap.Logger
	topicSubs natsSubscriotions
	mu        sync.Mutex
}

type envConfig struct {
	User, Password, Host string
	Port                 int
}

// loadEnv gathers and validates connection details from environment variables
// listed in the Settings struct. Invalid or missing values surface as a typed
// InvalidArgument error so callers can decide how to handle them.
func loadEnv(settings *nc.Settings, l *zap.Logger) (*envConfig, error) {
	get := func(key, label string) (string, error) {
		if v := os.Getenv(key); v != "" {
			return v, nil
		}
		l.Error(fmt.Sprintf("NATS %s not found in environment", label), zap.String("env_var", key))
		return "", merrors.InvalidArgument(fmt.Sprintf("NATS %s not found in environment variable: %s", label, key), key)
	}

	user, err := get(settings.UsernameEnv, "user name")
	if err != nil {
		return nil, err
	}

	password, err := get(settings.PasswordEnv, "password")
	if err != nil {
		return nil, err
	}

	host, err := get(settings.HostEnv, "host")
	if err != nil {
		return nil, err
	}

	portStr, err := get(settings.PortEnv, "port")
	if err != nil {
		return nil, err
	}

	port, err := strconv.Atoi(portStr)
	if err != nil || port <= 0 || port > 65535 {
		l.Error("Invalid NATS port value", zap.String("port", portStr))
		return nil, merrors.InvalidArgument("Invalid NATS port: "+portStr, settings.PortEnv)
	}

	return &envConfig{
		User:     user,
		Password: password,
		Host:     host,
		Port:     port,
	}, nil
}

func NewNatsBroker(logger mlogger.Logger, settings *nc.Settings) (*NatsBroker, error) {
	l := logger.Named("broker")
	var err error
	var cfg *envConfig
	var natsURL string
	if settings != nil && strings.TrimSpace(settings.URLEnv) != "" {
		urlVal := strings.TrimSpace(os.Getenv(settings.URLEnv))
		if urlVal != "" {
			natsURL = urlVal
		}
	}
	if natsURL == "" {
		// Helper function to get environment variables
		cfg, err = loadEnv(settings, l)
		if err != nil {
			return nil, err
		}

		u := &url.URL{
			Scheme: "nats",
			Host:   net.JoinHostPort(cfg.Host, strconv.Itoa(cfg.Port)),
		}
		natsURL = u.String()
	}

	opts := []nats.Option{
		nats.Name(settings.NATSName),
		nats.MaxReconnects(settings.MaxReconnects),
		nats.ReconnectWait(time.Duration(settings.ReconnectWait) * time.Second),
	}
	if cfg != nil {
		opts = append(opts, nats.UserInfo(cfg.User, cfg.Password))
	} else if settings != nil {
		userEnv := strings.TrimSpace(settings.UsernameEnv)
		passEnv := strings.TrimSpace(settings.PasswordEnv)
		if userEnv != "" && passEnv != "" {
			user := strings.TrimSpace(os.Getenv(userEnv))
			pass := strings.TrimSpace(os.Getenv(passEnv))
			if user != "" || pass != "" {
				opts = append(opts, nats.UserInfo(user, pass))
			}
		}
	}

	res := &NatsBroker{
		logger:    l.Named("nats"),
		topicSubs: natsSubscriotions{},
	}

	if res.nc, err = nats.Connect(natsURL, opts...); err != nil {
		l.Error("Failed to connect to NATS", zap.String("url", natsURL), zap.Error(err))
		return nil, err
	}
	if res.js, err = res.nc.JetStream(); err != nil {
		l.Warn("Failed to initialise JetStream context", zap.Error(err))
	}

	logger.Info("Connected to NATS", zap.String("broker", settings.NATSName),
		zap.String("url", natsURL))
	return res, nil
}

func (b *NatsBroker) JetStream() nats.JetStreamContext {
	if b == nil {
		return nil
	}
	return b.js
}