package sync

import "errors"

const (
	MessageSync           uint8 = 0
	MessageAwareness      uint8 = 1
	MessageAuth           uint8 = 2
	MessageAwarenessQuery uint8 = 3
)

const (
	SyncStep1 uint8 = 0
	SyncStep2 uint8 = 1
	Update    uint8 = 2
)

func writeVarUint(b []byte, v uint64) int {
	i := 0
	for {
		b[i] = byte(v & 0x7f)
		v >>= 7
		if v == 0 {
			i++
			break
		}
		b[i] |= 0x80
		i++
	}
	return i
}

func readVarUint(b []byte) (uint64, int, error) {
	if len(b) == 0 {
		return 0, 0, errors.New("unexpected end of input")
	}
	var result uint64
	var shift uint
	i := 0
	for {
		if i >= len(b) {
			return 0, 0, errors.New("unexpected end of input")
		}
		chunk := uint64(b[i])
		result |= (chunk & 0x7f) << shift
		i++
		if chunk&0x80 == 0 {
			break
		}
		shift += 7
		if shift > 63 {
			return 0, 0, errors.New("varint overflow")
		}
	}
	return result, i, nil
}

func encodeVarByteArray(data []byte) []byte {
	encoded := make([]byte, 0, 10+len(data))
	encoded = appendVarUint(encoded, uint64(len(data)))
	encoded = append(encoded, data...)
	return encoded
}

func encodeMessage(msgType uint8, payload []byte) []byte {
	msg := make([]byte, 0, 2+len(payload))
	msg = appendVarUint(msg, uint64(msgType))
	msg = appendVarByteArray(msg, payload)
	return msg
}

func encodeSyncMessage(innerType uint8, payload []byte) []byte {
	msg := make([]byte, 0, 2+len(payload))
	msg = appendVarUint(msg, uint64(MessageSync))
	msg = appendVarUint(msg, uint64(innerType))
	msg = appendVarByteArray(msg, payload)
	return msg
}

func encodeAwarenessMessage(payload []byte) []byte {
	msg := make([]byte, 0, 2+len(payload))
	msg = appendVarUint(msg, uint64(MessageAwareness))
	msg = appendVarByteArray(msg, payload)
	return msg
}

func appendVarUint(b []byte, v uint64) []byte {
	var buf [10]byte
	n := writeVarUint(buf[:], v)
	return append(b, buf[:n]...)
}

func appendVarByteArray(b []byte, data []byte) []byte {
	b = appendVarUint(b, uint64(len(data)))
	return append(b, data...)
}