package xray

import (
	"context"
	"encoding/json"
	"strings"
	"testing"

	"github.com/xtls/xray-core/features/inbound"
	"github.com/xtls/xray-core/proxy"
	"github.com/xtls/xray-core/proxy/tun"
)

type stateTestProxy struct {
	proxy.Inbound
	state tun.ReaderState
}

func (p *stateTestProxy) TUNReaderState() tun.ReaderState { return p.state }

type stateTestHandler struct {
	inbound.Handler
	tag string
	in  proxy.Inbound
}

func (h *stateTestHandler) Tag() string               { return h.tag }
func (*stateTestHandler) Start() error                { return nil }
func (*stateTestHandler) Close() error                { return nil }
func (h *stateTestHandler) GetInbound() proxy.Inbound { return h.in }
func TestManagedTUNStateUsesCurrentManagedInstance(t *testing.T) {
	if err := RunXray(probeConfig); err != nil {
		t.Fatal(err)
	}
	defer StopXray()
	manager := coreServer.GetFeature(inbound.ManagerType()).(inbound.Manager)
	handler := &stateTestHandler{tag: "fixture-tun", in: &stateTestProxy{state: tun.ReaderState{State: "failed", ErrorKind: "errno", ErrorCode: 5}}}
	if err := manager.AddHandler(context.Background(), handler); err != nil {
		t.Fatal(err)
	}
	state := GetManagedXrayState()
	if !state.Running || state.TUNReaders["fixture-tun"].State != "failed" {
		t.Fatalf("missing native state %+v", state)
	}
	encoded, err := json.Marshal(state)
	if err != nil || !strings.Contains(string(encoded), `"errorCode":5`) {
		t.Fatal("wrong JSON shape")
	}
	if err = StopXray(); err != nil {
		t.Fatal(err)
	}
	state = GetManagedXrayState()
	if state.Running || len(state.TUNReaders) != 0 {
		t.Fatal("stopped core retained reader failure")
	}
	if err = RunXray(probeConfig); err != nil {
		t.Fatal(err)
	}
	state = GetManagedXrayState()
	if !state.Running || len(state.TUNReaders) != 0 {
		t.Fatal("replacement core inherited old reader failure")
	}
}
func TestManagedTUNStateDoesNotInventFailureForMissingSupport(t *testing.T) {
	if got := managedTUNReaders([]inbound.Handler{&stateTestHandler{tag: "unsupported", in: nil}}); len(got) != 0 {
		t.Fatal("unsupported reader reported")
	}
	if err := RunXray(probeConfig); err != nil {
		t.Fatal(err)
	}
	defer StopXray()
	state := GetManagedXrayState()
	if !state.Running || len(state.TUNReaders) != 0 {
		t.Fatal("ordinary core reported TUN failure")
	}
}
