docs: reorder & testing

pkg/transcoder/report.go

@@ -1,12 +1,12 @@
 package transcoder
 
 import (
-	"encoding/binary"
 	"errors"
 	"fmt"
 	"sort"
 
 	model "galaxy/model/report"
+	commonfbs "galaxy/schema/fbs/common"
 	fbs "galaxy/schema/fbs/report"
 
 	flatbuffers "github.com/google/flatbuffers/go"
@@ -521,7 +521,7 @@ func encodeReportLocalGroup(builder *flatbuffers.Builder, group *model.LocalGrou
 		fleet = builder.CreateString(*group.Fleet)
 	}
 
-	idHi, idLo := reportUUIDToHiLo(group.ID)
+	idHi, idLo := uuidToHiLo(group.ID)
 
 	fbs.LocalGroupStart(builder)
 	fbs.LocalGroupAddNumber(builder, uint64(group.Number))
@@ -540,7 +540,7 @@ func encodeReportLocalGroup(builder *flatbuffers.Builder, group *model.LocalGrou
 	}
 	fbs.LocalGroupAddSpeed(builder, reportFloatToFBS(group.Speed))
 	fbs.LocalGroupAddMass(builder, reportFloatToFBS(group.Mass))
-	fbs.LocalGroupAddId(builder, fbs.CreateUUID(builder, idHi, idLo))
+	fbs.LocalGroupAddId(builder, commonfbs.CreateUUID(builder, idHi, idLo))
 	fbs.LocalGroupAddState(builder, state)
 	if group.Fleet != nil {
 		fbs.LocalGroupAddFleet(builder, fleet)
@@ -735,12 +735,12 @@ func decodeReportBattleVector(flatReport *fbs.Report, result *model.Report) erro
 	}
 
 	result.Battle = make([]uuid.UUID, length)
-	item := new(fbs.UUID)
+	item := new(commonfbs.UUID)
 	for i := 0; i < length; i++ {
 		if !flatReport.Battle(item, i) {
 			return fmt.Errorf("decode report battle %d: battle id is missing", i)
 		}
-		result.Battle[i] = reportUUIDFromHiLo(item.Hi(), item.Lo())
+		result.Battle[i] = uuidFromHiLo(item.Hi(), item.Lo())
 	}
 
 	return nil
@@ -1120,7 +1120,7 @@ func decodeReportLocalGroupVector(flatReport *fbs.Report, result *model.Report)
 				Speed:       reportFloatFromFBS(item.Speed()),
 				Mass:        reportFloatFromFBS(item.Mass()),
 			},
-			ID:    reportUUIDFromHiLo(id.Hi(), id.Lo()),
+			ID:    uuidFromHiLo(id.Hi(), id.Lo()),
 			State: string(item.State()),
 		}
 
@@ -1306,8 +1306,8 @@ func encodeReportUUIDVector(builder *flatbuffers.Builder, ids []uuid.UUID) flatb
 
 	fbs.ReportStartBattleVector(builder, len(ids))
 	for i := len(ids) - 1; i >= 0; i-- {
-		hi, lo := reportUUIDToHiLo(ids[i])
-		fbs.CreateUUID(builder, hi, lo)
+		hi, lo := uuidToHiLo(ids[i])
+		commonfbs.CreateUUID(builder, hi, lo)
 	}
 	return builder.EndVector(len(ids))
 }
@@ -1374,17 +1374,6 @@ func reportFloatFromFBS(value float32) model.Float {
 	return model.Float(float64(value))
 }
 
-func reportUUIDToHiLo(value uuid.UUID) (uint64, uint64) {
-	return binary.BigEndian.Uint64(value[0:8]), binary.BigEndian.Uint64(value[8:16])
-}
-
-func reportUUIDFromHiLo(hi uint64, lo uint64) uuid.UUID {
-	var value uuid.UUID
-	binary.BigEndian.PutUint64(value[0:8], hi)
-	binary.BigEndian.PutUint64(value[8:16], lo)
-	return value
-}
-
 func uint64ToUint(value uint64, field string) (uint, error) {
 	maxUint := uint64(^uint(0))
 	if value > maxUint {
@@ -1392,3 +1381,47 @@ func uint64ToUint(value uint64, field string) (uint, error) {
 	}
 	return uint(value), nil
 }
+
+// GameReportRequestToPayload converts model.GameReportRequest to
+// FlatBuffers bytes suitable for the authenticated gateway transport.
+func GameReportRequestToPayload(req *model.GameReportRequest) ([]byte, error) {
+	if req == nil {
+		return nil, errors.New("encode game report request payload: request is nil")
+	}
+
+	builder := flatbuffers.NewBuilder(64)
+
+	fbs.GameReportRequestStart(builder)
+	hi, lo := uuidToHiLo(req.GameID)
+	fbs.GameReportRequestAddGameId(builder, commonfbs.CreateUUID(builder, hi, lo))
+	fbs.GameReportRequestAddTurn(builder, uint32(req.Turn))
+	offset := fbs.GameReportRequestEnd(builder)
+	fbs.FinishGameReportRequestBuffer(builder, offset)
+
+	return builder.FinishedBytes(), nil
+}
+
+// PayloadToGameReportRequest converts FlatBuffers payload bytes into
+// model.GameReportRequest.
+func PayloadToGameReportRequest(data []byte) (result *model.GameReportRequest, err error) {
+	if len(data) == 0 {
+		return nil, errors.New("decode game report request payload: data is empty")
+	}
+
+	defer func() {
+		if recovered := recover(); recovered != nil {
+			result = nil
+			err = fmt.Errorf("decode game report request payload: panic recovered: %v", recovered)
+		}
+	}()
+
+	req := fbs.GetRootAsGameReportRequest(data, 0)
+	gameID := req.GameId(nil)
+	if gameID == nil {
+		return nil, errors.New("decode game report request payload: game_id is missing")
+	}
+	return &model.GameReportRequest{
+		GameID: uuidFromHiLo(gameID.Hi(), gameID.Lo()),
+		Turn:   uint(req.Turn()),
+	}, nil
+}