package tun

import (
	"errors"
	"io"
	"os"
	"sync"
	"sync/atomic"
	"syscall"
	"testing"
	"time"

	"gvisor.dev/gvisor/pkg/buffer"
	"gvisor.dev/gvisor/pkg/tcpip"
	"gvisor.dev/gvisor/pkg/tcpip/stack"
)

type readerTestEvent struct {
	err    error
	packet bool
}
type readerTestDevice struct {
	events chan readerTestEvent
	reads  atomic.Int32
}

func (d *readerTestDevice) WritePacket(*stack.PacketBuffer) tcpip.Error { return nil }
func (d *readerTestDevice) ReadPacket() (byte, *stack.PacketBuffer, error) {
	select {
	case event := <-d.events:
		d.reads.Add(1)
		if event.err != nil {
			return 0, nil, event.err
		}
		return 4, stack.NewPacketBuffer(stack.PacketBufferOptions{Payload: buffer.MakeWithData([]byte{0x45})}), nil
	default:
		return 0, nil, ErrQueueEmpty
	}
}
func (*readerTestDevice) Wait() { time.Sleep(time.Millisecond) }

type readerTestDispatcher struct{ delivered atomic.Int32 }

func (d *readerTestDispatcher) DeliverNetworkPacket(tcpip.NetworkProtocolNumber, *stack.PacketBuffer) {
	d.delivered.Add(1)
}
func (*readerTestDispatcher) DeliverLinkPacket(tcpip.NetworkProtocolNumber, *stack.PacketBuffer) {}
func waitReaderTest(t *testing.T, condition func() bool) {
	t.Helper()
	deadline := time.Now().Add(time.Second)
	for !condition() {
		if time.Now().After(deadline) {
			t.Fatal("timed out")
		}
		time.Sleep(time.Millisecond)
	}
}
func TestTivraReaderFailureReportedWithoutBlindRetry(t *testing.T) {
	for _, test := range []struct {
		name string
		err  error
		kind string
		code int
	}{
		{"errno", &os.PathError{Op: "read", Path: "private-descriptor", Err: syscall.EIO}, "errno", int(syscall.EIO)},
		{"eof", io.EOF, "eof", 0}, {"unknown", errors.New("sensitive underlying error"), "other", 0},
	} {
		t.Run(test.name, func(t *testing.T) {
			device := &readerTestDevice{events: make(chan readerTestEvent, 4)}
			dispatcher := &readerTestDispatcher{}
			endpoint := &LinkEndpoint{device: device}
			defer endpoint.Close()
			endpoint.Attach(dispatcher)
			device.events <- readerTestEvent{err: test.err}
			device.events <- readerTestEvent{packet: true}
			waitReaderTest(t, func() bool { return endpoint.ReaderState().State == "failed" })
			got := endpoint.ReaderState()
			if got.ErrorKind != test.kind || got.ErrorCode != test.code || endpoint.IsAttached() || device.reads.Load() != 1 {
				t.Fatalf("incorrect failure snapshot %+v reads=%d", got, device.reads.Load())
			}
			endpoint.Attach(dispatcher)
			waitReaderTest(t, func() bool { return dispatcher.delivered.Load() == 1 })
			if endpoint.ReaderState().State != "running" {
				t.Fatal("new reader inherited failure")
			}
			endpoint.Close()
			if endpoint.ReaderState().State != "stopped" {
				t.Fatal("intentional close marked failure")
			}
		})
	}
}
func TestTivraReaderLateFailureCannotOverwriteReplacementOrStop(t *testing.T) {
	device := &readerTestDevice{events: make(chan readerTestEvent, 4)}
	endpoint := &LinkEndpoint{device: device}
	defer endpoint.Close()
	endpoint.Attach(&readerTestDispatcher{})
	endpoint.lifecycleMu.Lock()
	old := endpoint.readerGeneration
	endpoint.lifecycleMu.Unlock()
	endpoint.Attach(&readerTestDispatcher{})
	endpoint.readerFailed(old, syscall.EIO)
	if endpoint.ReaderState().State != "running" {
		t.Fatal("late failure overwrote replacement")
	}
	endpoint.Close()
	endpoint.readerFailed(old+1, syscall.EIO)
	if endpoint.ReaderState().State != "stopped" {
		t.Fatal("late failure overwrote stop")
	}
}
func TestTivraReaderLifecycleConcurrentSnapshots(t *testing.T) {
	endpoint := &LinkEndpoint{device: &readerTestDevice{events: make(chan readerTestEvent, 4)}}
	defer endpoint.Close()
	var workers sync.WaitGroup
	for i := 0; i < 8; i++ {
		workers.Add(1)
		go func() {
			defer workers.Done()
			for j := 0; j < 100; j++ {
				endpoint.Attach(&readerTestDispatcher{})
				_ = endpoint.ReaderState()
				_ = endpoint.IsAttached()
				endpoint.Close()
			}
		}()
	}
	workers.Wait()
	if endpoint.ReaderState().State != "stopped" {
		t.Fatal("not stopped")
	}
}
