feat: predictions

internal/transport/rest/handler/handler.go

@@ -3,7 +3,9 @@ package handler
 import (
 	"context"
 	"net/http"
+	"time"
 
+	"git.intra.yksa.space/gsn/predictor/internal/pkg/ds"
 	"git.intra.yksa.space/gsn/predictor/internal/pkg/errcodes"
 	api "git.intra.yksa.space/gsn/predictor/pkg/rest"
 )
@@ -23,7 +25,115 @@ func New(svc Service) *Handler {
 }
 
 func (h *Handler) PerformPrediction(ctx context.Context, req api.OptPredictionParameters, params api.PerformPredictionParams) (*api.PredictionResult, error) {
-	return nil, errcodes.New(http.StatusNotImplemented, "not implemented", "please wait")
+	internalParams := ds.ConvertOptPredictionParameters(req)
+	if internalParams == nil {
+		return nil, errcodes.New(http.StatusBadRequest, "invalid or missing parameters")
+	}
+	results, err := h.svc.PerformPrediction(ctx, *internalParams)
+	if err != nil {
+		return nil, err
+	}
+	if len(results) == 0 {
+		return nil, errcodes.New(http.StatusInternalServerError, "no prediction results")
+	}
+
+	// Group results into stages (ascent and descent)
+	stages := h.groupResultsIntoStages(results)
+
+	// Map to OpenAPI schema
+	var predictionItems []api.PredictionResultPredictionItem
+
+	for _, stage := range stages {
+		var trajectory []api.PredictionResultPredictionItemTrajectoryItem
+
+		for _, result := range stage.Results {
+			traj := api.PredictionResultPredictionItemTrajectoryItem{
+				Datetime:  *result.Timestamp,
+				Latitude:  *result.Latitude,
+				Longitude: *result.Longitude,
+				Altitude:  *result.Altitude,
+			}
+			trajectory = append(trajectory, traj)
+		}
+
+		item := api.PredictionResultPredictionItem{
+			Stage:      stage.Stage,
+			Trajectory: trajectory,
+		}
+		predictionItems = append(predictionItems, item)
+	}
+
+	metadata := api.PredictionResultMetadata{
+		StartDatetime:    *results[0].Timestamp,
+		CompleteDatetime: *results[len(results)-1].Timestamp,
+	}
+
+	resp := &api.PredictionResult{
+		Metadata:   metadata,
+		Prediction: predictionItems,
+	}
+	return resp, nil
+}
+
+// StageResult represents a stage with its results
+type StageResult struct {
+	Stage   api.PredictionResultPredictionItemStage
+	Results []ds.PredicitonResult
+}
+
+// groupResultsIntoStages groups the prediction results into ascent and descent stages
+func (h *Handler) groupResultsIntoStages(results []ds.PredicitonResult) []StageResult {
+	if len(results) == 0 {
+		return nil
+	}
+
+	var stages []StageResult
+	var currentStage []ds.PredicitonResult
+	var currentStageType api.PredictionResultPredictionItemStage
+
+	// Determine if we're in ascent or descent based on altitude changes
+	prevAlt := *results[0].Altitude
+	currentStage = append(currentStage, results[0])
+	currentStageType = api.PredictionResultPredictionItemStageAscent
+
+	for i := 1; i < len(results); i++ {
+		result := results[i]
+		currentAlt := *result.Altitude
+
+		// Determine if we're still in the same stage
+		var stageType api.PredictionResultPredictionItemStage
+		if currentAlt > prevAlt {
+			stageType = api.PredictionResultPredictionItemStageAscent
+		} else if currentAlt < prevAlt {
+			stageType = api.PredictionResultPredictionItemStageDescent
+		} else {
+			// Same altitude - continue with current stage
+			stageType = currentStageType
+		}
+
+		// If stage type changed, finalize current stage and start new one
+		if stageType != currentStageType && len(currentStage) > 0 {
+			stages = append(stages, StageResult{
+				Stage:   currentStageType,
+				Results: currentStage,
+			})
+			currentStage = nil
+			currentStageType = stageType
+		}
+
+		currentStage = append(currentStage, result)
+		prevAlt = currentAlt
+	}
+
+	// Add the final stage
+	if len(currentStage) > 0 {
+		stages = append(stages, StageResult{
+			Stage:   currentStageType,
+			Results: currentStage,
+		})
+	}
+
+	return stages
 }
 
 func (h *Handler) NewError(ctx context.Context, err error) *api.ErrorStatusCode {
@@ -50,3 +160,35 @@ func (h *Handler) NewError(ctx context.Context, err error) *api.ErrorStatusCode
 		},
 	}
 }
+
+func (h *Handler) ReadinessCheck(ctx context.Context) (*api.ReadinessResponse, error) {
+	status := api.ReadinessResponseStatusNotReady
+	var lastUpdate time.Time
+	var isFresh bool
+	var errMsg string
+
+	if s, ok := h.svc.(interface {
+		GetGribStatus(ctx context.Context) (ready bool, lastUpdate time.Time, isFresh bool, errMsg string)
+	}); ok {
+		ready, lu, fresh, em := s.GetGribStatus(ctx)
+		lastUpdate = lu
+		isFresh = fresh
+		errMsg = em
+		if ready {
+			status = api.ReadinessResponseStatusOk
+		} else if em != "" {
+			status = api.ReadinessResponseStatusError
+		}
+	} else {
+		errMsg = "service does not implement GetGribStatus"
+		status = api.ReadinessResponseStatusError
+	}
+
+	resp := &api.ReadinessResponse{
+		Status:       status,
+		IsFresh:      api.NewOptBool(isFresh),
+		LastUpdate:   api.NewOptDateTime(lastUpdate),
+		ErrorMessage: api.NewOptString(errMsg),
+	}
+	return resp, nil
+}