package rmi

import (
	"bytes"
	"encoding/binary"

	csm "git.loafle.net/commons/service_matcher-go"
)

const (
	MAGIC_NUMBER    = 0x4a524d49
	STREAM_PROTOCOL = 0x4b
	VERSION         = 0x0002
	ACK_PROTOCOL    = 0x4e
)

type RMI_SEND_MESSAGE struct {
	magic    uint32
	version  uint16
	protocol uint8
}

type RMI_RECV_MESSAGE struct {
	streamMessage uint8
	packetLen     uint16
	host          []byte
	port          [2]byte
}

type RMIMatcher struct {
	csm.Matchers
}

func (r *RMIMatcher) Key() string {
	return "RMI"
}

func (r *RMIMatcher) Name() string {
	return "RMI"
}

func (r *RMIMatcher) Meta() csm.Metadata {
	return nil
}

func (r *RMIMatcher) IsPrePacket() bool {
	return false
}

func (r *RMIMatcher) HasResponse(index int) bool {
	return true
}

func (r *RMIMatcher) IsError(info csm.MatchInfo, index int, packet *csm.Packet) bool {
	return false
}

func (r *RMIMatcher) Match(info csm.MatchInfo, index int, packet *csm.Packet) error {

	if packet == nil || packet.Buffer == nil || packet.Len == 0 {
		return csm.NoPacketReceivedError()
	}

	rmiRecv := RMI_RECV_MESSAGE{}

	buf := bytes.NewReader(packet.Buffer)
	binary.Read(buf, binary.BigEndian, &rmiRecv.streamMessage)
	binary.Read(buf, binary.BigEndian, &rmiRecv.packetLen)

	lenInt := int(rmiRecv.packetLen)

	var tempHost = make([]byte, lenInt, lenInt)
	copy(rmiRecv.host, tempHost)

	rmiRecv.host = tempHost

	binary.Read(buf, binary.BigEndian, &rmiRecv.host)
	binary.Read(buf, binary.BigEndian, &rmiRecv.port)

	hostIp := string(rmiRecv.host[:lenInt])

	if rmiRecv.streamMessage == ACK_PROTOCOL && lenInt == len(hostIp) {
		return nil
	}

	return csm.NotMatchedError()
}

func NewMatcher() csm.Matcher {

	m := &RMIMatcher{}
	rsm := RMI_SEND_MESSAGE{
		magic:    MAGIC_NUMBER,
		version:  VERSION,
		protocol: STREAM_PROTOCOL,
	}

	mCache := new(bytes.Buffer)
	binary.Write(mCache, binary.BigEndian, rsm)

	sendByte := mCache.Bytes()

	m.AddPacket(csm.NewPacket(sendByte, len(sendByte)))

	return m
}