package engine

import (
	"context"
	"net"
	"testing"

	"git.difuse.io/Difuse/Mellaris/io"
)

type recordingPacket struct {
	streamID uint32
	data     []byte
}

func (p recordingPacket) StreamID() uint32 { return p.streamID }
func (p recordingPacket) Data() []byte     { return p.data }

type recordingPacketIO struct {
	verdict io.Verdict
}

func (r *recordingPacketIO) Register(context.Context, io.PacketCallback) error { return nil }
func (r *recordingPacketIO) SetVerdict(_ io.Packet, v io.Verdict, _ []byte) error {
	r.verdict = v
	return nil
}
func (r *recordingPacketIO) ProtectedDialContext(context.Context, string, string) (net.Conn, error) {
	return nil, nil
}
func (r *recordingPacketIO) Close() error { return nil }

func TestEngineDefaultOverflowPolicyAccepts(t *testing.T) {
	packetIO := &recordingPacketIO{}
	eng, err := NewEngine(Config{
		Logger:          noopTestLogger{},
		IO:              packetIO,
		Workers:         1,
		WorkerQueueSize: 1,
	})
	if err != nil {
		t.Fatalf("NewEngine error: %v", err)
	}
	e := eng.(*engine)
	if e.overflowPolicy != OverflowPolicyAccept {
		t.Fatalf("overflow policy=%v want=%v", e.overflowPolicy, OverflowPolicyAccept)
	}

	e.workers[0].packetChan <- &workerPacket{}
	packet := recordingPacket{
		streamID: 1,
		data: serializeIPv6TCP(
			t,
			net.ParseIP("2001:db8::11").To16(),
			net.ParseIP("2001:db8::22").To16(),
			42310,
			443,
			1000,
		),
	}

	e.dispatch(packet)
	stats := e.Stats()
	if packetIO.verdict != io.VerdictAccept {
		t.Fatalf("overflow verdict=%v want=%v", packetIO.verdict, io.VerdictAccept)
	}
	if stats.OverflowEvents != 1 || stats.OverflowAccepts != 1 || stats.OverflowDrops != 0 {
		t.Fatalf("overflow stats=%+v", stats)
	}
}