package rpc

import "lux/proto"

// FSM to handle TCP-window split XML packets
const LUX_XML_REQUEST_BEGIN = "<request"
const LUX_XML_REQUEST_END = "</request>"
const LUX_XML_RESPONSE_BEGIN = "<response"
const LUX_XML_RESPONSE_END = "</response>"
const LUX_XML_ERROR_BEGIN = "<error"
const LUX_XML_ERROR_END = "</error>"

type LuxRpcDefragState int

const (
	defragStateOff = 0

	defragStateReading         = 1
	defragStateReadingRequest  = 1
	defragStateReadingResponse = 2
	defragStateReadingError    = 3

	defragStateHasData = 4
	defragStateHasRequest
	defragStateHasResponse = 5
	defragStateHasError    = 6
)

type LuxRpcDefrag struct {
	buffer   proto.LuxBuffer
	state    LuxRpcDefragState
	beginOff int
	endOff   int
}

func NewLuxRpcDefrag() LuxRpcDefrag {
	return LuxRpcDefrag{
		buffer:   proto.NewLuxBuffer(),
		state:    defragStateOff,
		beginOff: 0,
		endOff:   0,
	}
}

func (def *LuxRpcDefrag) HasRequest() bool {
	return def.state == defragStateHasRequest
}

func (def *LuxRpcDefrag) HasResponse() bool {
	return def.state == defragStateHasResponse
}

func (def *LuxRpcDefrag) HasError() bool {
	return def.state == defragStateHasError
}

func matchTag(slice []byte, tag string) bool {
	tagLen := len(tag)
	if len(slice) >= tagLen {
		return string(slice[:tagLen]) == tag
	}

	return false
}

// will return true if data is complete
func (def *LuxRpcDefrag) Feed(data []byte) bool {
	// try find tag opening at beginning
	if def.state == defragStateOff {
		for i := 0; i < len(data); i++ {
			slice := data[i:]

			if matchTag(slice, LUX_XML_REQUEST_BEGIN) {
				def.state = defragStateReadingRequest
				def.beginOff = i + len(LUX_XML_REQUEST_BEGIN)
				break
			} else if matchTag(slice, LUX_XML_RESPONSE_BEGIN) {
				def.state = defragStateReadingResponse
				def.beginOff = i + len(LUX_XML_RESPONSE_BEGIN)
				break
			} else if matchTag(slice, LUX_XML_ERROR_BEGIN) {
				def.state = defragStateReadingError
				def.beginOff = i + len(LUX_XML_ERROR_BEGIN)
				break
			}
		}
	}

	// now check if slice has ending tag, if so - complete data
	if def.state >= defragStateReading {
		for i := def.beginOff; i < len(data); i++ {
			slice := data[i:]

			if matchTag(slice, LUX_XML_REQUEST_END) {
				def.state = defragStateHasRequest
				def.endOff = i + len(LUX_XML_REQUEST_END)
				break
			} else if matchTag(slice, LUX_XML_RESPONSE_END) {
				def.state = defragStateHasResponse
				def.endOff = i + len(LUX_XML_RESPONSE_END)
				break
			} else if matchTag(slice, LUX_XML_ERROR_END) {
				def.state = defragStateHasError
				def.endOff = i + len(LUX_XML_ERROR_END)
				break
			}
		}

		// got end tag? push exact 0:endOff slice
		if def.state >= defragStateHasData {
			def.buffer.WriteBytes(data[:def.endOff])

			return true // we got complete data!
		} else {
			// if there is no end tag, then reset beginOff so it wont
			// confuse next Feed call
			def.beginOff = 0
		}
	}

	// push whatever data is
	def.buffer.WriteBytes(data)
	return false
}

func (def *LuxRpcDefrag) GetAndForget() []byte {
	data := def.buffer.AllBytes()

	// reset state
	def.buffer = proto.NewLuxBuffer()
	def.state = defragStateOff
	def.beginOff = 0
	def.endOff = 0

	return data
}