package main

import (
	"context"
	"errors"
	"io"
	"net"
	"net/http"
	"strconv"
	"strings"
	"testing"
	"time"

	"github.com/sipeed/picoclaw/pkg/netbind"
	"github.com/sipeed/picoclaw/web/backend/launcherconfig"
)

func TestShouldEnableLauncherFileLogging(t *testing.T) {
	tests := []struct {
		name          string
		enableConsole bool
		debug         bool
		want          bool
	}{
		{name: "gui mode", enableConsole: false, debug: false, want: true},
		{name: "console mode", enableConsole: true, debug: false, want: false},
		{name: "debug gui mode", enableConsole: false, debug: true, want: true},
		{name: "debug console mode", enableConsole: true, debug: true, want: true},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if got := shouldEnableLauncherFileLogging(tt.enableConsole, tt.debug); got != tt.want {
				t.Fatalf(
					"shouldEnableLauncherFileLogging(%t, %t) = %t, want %t",
					tt.enableConsole,
					tt.debug,
					got,
					tt.want,
				)
			}
		})
	}
}

func TestDashboardTokenConfigHelpPath(t *testing.T) {
	const launcherPath = "/tmp/launcher-config.json"

	tests := []struct {
		name   string
		source launcherconfig.DashboardTokenSource
		want   string
	}{
		{
			name:   "env token does not expose config path",
			source: launcherconfig.DashboardTokenSourceEnv,
			want:   "",
		},
		{
			name:   "config token exposes config path",
			source: launcherconfig.DashboardTokenSourceConfig,
			want:   launcherPath,
		},
		{
			name:   "random token does not expose config path",
			source: launcherconfig.DashboardTokenSourceRandom,
			want:   "",
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if got := dashboardTokenConfigHelpPath(tt.source, launcherPath); got != tt.want {
				t.Fatalf("dashboardTokenConfigHelpPath(%q, %q) = %q, want %q", tt.source, launcherPath, got, tt.want)
			}
		})
	}
}

func TestMaskSecret(t *testing.T) {
	tests := []struct {
		input string
		want  string
	}{
		{"sdhjflsjdflksdf", "sdh**********ksdf"},
		{"abcdefghijklmnopqrstuvwxyz", "abc**********wxyz"},
		{"abcdefghijkl", "abc**********ijkl"},
		{"abcdefgh", "abc**********"},
		{"abcdefghijk", "abc**********"},
		{"abcdefg", "abc**********"},
		{"abcd", "abc**********"},
		{"abc", "**********"},
		{"", "**********"},
	}

	for _, tt := range tests {
		if got := maskSecret(tt.input); got != tt.want {
			t.Errorf("maskSecret(%q) = %q, want %q", tt.input, got, tt.want)
		}
	}
}

func TestResolveLauncherHostInput(t *testing.T) {
	tests := []struct {
		name         string
		flagHost     string
		explicitFlag bool
		envHost      string
		wantHost     string
		wantActive   bool
		wantErr      bool
	}{
		{
			name:         "flag host wins",
			flagHost:     "127.0.0.1",
			explicitFlag: true,
			envHost:      "::",
			wantHost:     "127.0.0.1",
			wantActive:   true,
		},
		{name: "env host used when flag absent", envHost: "127.0.0.1,::1", wantHost: "127.0.0.1,::1", wantActive: true},
		{name: "blank env ignored", envHost: "   ", wantHost: "", wantActive: false},
		{name: "invalid flag rejected", flagHost: "127.0.0.1, ", explicitFlag: true, wantErr: true},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			gotHost, gotActive, err := resolveLauncherHostInput(tt.flagHost, tt.explicitFlag, tt.envHost)
			if (err != nil) != tt.wantErr {
				t.Fatalf("resolveLauncherHostInput() err = %v, wantErr %t", err, tt.wantErr)
			}
			if tt.wantErr {
				return
			}
			if gotHost != tt.wantHost {
				t.Fatalf("resolveLauncherHostInput() host = %q, want %q", gotHost, tt.wantHost)
			}
			if gotActive != tt.wantActive {
				t.Fatalf("resolveLauncherHostInput() active = %t, want %t", gotActive, tt.wantActive)
			}
		})
	}
}

func TestLauncherConsoleHosts(t *testing.T) {
	t.Run("default loopback shows localhost only", func(t *testing.T) {
		hosts := launcherConsoleHostsWithLocalAddrs(
			"",
			false,
			[]string{"192.168.1.2", "10.0.0.8"},
			[]string{"2001:db8::1", "2001:db8::2"},
		)
		want := []string{"localhost"}
		if strings.Join(hosts, ",") != strings.Join(want, ",") {
			t.Fatalf("hosts = %#v, want %#v", hosts, want)
		}
	})

	t.Run("explicit loopback hosts collapse to localhost", func(t *testing.T) {
		tests := []struct {
			name      string
			hostInput string
		}{
			{name: "ipv6 loopback", hostInput: "::1"},
			{name: "ipv4 loopback", hostInput: "127.0.0.1"},
			{name: "localhost", hostInput: "localhost"},
		}

		for _, tt := range tests {
			t.Run(tt.name, func(t *testing.T) {
				hosts := launcherConsoleHostsWithLocalAddrs(
					tt.hostInput,
					false,
					[]string{"192.168.1.2", "10.0.0.8"},
					[]string{"2001:db8::1", "2001:db8::2"},
				)
				want := []string{"localhost"}
				if strings.Join(hosts, ",") != strings.Join(want, ",") {
					t.Fatalf("hosts = %#v, want %#v", hosts, want)
				}
			})
		}
	})

	t.Run("public wildcard shows localhost then ipv6 and ipv4", func(t *testing.T) {
		hosts := launcherConsoleHostsWithLocalAddrs(
			"",
			true,
			[]string{"192.168.1.2", "10.0.0.8"},
			[]string{"2001:db8::1", "2001:db8::2"},
		)
		want := []string{"localhost", "2001:db8::1", "2001:db8::2", "192.168.1.2", "10.0.0.8"}
		if strings.Join(hosts, ",") != strings.Join(want, ",") {
			t.Fatalf("hosts = %#v, want %#v", hosts, want)
		}
	})

	t.Run("explicit ipv6 any shows localhost then ipv6 variants", func(t *testing.T) {
		hosts := launcherConsoleHostsWithLocalAddrs(
			"::",
			false,
			[]string{"192.168.1.2", "10.0.0.8"},
			[]string{"2001:db8::1", "2001:db8::2"},
		)
		want := []string{"localhost", "2001:db8::1", "2001:db8::2"}
		if strings.Join(hosts, ",") != strings.Join(want, ",") {
			t.Fatalf("hosts = %#v, want %#v", hosts, want)
		}

		for _, host := range hosts {
			if host == "::1" || host == "127.0.0.1" || strings.HasPrefix(strings.ToLower(host), "fe80:") {
				t.Fatalf("hosts = %#v, loopback IPs must not be displayed", hosts)
			}
		}
	})

	t.Run("explicit ipv4 any shows localhost then lan ipv4", func(t *testing.T) {
		hosts := launcherConsoleHostsWithLocalAddrs(
			"0.0.0.0",
			false,
			[]string{"192.168.1.2", "10.0.0.8"},
			[]string{"2001:db8::1", "2001:db8::2"},
		)
		want := []string{"localhost", "192.168.1.2", "10.0.0.8"}
		if strings.Join(hosts, ",") != strings.Join(want, ",") {
			t.Fatalf("hosts = %#v, want %#v", hosts, want)
		}
	})

	t.Run("explicit wildcard star shows localhost first", func(t *testing.T) {
		hosts := launcherConsoleHostsWithLocalAddrs(
			"*",
			false,
			[]string{"192.168.1.2", "10.0.0.8"},
			[]string{"2001:db8::1", "2001:db8::2"},
		)
		want := []string{"localhost", "2001:db8::1", "2001:db8::2", "192.168.1.2", "10.0.0.8"}
		if strings.Join(hosts, ",") != strings.Join(want, ",") {
			t.Fatalf("hosts = %#v, want %#v", hosts, want)
		}
	})

	t.Run("explicit multi-address binding without local tokens hides localhost", func(t *testing.T) {
		hosts := launcherConsoleHostsWithLocalAddrs(
			"192.168.1.2,10.0.0.8,2001:db8::1,2001:db8::2,fe80::1",
			false,
			[]string{"192.168.1.2", "10.0.0.8"},
			[]string{"2001:db8::1", "2001:db8::2"},
		)
		want := []string{"192.168.1.2", "10.0.0.8", "2001:db8::1", "2001:db8::2"}
		if strings.Join(hosts, ",") != strings.Join(want, ",") {
			t.Fatalf("hosts = %#v, want %#v", hosts, want)
		}
	})
}

func TestWildcardAdvertiseIP(t *testing.T) {
	tests := []struct {
		name      string
		bindHosts []string
		ipv4      string
		ipv6      string
		want      string
	}{
		{
			name:      "ipv4 wildcard uses ipv4",
			bindHosts: []string{"0.0.0.0"},
			ipv4:      "192.168.1.2",
			ipv6:      "2001:db8::1",
			want:      "192.168.1.2",
		},
		{
			name:      "dual wildcard prefers ipv6",
			bindHosts: []string{"0.0.0.0", "::"},
			ipv4:      "192.168.1.2",
			ipv6:      "2001:db8::1",
			want:      "2001:db8::1",
		},
		{
			name:      "ipv6 wildcard uses ipv6",
			bindHosts: []string{"::"},
			ipv4:      "192.168.1.2",
			ipv6:      "2001:db8::1",
			want:      "2001:db8::1",
		},
		{
			name:      "dual wildcard falls back to ipv4 when ipv6 missing",
			bindHosts: []string{"0.0.0.0", "::"},
			ipv4:      "192.168.1.2",
			ipv6:      "",
			want:      "192.168.1.2",
		},
		{
			name:      "ipv6 wildcard without ipv6 does not advertise ipv4",
			bindHosts: []string{"::"},
			ipv4:      "192.168.1.2",
			ipv6:      "",
			want:      "",
		},
		{
			name:      "non wildcard does not advertise",
			bindHosts: []string{"127.0.0.1"},
			ipv4:      "192.168.1.2",
			ipv6:      "2001:db8::1",
			want:      "",
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if got := wildcardAdvertiseIP(tt.bindHosts, tt.ipv4, tt.ipv6); got != tt.want {
				t.Fatalf("wildcardAdvertiseIP(%#v, %q, %q) = %q, want %q", tt.bindHosts, tt.ipv4, tt.ipv6, got, tt.want)
			}
		})
	}
}

func TestOpenLauncherListeners_HonorsIPv6OnlyHost(t *testing.T) {
	hasIPv4, hasIPv6 := netbind.DetectIPFamilies()
	if !hasIPv6 {
		t.Skip("IPv6 is unavailable in this environment")
	}

	result, err := openLauncherListeners("::", false, "0")
	if err != nil {
		t.Fatalf("openLauncherListeners() error = %v", err)
	}
	startLauncherTestHTTPServer(t, result.Listeners)
	port := mustAtoi(t, result.Port)

	requireLauncherHTTPReachable(t, "::1", port)
	if hasIPv4 {
		requireLauncherHTTPUnreachable(t, "127.0.0.1", port)
	}
}

func TestOpenLauncherListeners_SupportsExplicitMultiHost(t *testing.T) {
	hasIPv4, hasIPv6 := netbind.DetectIPFamilies()
	if !hasIPv4 || !hasIPv6 {
		t.Skip("dual-stack loopback is unavailable in this environment")
	}

	result, err := openLauncherListeners("127.0.0.1,::1", false, "0")
	if err != nil {
		t.Fatalf("openLauncherListeners() error = %v", err)
	}
	startLauncherTestHTTPServer(t, result.Listeners)
	port := mustAtoi(t, result.Port)

	requireLauncherHTTPReachable(t, "127.0.0.1", port)
	requireLauncherHTTPReachable(t, "::1", port)
}

func startLauncherTestHTTPServer(t *testing.T, listeners []net.Listener) {
	t.Helper()

	server := &http.Server{
		Handler: http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
			_, _ = io.WriteString(w, "ok")
		}),
	}

	errCh := make(chan error, len(listeners))
	for _, listener := range listeners {
		ln := listener
		go func() {
			errCh <- server.Serve(ln)
		}()
	}

	t.Cleanup(func() {
		ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
		defer cancel()
		_ = server.Shutdown(ctx)
		for range listeners {
			err := <-errCh
			if err != nil && !errors.Is(err, http.ErrServerClosed) {
				t.Fatalf("server.Serve() error = %v", err)
			}
		}
	})
}

func requireLauncherHTTPReachable(t *testing.T, host string, port int) {
	t.Helper()
	deadline := time.Now().Add(2 * time.Second)
	for {
		err := launcherHTTPGet(host, port)
		if err == nil {
			return
		}
		if time.Now().After(deadline) {
			t.Fatalf("expected %s:%d to be reachable: %v", host, port, err)
		}
		time.Sleep(50 * time.Millisecond)
	}
}

func requireLauncherHTTPUnreachable(t *testing.T, host string, port int) {
	t.Helper()
	if err := launcherHTTPGet(host, port); err == nil {
		t.Fatalf("expected %s:%d to be unreachable", host, port)
	}
}

func launcherHTTPGet(host string, port int) error {
	client := &http.Client{
		Timeout: 300 * time.Millisecond,
		Transport: &http.Transport{
			Proxy: nil,
		},
	}

	resp, err := client.Get("http://" + net.JoinHostPort(host, strconv.Itoa(port)))
	if err != nil {
		return err
	}
	defer resp.Body.Close()
	if resp.StatusCode != http.StatusOK {
		return errors.New(resp.Status)
	}
	return nil
}

func mustAtoi(t *testing.T, value string) int {
	t.Helper()
	n, err := strconv.Atoi(value)
	if err != nil {
		t.Fatalf("Atoi(%q) error = %v", value, err)
	}
	return n
}