package resolver

import "strings"

type DNSModeRuntimeInput struct {
	Config                DNSConfig
	Mode                  string
	ViaSmartDNS           bool
	SmartDNSAddr          string
	SmartDNSForced        bool
	SmartDNSDefault       string
	NormalizeMode         func(mode string, viaSmartDNS bool) string
	NormalizeSmartDNSAddr func(raw string) string
}

func ApplyDNSModeRuntime(in DNSModeRuntimeInput) DNSConfig {
	cfg := DNSConfig{
		Default:  append([]string(nil), in.Config.Default...),
		Meta:     append([]string(nil), in.Config.Meta...),
		SmartDNS: strings.TrimSpace(in.Config.SmartDNS),
		Mode:     strings.TrimSpace(in.Config.Mode),
	}

	if !in.SmartDNSForced && in.NormalizeMode != nil {
		if mode := strings.TrimSpace(in.NormalizeMode(in.Mode, in.ViaSmartDNS)); mode != "" {
			cfg.Mode = mode
		}
	}

	if in.NormalizeSmartDNSAddr != nil {
		if addr := strings.TrimSpace(in.NormalizeSmartDNSAddr(in.SmartDNSAddr)); addr != "" {
			cfg.SmartDNS = addr
		}
	} else if addr := strings.TrimSpace(in.SmartDNSAddr); addr != "" {
		cfg.SmartDNS = addr
	}

	if cfg.SmartDNS == "" {
		cfg.SmartDNS = strings.TrimSpace(in.SmartDNSDefault)
	}

	if cfg.Mode == "smartdns" && cfg.SmartDNS != "" {
		cfg.Default = []string{cfg.SmartDNS}
		cfg.Meta = []string{cfg.SmartDNS}
	}

	return cfg
}

func LogDNSMode(cfg DNSConfig, wildcardCount int, logf func(string, ...any)) {
	if logf == nil {
		return
	}
	switch cfg.Mode {
	case "smartdns":
		logf("resolver dns mode: SmartDNS-only (%s)", cfg.SmartDNS)
	case "hybrid_wildcard":
		logf("resolver dns mode: hybrid_wildcard smartdns=%s wildcards=%d default=%v meta=%v", cfg.SmartDNS, wildcardCount, cfg.Default, cfg.Meta)
	default:
		logf("resolver dns mode: direct default=%v meta=%v", cfg.Default, cfg.Meta)
	}
}