utils

func PrintStartupInfo(port, httpsPort, localIP string, host bool)

{
	fmt.Println(indent, boldRed("rfw"), faint(core.Version))
	fmt.Println()
	fmt.Println(indent, red("➜ "), bold("Local:"), red(fmt.Sprintf("http://localhost:%s/ - https://localhost:%s/", port, httpsPort)))

	if host {
		fmt.Println(indent, red("➜ "), faint(bold("Network:")), white(fmt.Sprintf("http://%s:%s/ (https://%s:%s/)", localIP, port, localIP, httpsPort)))
	} else {
		fmt.Println(indent, red("➜ "), faint(bold("Network:")), white("--host"), faint("to expose"))
	}

	fmt.Println(indent, faintRed("➜ "), faint("Press"), bold("h + enter"), faint("to show help"))
	fmt.Println()
}

func PrintHelp()

{
	ClearScreen()
	fmt.Println()
	fmt.Println(indent, red("➜ "), bold("Help"))
	fmt.Println(indent, indent, yellow("➜ "), bold("Shortcuts"))
	fmt.Println(indent, indent, indent, faint("Press"), bold("c + enter"), faint("to stop the server"))
	fmt.Println(indent, indent, indent, faint("Press"), bold("o + enter"), faint("to open the browser"))
	fmt.Println(indent, indent, indent, faint("Press"), bold("u + enter"), faint("to show the startup info and clear logs"))
	fmt.Println(indent, indent, indent, faint("Press"), bold("h + enter"), faint("to show this help"))
	fmt.Println(indent, indent, yellow("➜ "), bold("Flags"))
	fmt.Println(indent, indent, indent, faint("Use"), bold("--host"), faint("to expose the server to the network"))
	fmt.Println(indent, indent, indent, faint("Use"), bold("--port=XXXX"), faint("to specify a port"))
	fmt.Println()
}

func fetchLatestVersion() (string, error)

{
	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
	defer cancel()

	req, err := http.NewRequestWithContext(ctx, "GET", "https://api.github.com/repos/"+githubRepo+"/releases/latest", nil)
	if err != nil {
		return "", err
	}
	req.Header.Set("Accept", "application/vnd.github+json")

	client := &http.Client{Transport: &http.Transport{
		DialContext: func(ctx context.Context, network, addr string) (net.Conn, error) {
			return net.DialTimeout(network, addr, 3*time.Second)
		},
	}}
	resp, err := client.Do(req)
	if err != nil {
		return "", err
	}
	defer resp.Body.Close()

	if resp.StatusCode != 200 {
		return "", fmt.Errorf("status %d", resp.StatusCode)
	}

	body, err := io.ReadAll(resp.Body)
	if err != nil {
		return "", err
	}

	var release githubRelease
	if err := json.Unmarshal(body, &release); err != nil {
		return "", err
	}
	return release.TagName, nil
}

func shouldCheckUpdate() bool

{
	home, err := os.UserHomeDir()
	if err != nil {
		return true
	}
	path := home + "/" + checkFile
	info, err := os.Stat(path)
	if err != nil {
		return true
	}
	return time.Since(info.ModTime()) > checkInterval
}

func isNewer(current, latest string) bool

{
	c := strings.TrimPrefix(current, "v")
	l := strings.TrimPrefix(latest, "v")
	if c == "" || l == "" {
		return false
	}
	partsC := strings.SplitN(c, ".", 3)
	partsL := strings.SplitN(l, ".", 3)
	for i := 0; i < 3; i++ {
		if i >= len(partsC) || i >= len(partsL) {
			break
		}
		if partsL[i] > partsC[i] {
			return true
		}
		if partsL[i] < partsC[i] {
			return false
		}
	}
	return false
}

func downloadAndReplace(assetURL string) error

{
	tmp, err := os.CreateTemp("", "rfw-update-*")
	if err != nil {
		return err
	}
	tmp.Close()
	defer os.Remove(tmp.Name())

	ctx, cancel := context.WithTimeout(context.Background(), 60*time.Second)
	defer cancel()

	req, err := http.NewRequestWithContext(ctx, "GET", assetURL, nil)
	if err != nil {
		return err
	}

	resp, err := http.DefaultClient.Do(req)
	if err != nil {
		return err
	}
	defer resp.Body.Close()

	if resp.StatusCode != 200 {
		return fmt.Errorf("download failed: status %d", resp.StatusCode)
	}

	if _, err := io.Copy(tmp, resp.Body); err != nil {
		return err
	}

	exePath, err := os.Executable()
	if err != nil {
		return err
	}

	if err := os.Chmod(tmp.Name(), 0755); err != nil {
		return err
	}

	if err := os.Rename(tmp.Name(), exePath); err != nil {
		return os.WriteFile(exePath, mustReadFile(tmp.Name()), 0755)
	}

	return nil
}

func CheckForUpdate()

{
	if !shouldCheckUpdate() {
		return
	}

	latest, err := fetchLatestVersion()
	if err != nil {
		return
	}
	markChecked()

	if !isNewer(core.Version, latest) {
		return
	}

	assetName := getAssetName()
	fmt.Println()
	Info(fmt.Sprintf("Update available: %s → %s", faint(core.Version), boldCyan(latest)))

	fmt.Print(indent, red("➜ "), bold("Update now? [y/N] "))
	var answer string
	fmt.Scanln(&answer)
	answer = strings.TrimSpace(strings.ToLower(answer))
	if answer != "y" && answer != "yes" {
		fmt.Println(indent, faint("Skipped."))
		return
	}

	assetURL := ""
	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
	defer cancel()

	req, _ := http.NewRequestWithContext(ctx, "GET", "https://api.github.com/repos/"+githubRepo+"/releases/latest", nil)
	req.Header.Set("Accept", "application/vnd.github+json")
	resp, err := http.DefaultClient.Do(req)
	if err != nil {
		Info("Failed to fetch release info")
		return
	}
	defer resp.Body.Close()
	body, _ := io.ReadAll(resp.Body)
	var release githubRelease
	json.Unmarshal(body, &release)

	for _, a := range release.Assets {
		if a.Name == assetName {
			assetURL = a.BrowserDownloadURL
			break
		}
	}
	if assetURL == "" {
		Info(fmt.Sprintf("No binary found for %s/%s", runtime.GOOS, runtime.GOARCH))
		return
	}

	Info("Downloading...")
	if err := downloadAndReplace(assetURL); err != nil {
		Info(fmt.Sprintf("Update failed: %v", err))
		return
	}

	Info(fmt.Sprintf("Updated to %s!", latest))
}

func captureOutput(f func()) string

{
	orig := os.Stdout
	r, w, _ := os.Pipe()
	os.Stdout = w
	f()
	w.Close()
	os.Stdout = orig
	var buf bytes.Buffer
	_, _ = io.Copy(&buf, r)
	return buf.String()
}

func TestDebug(t *testing.T)

{
	EnableDebug(true)
	out := captureOutput(func() { Debug("hello") })
	if !strings.Contains(out, "[rfw][debug]") {
		t.Fatalf("expected debug output, got %q", out)
	}

	EnableDebug(false)
	out = captureOutput(func() { Debug("no output") })
	if out != "" {
		t.Fatalf("expected no output, got %q", out)
	}
}

func TestPrintStartupInfo(t *testing.T)

{
	out := captureOutput(func() { PrintStartupInfo("8080", "8443", "192.168.0.1", true) })
	if !strings.Contains(out, "http://localhost:8080/") {
		t.Fatalf("expected local URL in output, got %q", out)
	}
	if !strings.Contains(out, "http://192.168.0.1:8080/") {
		t.Fatalf("expected network URL, got %q", out)
	}
	out = captureOutput(func() { PrintStartupInfo("8080", "8443", "", false) })
	if !strings.Contains(out, "--host") {
		t.Fatalf("expected hint about --host, got %q", out)
	}
}

func GetLocalIP() (string, error)

{
	addrs, err := net.InterfaceAddrs()
	if err != nil {
		return "", err
	}

	for _, addr := range addrs {
		if ipNet, ok := addr.(*net.IPNet); ok && !ipNet.IP.IsLoopback() && ipNet.IP.To4() != nil {
			return ipNet.IP.String(), nil
		}
	}

	return "", fmt.Errorf("no local IP address found")
}