package config

import (
	"encoding/json"
	"errors"
	"net"
	"os"
	pathpkg "path"
	"path/filepath"
	"strings"
	"time"
)

const (
	defaultDockerMainConfigRelativePath    = "etc/nginx/nginx.conf"
	defaultDockerRouteConfigRelativePath   = "etc/nginx/conf.d/openflare_routes.conf"
	defaultCertDirRelativePath             = "etc/nginx/certs"
	defaultLuaDirRelativePath              = "etc/nginx/lua"
	defaultDockerStateRelativePath         = "var/lib/openflare/agent-state.json"
	defaultObservabilityBufferRelativePath = "var/lib/openflare/observability-buffer.json"
	defaultDockerOpenRestyCertDir          = "/etc/nginx/openflare-certs"
	defaultDockerOpenRestyLuaDir           = "/etc/nginx/openflare-lua"
	defaultOpenRestyObservabilityPort      = 18081
	defaultObservabilityReplayMinutes      = 15
)

type Config struct {
	ServerURL                  string              `json:"server_url"`
	AgentToken                 string              `json:"agent_token"`
	DiscoveryToken             string              `json:"discovery_token"`
	NodeName                   string              `json:"node_name"`
	NodeIP                     string              `json:"node_ip"`
	AgentVersion               string              `json:"-"`
	NginxVersion               string              `json:"-"`
	OpenrestyPath              string              `json:"openresty_path"`
	OpenrestyContainerName     string              `json:"openresty_container_name"`
	OpenrestyDockerImage       string              `json:"openresty_docker_image"`
	DockerBinary               string              `json:"docker_binary"`
	DataDir                    string              `json:"data_dir"`
	MainConfigPath             string              `json:"main_config_path"`
	RouteConfigPath            string              `json:"route_config_path"`
	CertDir                    string              `json:"cert_dir"`
	OpenrestyCertDir           string              `json:"openresty_cert_dir"`
	LuaDir                     string              `json:"lua_dir"`
	OpenrestyLuaDir            string              `json:"openresty_lua_dir"`
	OpenrestyObservabilityPort int                 `json:"openresty_observability_port"`
	ObservabilityBufferPath    string              `json:"observability_buffer_path"`
	ObservabilityReplayMinutes int                 `json:"observability_replay_minutes"`
	StatePath                  string              `json:"state_path"`
	HeartbeatInterval          MillisecondDuration `json:"heartbeat_interval"`
	RequestTimeout             MillisecondDuration `json:"request_timeout"`
	configPath                 string
}

type configFile struct {
	ServerURL                  string              `json:"server_url"`
	AgentToken                 string              `json:"agent_token"`
	DiscoveryToken             string              `json:"discovery_token"`
	NodeName                   string              `json:"node_name"`
	NodeIP                     string              `json:"node_ip"`
	OpenrestyPath              string              `json:"openresty_path"`
	OpenrestyContainerName     string              `json:"openresty_container_name"`
	OpenrestyDockerImage       string              `json:"openresty_docker_image"`
	DockerBinary               string              `json:"docker_binary"`
	DataDir                    string              `json:"data_dir"`
	MainConfigPath             string              `json:"main_config_path"`
	RouteConfigPath            string              `json:"route_config_path"`
	CertDir                    string              `json:"cert_dir"`
	OpenrestyCertDir           string              `json:"openresty_cert_dir"`
	LuaDir                     string              `json:"lua_dir"`
	OpenrestyLuaDir            string              `json:"openresty_lua_dir"`
	OpenrestyObservabilityPort int                 `json:"openresty_observability_port"`
	ObservabilityBufferPath    string              `json:"observability_buffer_path"`
	ObservabilityReplayMinutes int                 `json:"observability_replay_minutes"`
	StatePath                  string              `json:"state_path"`
	HeartbeatInterval          MillisecondDuration `json:"heartbeat_interval"`
	RequestTimeout             MillisecondDuration `json:"request_timeout"`
}

func Load(path string) (*Config, error) {
	data, err := os.ReadFile(path)
	if err != nil {
		return nil, err
	}
	file := &configFile{}
	if err = json.Unmarshal(data, file); err != nil {
		return nil, err
	}
	cfg := &Config{
		ServerURL:                  file.ServerURL,
		AgentToken:                 file.AgentToken,
		DiscoveryToken:             file.DiscoveryToken,
		NodeName:                   file.NodeName,
		NodeIP:                     file.NodeIP,
		OpenrestyPath:              file.OpenrestyPath,
		OpenrestyContainerName:     file.OpenrestyContainerName,
		OpenrestyDockerImage:       file.OpenrestyDockerImage,
		DockerBinary:               file.DockerBinary,
		DataDir:                    file.DataDir,
		MainConfigPath:             file.MainConfigPath,
		RouteConfigPath:            file.RouteConfigPath,
		CertDir:                    file.CertDir,
		OpenrestyCertDir:           file.OpenrestyCertDir,
		LuaDir:                     file.LuaDir,
		OpenrestyLuaDir:            file.OpenrestyLuaDir,
		OpenrestyObservabilityPort: file.OpenrestyObservabilityPort,
		ObservabilityBufferPath:    file.ObservabilityBufferPath,
		ObservabilityReplayMinutes: file.ObservabilityReplayMinutes,
		StatePath:                  file.StatePath,
		HeartbeatInterval:          file.HeartbeatInterval,
		RequestTimeout:             file.RequestTimeout,
	}
	cfg.configPath = path
	applyDefaults(cfg, filepath.Dir(path))
	if err = validate(cfg); err != nil {
		return nil, err
	}
	return cfg, nil
}

func applyDefaults(cfg *Config, baseDir string) {
	baseDir = filepath.Clean(baseDir)
	cfg.AgentVersion = AgentVersion
	if cfg.OpenrestyContainerName == "" {
		cfg.OpenrestyContainerName = "openflare-openresty"
	}
	if cfg.OpenrestyDockerImage == "" {
		cfg.OpenrestyDockerImage = "openresty/openresty:alpine"
	}
	if cfg.DockerBinary == "" {
		cfg.DockerBinary = "docker"
	}
	if cfg.DataDir == "" {
		cfg.DataDir = filepath.Join(baseDir, "data")
	}
	if cfg.NodeName == "" {
		cfg.NodeName = detectHostname()
	}
	if cfg.NodeIP == "" {
		cfg.NodeIP = detectNodeIP()
	}
	if cfg.OpenrestyPath == "" {
		cfg.MainConfigPath = joinManagedPath(cfg.DataDir, defaultDockerMainConfigRelativePath)
		cfg.RouteConfigPath = joinManagedPath(cfg.DataDir, defaultDockerRouteConfigRelativePath)
		cfg.StatePath = joinManagedPath(cfg.DataDir, defaultDockerStateRelativePath)
	} else {
		if cfg.MainConfigPath == "" {
			cfg.MainConfigPath = joinManagedPath(cfg.DataDir, defaultDockerMainConfigRelativePath)
		}
		if cfg.RouteConfigPath == "" {
			cfg.RouteConfigPath = joinManagedPath(cfg.DataDir, defaultDockerRouteConfigRelativePath)
		}
		if cfg.StatePath == "" {
			cfg.StatePath = joinManagedPath(cfg.DataDir, defaultDockerStateRelativePath)
		}
	}
	if cfg.CertDir == "" {
		cfg.CertDir = joinManagedPath(cfg.DataDir, defaultCertDirRelativePath)
	}
	if cfg.OpenrestyCertDir == "" {
		if cfg.OpenrestyPath != "" {
			cfg.OpenrestyCertDir = cfg.CertDir
		} else {
			cfg.OpenrestyCertDir = defaultDockerOpenRestyCertDir
		}
	}
	if cfg.LuaDir == "" {
		cfg.LuaDir = joinManagedPath(cfg.DataDir, defaultLuaDirRelativePath)
	}
	if cfg.OpenrestyLuaDir == "" {
		if cfg.OpenrestyPath != "" {
			cfg.OpenrestyLuaDir = cfg.LuaDir
		} else {
			cfg.OpenrestyLuaDir = defaultDockerOpenRestyLuaDir
		}
	}
	if cfg.OpenrestyObservabilityPort <= 0 {
		cfg.OpenrestyObservabilityPort = defaultOpenRestyObservabilityPort
	}
	if cfg.ObservabilityBufferPath == "" {
		cfg.ObservabilityBufferPath = joinManagedPath(cfg.DataDir, defaultObservabilityBufferRelativePath)
	}
	if cfg.ObservabilityReplayMinutes <= 0 {
		cfg.ObservabilityReplayMinutes = defaultObservabilityReplayMinutes
	}
	if cfg.HeartbeatInterval <= 0 {
		cfg.HeartbeatInterval = MillisecondDuration(10 * time.Second)
	}
	if cfg.RequestTimeout <= 0 {
		cfg.RequestTimeout = MillisecondDuration(10 * time.Second)
	}
	normalizeManagedPaths(cfg)
}

func normalizeManagedPaths(cfg *Config) {
	if cfg == nil {
		return
	}
	if usesSlashPath(cfg.DataDir) {
		cfg.DataDir = filepath.ToSlash(cfg.DataDir)
	}
	if usesSlashPath(cfg.MainConfigPath) {
		cfg.MainConfigPath = filepath.ToSlash(cfg.MainConfigPath)
	}
	if usesSlashPath(cfg.RouteConfigPath) {
		cfg.RouteConfigPath = filepath.ToSlash(cfg.RouteConfigPath)
	}
	if usesSlashPath(cfg.CertDir) {
		cfg.CertDir = filepath.ToSlash(cfg.CertDir)
	}
	if usesSlashPath(cfg.OpenrestyCertDir) {
		cfg.OpenrestyCertDir = filepath.ToSlash(cfg.OpenrestyCertDir)
	}
	if usesSlashPath(cfg.LuaDir) {
		cfg.LuaDir = filepath.ToSlash(cfg.LuaDir)
	}
	if usesSlashPath(cfg.OpenrestyLuaDir) {
		cfg.OpenrestyLuaDir = filepath.ToSlash(cfg.OpenrestyLuaDir)
	}
	if usesSlashPath(cfg.StatePath) {
		cfg.StatePath = filepath.ToSlash(cfg.StatePath)
	}
	if usesSlashPath(cfg.ObservabilityBufferPath) {
		cfg.ObservabilityBufferPath = filepath.ToSlash(cfg.ObservabilityBufferPath)
	}
}

func usesSlashPath(path string) bool {
	return strings.HasPrefix(path, "/")
}

func joinManagedPath(base string, relative string) string {
	if usesSlashPath(base) {
		return pathpkg.Join(filepath.ToSlash(base), relative)
	}
	return filepath.Join(base, relative)
}

func validate(cfg *Config) error {
	if cfg.ServerURL == "" {
		return errors.New("server_url 不能为空")
	}
	if strings.TrimSpace(cfg.AgentToken) == "" && strings.TrimSpace(cfg.DiscoveryToken) == "" {
		return errors.New("agent_token 和 discovery_token 不能同时为空")
	}
	if cfg.NodeName == "" {
		return errors.New("node_name 不能为空")
	}
	if cfg.NodeIP == "" {
		return errors.New("node_ip 不能为空")
	}
	if cfg.OpenrestyObservabilityPort <= 0 || cfg.OpenrestyObservabilityPort > 65535 {
		return errors.New("openresty_observability_port 必须在 1-65535 之间")
	}
	if cfg.ObservabilityReplayMinutes <= 0 {
		return errors.New("observability_replay_minutes 必须大于 0")
	}
	return nil
}

func (cfg *Config) InitialAuthToken() string {
	if cfg == nil {
		return ""
	}
	if token := strings.TrimSpace(cfg.AgentToken); token != "" {
		return token
	}
	return strings.TrimSpace(cfg.DiscoveryToken)
}

func (cfg *Config) Save() error {
	if cfg == nil {
		return errors.New("config 不能为空")
	}
	if cfg.configPath == "" {
		return errors.New("config path 未初始化")
	}
	data, err := json.MarshalIndent(cfg, "", "  ")
	if err != nil {
		return err
	}
	return os.WriteFile(cfg.configPath, data, 0o644)
}

func detectHostname() string {
	host, err := os.Hostname()
	if err != nil {
		return ""
	}
	return strings.TrimSpace(host)
}

func firstNonEmpty(values ...string) string {
	for _, value := range values {
		if strings.TrimSpace(value) != "" {
			return value
		}
	}
	return ""
}

func detectNodeIP() string {
	interfaces, err := net.Interfaces()
	if err != nil {
		return ""
	}
	for _, iface := range interfaces {
		if iface.Flags&net.FlagUp == 0 || iface.Flags&net.FlagLoopback != 0 {
			continue
		}
		addrs, err := iface.Addrs()
		if err != nil {
			continue
		}
		for _, addr := range addrs {
			ipNet, ok := addr.(*net.IPNet)
			if !ok || ipNet.IP == nil || ipNet.IP.IsLoopback() {
				continue
			}
			ipv4 := ipNet.IP.To4()
			if ipv4 != nil {
				return ipv4.String()
			}
		}
	}
	return ""
}