package config

import (
	"testing"
	"time"
)

func TestLoadConfigFromEnvAndArgs(t *testing.T) {
	cfg, err := Load([]string{"-node-name", "node-b"}, map[string]string{
		"RAP_BACKEND_URL":                               "http://backend/api/v1/",
		"RAP_CLUSTER_ID":                                "cluster-1",
		"RAP_CLUSTER_AUTHORITY_PUBLIC_KEY":              "public-key-b64",
		"RAP_CLUSTER_AUTHORITY_FINGERPRINT":             "rap-ca-ed25519-test",
		"RAP_JOIN_TOKEN":                                "join-token",
		"RAP_NODE_NAME":                                 "node-a",
		"RAP_NODE_STATE_DIR":                            "/tmp/rap-node",
		"RAP_WORKLOAD_SUPERVISION_ENABLED":              "true",
		"RAP_HEARTBEAT_INTERVAL_SECONDS":                "7",
		"RAP_ENROLLMENT_POLL_INTERVAL_SECONDS":          "3",
		"RAP_ENROLLMENT_POLL_TIMEOUT_SECONDS":           "30",
		"RAP_MESH_SYNTHETIC_RUNTIME_ENABLED":            "true",
		"RAP_MESH_PRODUCTION_FORWARDING_ENABLED":        "true",
		"RAP_MESH_PRODUCTION_OBSERVATION_SINK_CAPACITY": "5",
		"RAP_MESH_LISTEN_ADDR":                          "127.0.0.1:19001",
		"RAP_MESH_ADVERTISE_ENDPOINT":                   "https://node-a.example.test:443/",
		"RAP_MESH_ADVERTISE_ENDPOINTS_JSON":             `[{"endpoint_id":"node-a-lan","address":"10.10.0.20:19001"}]`,
		"RAP_MESH_ADVERTISE_TRANSPORT":                  "wss",
		"RAP_MESH_CONNECTIVITY_MODE":                    "outbound_only",
		"RAP_MESH_NAT_TYPE":                             "symmetric",
		"RAP_MESH_REGION":                               "eu",
		"RAP_MESH_SYNTHETIC_CONFIG":                     "/tmp/rap-node/mesh-synthetic.json",
		"RAP_MESH_PEER_ENDPOINTS_JSON":                  `{"node-b":"http://127.0.0.1:19002"}`,
		"RAP_MESH_SYNTHETIC_ROUTES_JSON":                `[{"route_id":"route-1"}]`,
	})
	if err != nil {
		t.Fatalf("load config: %v", err)
	}
	if cfg.BackendURL != "http://backend/api/v1" {
		t.Fatalf("BackendURL = %q", cfg.BackendURL)
	}
	if cfg.NodeName != "node-b" {
		t.Fatalf("NodeName = %q", cfg.NodeName)
	}
	if cfg.ClusterAuthorityPublicKey != "public-key-b64" || cfg.ClusterAuthorityFingerprint != "rap-ca-ed25519-test" {
		t.Fatalf("unexpected cluster authority pin config: %+v", cfg)
	}
	if cfg.HeartbeatInterval != 7*time.Second {
		t.Fatalf("HeartbeatInterval = %s", cfg.HeartbeatInterval)
	}
	if cfg.EnrollmentPollInterval != 3*time.Second || cfg.EnrollmentPollTimeout != 30*time.Second {
		t.Fatalf("unexpected enrollment polling config: %+v", cfg)
	}
	if !cfg.WorkloadSupervisionEnabled {
		t.Fatal("WorkloadSupervisionEnabled = false, want true")
	}
	if !cfg.MeshSyntheticRuntimeEnabled {
		t.Fatal("MeshSyntheticRuntimeEnabled = false, want true")
	}
	if !cfg.MeshProductionForwardingEnabled {
		t.Fatal("MeshProductionForwardingEnabled = false, want true")
	}
	if cfg.MeshProductionObservationSinkCapacity != 5 {
		t.Fatalf("MeshProductionObservationSinkCapacity = %d, want 5", cfg.MeshProductionObservationSinkCapacity)
	}
	if cfg.MeshListenAddr != "127.0.0.1:19001" {
		t.Fatalf("MeshListenAddr = %q", cfg.MeshListenAddr)
	}
	if cfg.MeshAdvertiseEndpoint != "https://node-a.example.test:443" ||
		cfg.MeshAdvertiseEndpointsJSON == "" ||
		cfg.MeshAdvertiseTransport != "wss" ||
		cfg.MeshConnectivityMode != "outbound_only" ||
		cfg.MeshNATType != "symmetric" ||
		cfg.MeshRegion != "eu" {
		t.Fatalf("unexpected mesh advertise config: %+v", cfg)
	}
	if cfg.MeshSyntheticConfigPath != "/tmp/rap-node/mesh-synthetic.json" {
		t.Fatalf("MeshSyntheticConfigPath = %q", cfg.MeshSyntheticConfigPath)
	}
	if cfg.MeshPeerEndpointsJSON == "" || cfg.MeshSyntheticRoutesJSON == "" {
		t.Fatalf("mesh live synthetic config was not loaded: %+v", cfg)
	}
}

func TestLoadConfigRejectsNegativeProductionObservationSinkCapacity(t *testing.T) {
	_, err := Load(nil, map[string]string{
		"RAP_BACKEND_URL": "http://backend/api/v1",
		"RAP_NODE_NAME":   "node-a",
		"RAP_MESH_PRODUCTION_OBSERVATION_SINK_CAPACITY": "-1",
	})
	if err == nil {
		t.Fatal("Load returned nil error for negative sink capacity")
	}
}

func TestLoadConfigRejectsTooLargeProductionObservationSinkCapacity(t *testing.T) {
	_, err := Load(nil, map[string]string{
		"RAP_BACKEND_URL": "http://backend/api/v1",
		"RAP_NODE_NAME":   "node-a",
		"RAP_MESH_PRODUCTION_OBSERVATION_SINK_CAPACITY": "10001",
	})
	if err == nil {
		t.Fatal("Load returned nil error for too-large sink capacity")
	}
}