package display

import (
	"context"
	"errors"
	"strings"
	"testing"
	"time"

	"github.com/BurntSushi/xgb"
	"github.com/BurntSushi/xgb/xproto"
)

func TestConfirmMappedSucceedsWhenLivenessReplySucceeds(t *testing.T) {
	// Open's post-map liveness stage must succeed when the reply-bearing
	// round trip succeeds, so the mapped window proceeds to a live session.
	probes := 0
	probe := func() error {
		probes++
		return nil
	}

	if err := confirmMapped(probe); err != nil {
		t.Fatalf("confirmMapped=%v want success when the liveness reply arrives", err)
	}
	if probes != 1 {
		t.Fatalf("probes=%d want exactly one liveness round trip", probes)
	}
}

func TestConfirmMappedWrapsLivenessFailureForMappedWindowCleanup(t *testing.T) {
	sentinel := errors.New("connection reset")
	err := confirmMapped(func() error { return sentinel })
	if err == nil {
		t.Fatal("confirmMapped must propagate a failed liveness round trip")
	}
	if !strings.Contains(err.Error(), "map kiosk window") {
		t.Fatalf("error %v must be wrapped as the map-kiosk-window failure so Open closes the connection", err)
	}
	if !errors.Is(err, sentinel) {
		t.Fatalf("error %v must carry the underlying liveness error", err)
	}
}

func TestX11SessionWaitEventKeepsPollingWhileLivenessRepliesSucceed(t *testing.T) {
	probes := 0
	session := &x11Session{
		poll: time.Millisecond,
		pollEvent: func() (xgb.Event, xgb.Error) {
			return nil, nil
		},
		probe: func() error {
			probes++
			return nil
		},
	}

	ctx, cancel := context.WithTimeout(context.Background(), 20*time.Millisecond)
	defer cancel()
	_, err := session.WaitEvent(ctx)
	if !errors.Is(err, context.DeadlineExceeded) {
		t.Fatalf("WaitEvent=%v want clean cancellation while liveness replies succeed", err)
	}
	if probes == 0 {
		t.Fatal("WaitEvent must perform liveness round trips while idle")
	}
}

func TestX11SessionWaitEventPropagatesLivenessError(t *testing.T) {
	sentinel := errors.New("X server went away")
	session := &x11Session{
		poll:      time.Millisecond,
		pollEvent: func() (xgb.Event, xgb.Error) { return nil, nil },
		probe:     func() error { return sentinel },
	}

	// The propagated error is what makes Run close the mapped window and
	// reconnect, keeping the failure contained in the display loop.
	_, err := session.WaitEvent(context.Background())
	if !errors.Is(err, sentinel) {
		t.Fatalf("WaitEvent=%v want the underlying liveness error", err)
	}
}

func TestX11SessionWaitEventStillHandlesEventsBeforeLiveness(t *testing.T) {
	session := &x11Session{
		poll: time.Millisecond,
		pollEvent: func() (xgb.Event, xgb.Error) {
			return xproto.ExposeEvent{}, nil
		},
		probe: func() error {
			t.Fatal("liveness must not run when an event is already handled")
			return nil
		},
	}

	redraw, err := session.WaitEvent(context.Background())
	if err != nil {
		t.Fatalf("WaitEvent=%v", err)
	}
	if !redraw {
		t.Fatal("an expose event must request a redraw")
	}
}

// TestResolveLivenessWaitsForReplyOnReplyBearingCookie is the behavioral
// guard for the hardware-proven root cause. GetInputFocus issues a
// reply-bearing cookie (NewCookie(true, true)); resolveLiveness must
// consume it with Reply — meaning it blocks awaiting the server's reply —
// never with Check, which would return the XGB reply-cookie error on every
// call regardless of server health. A reply-bearing cookie can be built
// without a server because xgb's NewCookie does not touch the connection.
func TestResolveLivenessWaitsForReplyOnReplyBearingCookie(t *testing.T) {
	conn := &xgb.Conn{}
	cookie := xproto.GetInputFocusCookie{Cookie: conn.NewCookie(true, true)}

	done := make(chan error, 1)
	go func() { done <- resolveLiveness(cookie) }()
	select {
	case err := <-done:
		t.Fatalf("resolveLiveness returned %v without any server reply; the cookie was not resolved with Reply", err)
	case <-time.After(100 * time.Millisecond):
		// Still waiting for the reply: Reply-resolution semantics intact.
	}
}

// TestCheckOnReplyBearingCookieIsTheDeviceRootCause pins the exact xgb
// behavior the fix depends on, using the real cookie API: Check on a
// reply-bearing cookie returns the device-proven error immediately, while
// Reply is the only resolution that waits for the server. This is the
// behavioral contrast proving connLivenessProbe/resolveLiveness cannot
// reintroduce the open_failed reconnect loop.
func TestCheckOnReplyBearingCookieIsTheDeviceRootCause(t *testing.T) {
	conn := &xgb.Conn{}
	cookie := xproto.GetInputFocusCookie{Cookie: conn.NewCookie(true, true)}

	err := cookie.Check()
	if err == nil {
		t.Fatal("Check on a reply-bearing cookie must fail; the device root cause would be reintroduced")
	}
	const deviceError = "Cannot call 'Check' on a cookie that is expecting a *reply*. Use 'Reply' instead."
	if err.Error() != deviceError {
		t.Fatalf("Check error=%q want the device-proven %q", err.Error(), deviceError)
	}
}