package rmi

import (
	"bytes"
	"encoding/binary"

	cnsm "git.loafle.net/commons_go/network_service_matcher"
)

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 {
	cnsm.Matchers
}

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

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

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

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

func (r *RMIMatcher) Match(info cnsm.MatchInfo, index int, packet *cnsm.Packet) bool {
	result := false

	if packet == nil || packet.Buffer == nil || packet.Len == 0 {
		return result
	}

	//fmt.Println("packet :", packet)
	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])
	//fmt.Println(hostIp)

	//hostPort := binary.BigEndian.Uint16(rmiRecv.port[:2])

	if rmiRecv.streamMessage == ACK_PROTOCOL && lenInt == len(hostIp) {
		result = true
	}

	return result
}

func NewMatcher() cnsm.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)

	sendByte1 := mCache.Bytes()

	m.AddPacket(cnsm.NewPacket(sendByte1, len(sendByte1)))

	return m
}