package rcon

import (
	"bufio"
	"context"
	"encoding/binary"
	"errors"
	"fmt"
	"io"
	"net"
	"strings"
	"sync"
	"time"
)

// SourceDialer speaks Valve's Source RCON protocol — the standard RCON of
// Minecraft, CS2, Rust, Valheim-with-plugins, and most Source-engine games.
//
// Protocol summary (little-endian throughout):
//
//	int32 size            = bytes that follow (i.e. frame length − 4)
//	int32 id              = client-chosen, server echoes
//	int32 type            = 3 auth-request, 2 exec, 0 response, 2 auth-response
//	body  ASCIIZ          = command string or response body, null-terminated
//	byte  trailing null   = required empty string sentinel
//
// size = 4 (id) + 4 (type) + len(body) + 1 (body NUL) + 1 (sentinel NUL)
type SourceDialer struct{}

// Name identifies this adapter in the module manifest.
func (SourceDialer) Name() string { return "source_rcon" }

const (
	pktAuth          int32 = 3
	pktExecCommand   int32 = 2
	pktResponseValue int32 = 0
	pktAuthResponse  int32 = 2

	minPktSize = 10
	maxPktSize = 4110
)

func (SourceDialer) Dial(ctx context.Context, opts DialOptions) (Client, error) {
	if opts.Host == "" || opts.Port == 0 {
		return nil, errors.New("source rcon dial: host and port are required")
	}
	timeout := opts.ConnectTimeout
	if timeout == 0 {
		timeout = 5 * time.Second
	}
	d := &net.Dialer{Timeout: timeout}
	conn, err := d.DialContext(ctx, "tcp", fmt.Sprintf("%s:%d", opts.Host, opts.Port))
	if err != nil {
		return nil, fmt.Errorf("source rcon dial %s:%d: %w", opts.Host, opts.Port, err)
	}
	c := &sourceClient{conn: conn, reader: bufio.NewReader(conn), nextID: 1}
	if err := c.authenticate(opts.Password); err != nil {
		_ = conn.Close()
		return nil, fmt.Errorf("source rcon auth: %w", err)
	}
	return c, nil
}

type sourceClient struct {
	conn   net.Conn
	reader *bufio.Reader

	mu     sync.Mutex
	nextID int32
}

// authenticate sends SERVERDATA_AUTH and waits for SERVERDATA_AUTH_RESPONSE.
// Valve's spec says servers send an empty RESPONSE_VALUE first (id echoed),
// then the AUTH_RESPONSE (id = original on success, −1 on failure). Some
// implementations skip the probe — we accept either ordering.
func (c *sourceClient) authenticate(password string) error {
	id := c.assignID()
	if err := c.writePacket(id, pktAuth, password); err != nil {
		return err
	}
	// ASA's RCON handler is slow to answer AUTH during the first few
	// minutes after "Server has completed startup" — sometimes 3-4s per
	// reply when the server is still loading tribe data / saving a
	// snapshot. The previous 2s per-read deadline + 5s overall was
	// tripping the tracker into its 32s exponential backoff on every
	// auth, stranding the panel with "RCON not yet connected" for 5-10
	// min even though the server was otherwise fine. Give AUTH a 12s
	// outer window and 8s per-read — enough slack for ASA's slowest
	// responses without letting a truly dead connection hang forever.
	deadline := time.Now().Add(12 * time.Second)
	for time.Now().Before(deadline) {
		_ = c.conn.SetReadDeadline(time.Now().Add(8 * time.Second))
		gotID, gotType, _, err := c.readPacket()
		if err != nil {
			return err
		}
		if gotType == pktAuthResponse {
			// Spec: id == -1 means auth failed (bad password).
			// Any other id means success. Most servers echo our request id
			// but some (Conan Exiles, Palworld, a few others) return 0 or
			// an unrelated id — treat that as success, don't reject.
			if gotID == -1 {
				return errors.New("invalid password")
			}
			return nil
		}
		// Probe echo (RESPONSE_VALUE with body ""), keep reading for the
		// AUTH_RESPONSE that follows.
	}
	return errors.New("auth timeout")
}

// Exec sends a SERVERDATA_EXECCOMMAND and concatenates RESPONSE_VALUE bodies
// until the server goes silent. For responses that straddle multiple packets
// the spec recommends a "bogus packet trick" (send a second empty packet and
// watch for its echo) but short command output fits in one packet in practice.
func (c *sourceClient) Exec(ctx context.Context, cmd string) (string, error) {
	c.mu.Lock()
	defer c.mu.Unlock()

	if dl, ok := ctx.Deadline(); ok {
		_ = c.conn.SetDeadline(dl)
		defer c.conn.SetDeadline(time.Time{}) //nolint:errcheck
	}

	id := c.assignID()
	if err := c.writePacket(id, pktExecCommand, cmd); err != nil {
		return "", fmt.Errorf("write: %w", err)
	}

	var out strings.Builder
	// First read waits longer — some servers (Palworld especially) take 1–3s
	// to build the response for commands like ShowPlayers. Subsequent reads
	// use a tight idle timeout so we exit promptly once the stream goes quiet.
	const (
		firstTimeout = 5 * time.Second
		idleTimeout  = 800 * time.Millisecond
	)
	readDeadline := firstTimeout
	for {
		_ = c.conn.SetReadDeadline(time.Now().Add(readDeadline))
		readDeadline = idleTimeout
		gotID, gotType, body, err := c.readPacket()
		if err != nil {
			var ne net.Error
			if errors.As(err, &ne) && ne.Timeout() && out.Len() > 0 {
				return out.String(), nil
			}
			if errors.Is(err, io.EOF) && out.Len() > 0 {
				return out.String(), nil
			}
			return out.String(), err
		}
		// Source RCON spec says the server MUST echo our request id on
		// RESPONSE_VALUE. Palworld always returns id=0; Conan Exiles
		// returns a different arbitrary id. We hold mu.Lock() for the
		// whole Exec so only one command is ever in flight — ID matching
		// isn't needed for correctness, so accept any id the server
		// hands us (except -1, which is reserved for auth failures).
		if gotID == -1 {
			continue
		}
		// Spec: RESPONSE_VALUE (type 0) carries command output. Conan
		// Exiles sends command output via AUTH_RESPONSE (type 2) instead —
		// non-spec but functional. We're past the auth phase by this point
		// so accepting either type is safe; anything else we skip.
		if gotType != pktResponseValue && gotType != pktAuthResponse {
			continue
		}
		out.WriteString(body)
		// Body shorter than ~4000 bytes → likely single-packet response.
		if len(body) < 3800 {
			return out.String(), nil
		}
	}
}

// Close shuts down the underlying TCP connection.
func (c *sourceClient) Close() error { return c.conn.Close() }

func (c *sourceClient) assignID() int32 {
	c.nextID++
	if c.nextID <= 0 {
		c.nextID = 1
	}
	return c.nextID
}

// writePacket wire-encodes a Source RCON packet.
func (c *sourceClient) writePacket(id, ptype int32, body string) error {
	bodyBytes := []byte(body)
	pktSize := int32(4 + 4 + len(bodyBytes) + 2) // id + type + body + 2×NUL
	if pktSize > maxPktSize {
		return fmt.Errorf("source rcon: body too large (%d bytes, max %d)", len(bodyBytes), maxPktSize-10)
	}
	buf := make([]byte, 4+pktSize)
	binary.LittleEndian.PutUint32(buf[0:4], uint32(pktSize))
	binary.LittleEndian.PutUint32(buf[4:8], uint32(id))
	binary.LittleEndian.PutUint32(buf[8:12], uint32(ptype))
	copy(buf[12:], bodyBytes)
	// trailing two NUL bytes already zero
	_, err := c.conn.Write(buf)
	return err
}

// readPacket reads one framed Source RCON packet from the underlying reader.
// Returns (id, type, body, err). Body has trailing NULs stripped.
func (c *sourceClient) readPacket() (int32, int32, string, error) {
	var sizeBuf [4]byte
	if _, err := io.ReadFull(c.reader, sizeBuf[:]); err != nil {
		return 0, 0, "", err
	}
	size := int32(binary.LittleEndian.Uint32(sizeBuf[:]))
	if size < minPktSize || size > maxPktSize {
		return 0, 0, "", fmt.Errorf("source rcon: bogus packet size %d", size)
	}
	rest := make([]byte, size)
	if _, err := io.ReadFull(c.reader, rest); err != nil {
		return 0, 0, "", err
	}
	id := int32(binary.LittleEndian.Uint32(rest[0:4]))
	ptype := int32(binary.LittleEndian.Uint32(rest[4:8]))
	bodyEnd := size - 2 // trim both trailing NULs
	if bodyEnd < 8 {
		bodyEnd = 8
	}
	body := string(rest[8:bodyEnd])
	return id, ptype, body, nil
}