//go:build linux

package netlink

import (
	"fmt"
	"io"
	"log"
	"os"
	"strconv"
	"strings"
	"syscall"
	"unsafe"

	"github.com/mdlayher/netlink/nlenc"
	"golang.org/x/sys/unix"
)

// newDebugger creates a debugger by parsing key=value arguments.
func newDebugger(args []string) *debugger {
	d := &debugger{
		Log:    log.New(os.Stderr, "nl: ", 0),
		Level:  1,
		Format: "mnl",
	}
	for _, a := range args {
		kv := strings.Split(a, "=")
		if len(kv) != 2 {
			continue
		}
		switch kv[0] {
		case "level":
			level, err := strconv.Atoi(kv[1])
			if err != nil {
				panicf("netlink: invalid NLDEBUG level: %q", a)
			}
			d.Level = level
		case "format":
			d.Format = kv[1]
		}
	}
	return d
}

// debugf prints debugging information at the specified level, if d.Level is high enough to print the message.
func (d *debugger) debugf(level int, format string, v ...interface{}) {
	if d.Level < level {
		return
	}
	switch d.Format {
	case "mnl":
		colorize := true
		_, err := unix.IoctlGetWinsize(int(os.Stdout.Fd()), unix.TIOCGWINSZ)
		if err != nil {
			colorize = false
		}
		for _, iface := range v {
			if msg, ok := iface.(Message); ok {
				nlmsgFprintf(d.Log.Writer(), msg, colorize)
			} else {
				d.Log.Printf(format, v...)
			}
		}
	default:
		d.Log.Printf(format, v...)
	}
}

// nlmsgFprintfHeader prints the netlink message header to fd.
func nlmsgFprintfHeader(fd io.Writer, nlh Header) {
	fmt.Fprintf(fd, "----------------\t------------------\n")
	fmt.Fprintf(fd, "|  %010d  |\t| message length |\n", nlh.Length)
	fmt.Fprintf(fd, "| %05d | %s%s%s%s |\t|  type | flags  |\n",
		nlh.Type,
		ternary(nlh.Flags&Request != 0, "R", "-"),
		ternary(nlh.Flags&Multi != 0, "M", "-"),
		ternary(nlh.Flags&Acknowledge != 0, "A", "-"),
		ternary(nlh.Flags&Echo != 0, "E", "-"),
	)
	fmt.Fprintf(fd, "|  %010d  |\t| sequence number|\n", nlh.Sequence)
	fmt.Fprintf(fd, "|  %010d  |\t|     port ID    |\n", nlh.PID)
	fmt.Fprintf(fd, "----------------\t------------------\n")
}

// nlmsgFprintf prints a single Message for netlink errors and attributes.
func nlmsgFprintf(fd io.Writer, m Message, colorize bool) {
	var hasHeader bool
	nlmsgFprintfHeader(fd, m.Header)
	switch {
	case m.Header.Type == Error:
		hasHeader = true
	case m.Header.Type == Done && m.Header.Flags&Multi != 0:
		if len(m.Data) == 0 {
			return
		}
	default:
		// Neither, nothing to do.
	}
	// Errno occupies 4 bytes.
	const endErrno = 4
	if len(m.Data) < endErrno {
		return
	}

	c := nlenc.Int32(m.Data[:endErrno])
	if c != 0 {
		b := m.Data[0:4]
		fmt.Fprintf(fd, "| %.2x %.2x %.2x %.2x  |\t",
			0xff&b[0], 0xff&b[1],
			0xff&b[2], 0xff&b[3])
		fmt.Fprintf(fd, "|  extra header  |\n")
	}

	// Flags indicate an extended acknowledgement. The type/flags combination
	// checked above determines the offset where the TLVs occur.
	var off int
	if hasHeader {
		// There is an nlmsghdr preceding the TLVs.
		if len(m.Data) < endErrno+nlmsgHeaderLen {
			return
		}
		// The TLVs should be at the offset indicated by the nlmsghdr.length,
		// plus the offset where the header began. But make sure the calculated
		// offset is still in-bounds.
		h := *(*Header)(unsafe.Pointer(&m.Data[endErrno : endErrno+nlmsgHeaderLen][0]))
		off = endErrno + int(h.Length)
		if len(m.Data) < off {
			return
		}
	} else {
		// There is no nlmsghdr preceding the TLVs, parse them directly.
		off = endErrno
	}

	data := m.Data[off:]
	for i := 0; i < len(data); {
		// Make sure there's at least a header's worth of data to read on each iteration.
		if len(data[i:]) < nlaHeaderLen {
			break
		}
		// Extract the length of the attribute.
		l := int(nlenc.Uint16(data[i : i+2]))
		// extract the type
		t := nlenc.Uint16(data[i+2 : i+4])
		// print attribute header
		if colorize {
			fmt.Fprintf(fd, "|\033[1;31m%05d|\033[1;32m%s%s|\033[1;34m%05d\033[0m|\t",
				l,
				ternary(t&syscall.NLA_F_NESTED != 0, "N", "-"),
				ternary(t&syscall.NLA_F_NET_BYTEORDER != 0, "B", "-"),
				t&attrTypeMask)
			fmt.Fprintf(fd, "|len |flags| type|\n")
		} else {
			fmt.Fprintf(fd, "|%05d|%s%s|%05d|\t",
				l,
				ternary(t&syscall.NLA_F_NESTED != 0, "N", "-"),
				ternary(t&syscall.NLA_F_NET_BYTEORDER != 0, "B", "-"),
				t&attrTypeMask)
			fmt.Fprintf(fd, "|len |flags| type|\n")
		}

		nextAttr := i + nlaAlign(l)
		i += nlaHeaderLen

		// Ignore zero-length attributes.
		if l == 0 {
			continue
		}
		// If nested check the next attribute
		if t&syscall.NLA_F_NESTED != 0 {
			continue
		}
		// Print the remaining attributes bytes
		for ; i < nextAttr; i += 4 {
			fmt.Fprintf(fd, "| %.2x %.2x %.2x %.2x  |\t",
				0xff&data[i], 0xff&data[i+1],
				0xff&data[i+2], 0xff&data[i+3])
			fmt.Fprintf(fd, "|      data      |")
			fmt.Fprintf(fd, "\t %s %s %s %s\n",
				ternary(strconv.IsPrint(rune(data[i])), string(data[i]), " "),
				ternary(strconv.IsPrint(rune(data[i+1])), string(data[i+1]), " "),
				ternary(strconv.IsPrint(rune(data[i+2])), string(data[i+2]), " "),
				ternary(strconv.IsPrint(rune(data[i+3])), string(data[i+3]), " "),
			)
		}
	}
	fmt.Fprintf(fd, "----------------\t------------------\n")
}

// ternary returns iftrue if cond is true, else iffalse.
func ternary(cond bool, iftrue string, iffalse string) string {
	if cond {
		return iftrue
	}
	return iffalse
}
