package mcp

import (
	"reflect"
	"testing"
)

func TestFromEnv_DefaultServer(t *testing.T) {
	t.Parallel()
	pairs := []string{
		"MCP_NAME=calc",
		"MCP_COMMAND=mcp-calc",
		"MCP_ARGS=--stdio,--transport",
		"MCP_URL=",
		"MCP_ENABLED=true",
	}
	cfg, err := FromEnv(pairs)
	if err != nil {
		t.Fatalf("FromEnv: %v", err)
	}
	if len(cfg.Servers) != 1 {
		t.Fatalf("servers = %d, want 1", len(cfg.Servers))
	}
	s := cfg.Servers[0]
	if s.Name != "calc" || s.Command != "mcp-calc" || !s.Enabled {
		t.Fatalf("server = %+v, want calc/mcp-calc/enabled", s)
	}
	if !reflect.DeepEqual(s.Args, []string{"--stdio", "--transport"}) {
		t.Fatalf("Args = %v, want [--stdio --transport]", s.Args)
	}
}

func TestFromEnv_MultipleServers(t *testing.T) {
	t.Parallel()
	pairs := []string{
		"MCP_0_NAME=calc",
		"MCP_0_COMMAND=mcp-calc",
		"MCP_0_ENABLED=true",
		"MCP_1_NAME=web",
		"MCP_1_URL=http://localhost:9090/sse",
		"MCP_1_ENABLED=false",
	}
	cfg, err := FromEnv(pairs)
	if err != nil {
		t.Fatalf("FromEnv: %v", err)
	}
	if len(cfg.Servers) != 2 {
		t.Fatalf("servers = %d, want 2", len(cfg.Servers))
	}
	if cfg.Servers[1].Name != "web" || cfg.Servers[1].URL != "http://localhost:9090/sse" || cfg.Servers[1].Enabled {
		t.Fatalf("server[1] = %+v, want web/url/disabled", cfg.Servers[1])
	}
}

func TestFromEnv_TransportType(t *testing.T) {
	t.Parallel()
	pairs := []string{
		"MCP_NAME=web",
		"MCP_URL=http://localhost:9090/mcp",
		"MCP_TRANSPORT=http",
	}
	cfg, err := FromEnv(pairs)
	if err != nil {
		t.Fatalf("FromEnv: %v", err)
	}
	if len(cfg.Servers) != 1 {
		t.Fatalf("servers = %d, want 1", len(cfg.Servers))
	}
	if cfg.Servers[0].TransportType != "http" {
		t.Fatalf("TransportType = %q, want http", cfg.Servers[0].TransportType)
	}
}

func TestFromEnv_NoServers(t *testing.T) {
	t.Parallel()
	cfg, err := FromEnv([]string{"MCP_ENABLED=true"})
	if err != nil {
		t.Fatalf("FromEnv: %v", err)
	}
	if len(cfg.Servers) != 0 {
		t.Fatalf("servers = %d, want 0 (ENABLED alone is not a server)", len(cfg.Servers))
	}
}

func TestFromEnv_Empty(t *testing.T) {
	t.Parallel()
	cfg, err := FromEnv(nil)
	if err != nil {
		t.Fatalf("FromEnv: %v", err)
	}
	if len(cfg.Servers) != 0 {
		t.Fatalf("servers = %d, want 0", len(cfg.Servers))
	}
}

func TestFromYAML(t *testing.T) {
	t.Parallel()
	data := []byte(`
servers:
  - name: calc
    command: mcp-calc
    args: [--stdio]
    enabled: true
  - name: web
    url: http://localhost:9090/sse
`)
	cfg, err := FromYAML(data)
	if err != nil {
		t.Fatalf("FromYAML: %v", err)
	}
	if len(cfg.Servers) != 2 {
		t.Fatalf("servers = %d, want 2", len(cfg.Servers))
	}
	if cfg.Servers[0].Name != "calc" || cfg.Servers[0].Command != "mcp-calc" || !cfg.Servers[0].Enabled {
		t.Fatalf("server[0] = %+v, want calc/mcp-calc/enabled", cfg.Servers[0])
	}
	if !reflect.DeepEqual(cfg.Servers[0].Args, []string{"--stdio"}) {
		t.Fatalf("Args = %v, want [--stdio]", cfg.Servers[0].Args)
	}
	if cfg.Servers[1].URL != "http://localhost:9090/sse" {
		t.Fatalf("server[1].URL = %q, want sse url", cfg.Servers[1].URL)
	}
}

func TestFromYAML_Invalid(t *testing.T) {
	t.Parallel()
	if _, err := FromYAML([]byte(`servers: [`)); err == nil {
		t.Fatal("FromYAML with malformed YAML succeeded, want error")
	}
}

func TestSplitArgs(t *testing.T) {
	t.Parallel()
	tests := []struct {
		in   string
		want []string
	}{
		{in: "--stdio,--transport", want: []string{"--stdio", "--transport"}},
		{in: " a , b ,, c ", want: []string{"a", "b", "c"}},
		{in: "", want: nil},
		{in: "   ", want: nil},
	}
	for _, tt := range tests {
		tt := tt
		t.Run(tt.in, func(t *testing.T) {
			t.Parallel()
			if got := splitArgs(tt.in); !reflect.DeepEqual(got, tt.want) {
				t.Fatalf("splitArgs(%q) = %v, want %v", tt.in, got, tt.want)
			}
		})
	}
}

func TestParseBool(t *testing.T) {
	t.Parallel()
	tests := []struct {
		in   string
		def  bool
		want bool
	}{
		{in: "true", def: false, want: true},
		{in: "false", def: true, want: false},
		{in: "TRUE", def: false, want: true},
		{in: "1", def: false, want: true},
		{in: "", def: true, want: true},
		{in: "garbage", def: false, want: false},
	}
	for _, tt := range tests {
		tt := tt
		t.Run(tt.in, func(t *testing.T) {
			t.Parallel()
			if got := parseBool(tt.in, tt.def); got != tt.want {
				t.Fatalf("parseBool(%q, %v) = %v, want %v", tt.in, tt.def, got, tt.want)
			}
		})
	}
}