package tun

import (
	"context"
	"errors"
	"io"
	"sync"
	"syscall"

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

var ErrQueueEmpty = errors.New("queue is empty")

type GVisorDevice interface {
	WritePacket(packet *stack.PacketBuffer) tcpip.Error
	ReadPacket() (byte, *stack.PacketBuffer, error)
	Wait()
}

// LinkEndpoint implements GVisor stack.LinkEndpoint
var _ stack.LinkEndpoint = (*LinkEndpoint)(nil)

type LinkEndpoint struct {
	deviceMTU        uint32
	device           GVisorDevice
	dispatcherCancel context.CancelFunc
	lifecycleMu      sync.Mutex
	readerGeneration uint64
	readerState      ReaderState
}

func (e *LinkEndpoint) MTU() uint32 {
	return e.deviceMTU
}

func (e *LinkEndpoint) SetMTU(_ uint32) {
	// not Implemented, as it is not expected GVisor will be asking tun device to be modified
}

func (e *LinkEndpoint) MaxHeaderLength() uint16 {
	return 0
}

func (e *LinkEndpoint) LinkAddress() tcpip.LinkAddress {
	return ""
}

func (e *LinkEndpoint) SetLinkAddress(_ tcpip.LinkAddress) {
	// not Implemented, as it is not expected GVisor will be asking tun device to be modified
}

func (e *LinkEndpoint) Capabilities() stack.LinkEndpointCapabilities {
	return stack.CapabilityRXChecksumOffload
}

// ReaderState reports only local reader lifecycle, not end-to-end connectivity.
// No packet, address, raw error string, or application traffic is exposed.
type ReaderState struct {
	State     string `json:"state"`
	ErrorKind string `json:"errorKind,omitempty"`
	ErrorCode int    `json:"errorCode,omitempty"`
}

func (e *LinkEndpoint) ReaderState() ReaderState {
	e.lifecycleMu.Lock()
	defer e.lifecycleMu.Unlock()
	if e.readerState.State == "" {
		return ReaderState{State: "unavailable"}
	}
	return e.readerState
}

func (e *LinkEndpoint) Attach(dispatcher stack.NetworkDispatcher) {
	e.lifecycleMu.Lock()
	defer e.lifecycleMu.Unlock()
	if e.dispatcherCancel != nil {
		e.dispatcherCancel()
	}
	e.dispatcherCancel = nil
	e.readerGeneration++
	e.readerState = ReaderState{State: "stopped"}
	if dispatcher != nil {
		ctx, cancel := context.WithCancel(context.Background())
		e.dispatcherCancel = cancel
		e.readerState = ReaderState{State: "running"}
		go e.dispatchLoop(ctx, dispatcher, e.readerGeneration)
	}
}

func (e *LinkEndpoint) IsAttached() bool {
	e.lifecycleMu.Lock()
	defer e.lifecycleMu.Unlock()
	return e.dispatcherCancel != nil
}

func (e *LinkEndpoint) readerFailed(generation uint64, err error) {
	e.lifecycleMu.Lock()
	defer e.lifecycleMu.Unlock()
	// An intentionally stopped or superseded reader cannot overwrite a newer
	// attach/close or request repair of its replacement.
	if generation != e.readerGeneration || e.dispatcherCancel == nil {
		return
	}
	failure := ReaderState{State: "failed", ErrorKind: "other"}
	var errno syscall.Errno
	if errors.Is(err, io.EOF) {
		failure.ErrorKind = "eof"
	} else if errors.As(err, &errno) && errno > 0 && errno < 4096 {
		failure.ErrorKind = "errno"
		failure.ErrorCode = int(errno)
	}
	e.readerState = failure
	e.dispatcherCancel()
	e.dispatcherCancel = nil
}

func (e *LinkEndpoint) Wait() {
}

func (e *LinkEndpoint) ARPHardwareType() header.ARPHardwareType {
	return header.ARPHardwareNone
}

func (e *LinkEndpoint) AddHeader(buffer *stack.PacketBuffer) {
	// tun interface doesn't have link layer header, it will be added by the OS
}

func (e *LinkEndpoint) ParseHeader(ptr *stack.PacketBuffer) bool {
	return true
}

func (e *LinkEndpoint) Close() { e.Attach(nil) }

func (e *LinkEndpoint) SetOnCloseAction(_ func()) {
}

func (e *LinkEndpoint) WritePackets(packetBufferList stack.PacketBufferList) (int, tcpip.Error) {
	var n int
	var err tcpip.Error

	for _, packetBuffer := range packetBufferList.AsSlice() {
		err = e.device.WritePacket(packetBuffer)
		if err != nil {
			return n, &tcpip.ErrAborted{}
		}
		n++
	}

	return n, nil
}

func (e *LinkEndpoint) dispatchLoop(ctx context.Context, dispatcher stack.NetworkDispatcher, generation uint64) {
	var networkProtocolNumber tcpip.NetworkProtocolNumber
	var version byte
	var packet *stack.PacketBuffer
	var err error

	for {
		select {
		case <-ctx.Done():
			return
		default:
			version, packet, err = e.device.ReadPacket()
			// on "queue empty", ask device to yield slightly and continue
			if errors.Is(err, ErrQueueEmpty) {
				e.device.Wait()
				continue
			}
			// stop dispatcher loop on any other interface failure
			if err != nil {
				if ctx.Err() == nil {
					e.readerFailed(generation, err)
				}
				return
			}

			// extract network protocol number from the packet first byte
			// (which is returned separately, since it is so incredibly hard to extract one byte from
			// stack.PacketBuffer without additional memory allocation and full copying it back and forth)
			switch version {
			case 4:
				networkProtocolNumber = header.IPv4ProtocolNumber
			case 6:
				networkProtocolNumber = header.IPv6ProtocolNumber
			default:
				// discard unknown network protocol packet
				packet.DecRef()
				continue
			}

			// dispatch the buffer to the stack
			dispatcher.DeliverNetworkPacket(networkProtocolNumber, packet)
			// signal the buffer that it can be released
			packet.DecRef()
		}
	}
}
