feat: predictions

internal/transport/rest/config.go

@@ -1,5 +1,10 @@
 package rest
 
+import (
+	"git.intra.yksa.space/gsn/predictor/internal/pkg/errcodes"
+	env "github.com/caarlos0/env/v11"
+)
+
 type Config struct {
 	Host         string `env:"HOST" envDefault:"0.0.0.0"`
 	Port         int    `env:"PORT" envDefault:"8080"`
@@ -7,3 +12,13 @@ type Config struct {
 	WriteTimeout string `env:"WRITE_TIMEOUT" envDefault:"30s"`
 	IdleTimeout  string `env:"IDLE_TIMEOUT" envDefault:"60s"`
 }
+
+func NewConfig() (*Config, error) {
+	cfg := &Config{}
+	if err := env.ParseWithOptions(cfg, env.Options{
+		PrefixTagName: "GSN_PREDICTOR_REST_",
+	}); err != nil {
+		return nil, errcodes.Wrap(err, "failed to parse REST config")
+	}
+	return cfg, nil
+}

internal/transport/rest/handler/deps.go

@@ -3,9 +3,12 @@ package handler
 import (
 	"context"
 	"time"
+
+	"git.intra.yksa.space/gsn/predictor/internal/pkg/ds"
 )
 
 type Service interface {
 	UpdateWeatherData(ctx context.Context) error
 	ExtractWind(ctx context.Context, lat, lon, alt float64, ts time.Time) ([2]float64, error)
+	PerformPrediction(ctx context.Context, params ds.PredictionParameters) ([]ds.PredicitonResult, error)
 }

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
+}

internal/transport/rest/transport.go

@@ -1,36 +1,37 @@
 package rest
 
 import (
+	"context"
 	"fmt"
 	"net/http"
 
+	"git.intra.yksa.space/gsn/predictor/internal/pkg/log"
 	"git.intra.yksa.space/gsn/predictor/internal/transport/middleware"
 	handler "git.intra.yksa.space/gsn/predictor/internal/transport/rest/handler"
 	api "git.intra.yksa.space/gsn/predictor/pkg/rest"
-	"go.uber.org/zap"
 )
 
 type Transport struct {
-	lg  *zap.Logger
-	cfg *Config
-	srv *api.Server
+	cfg     *Config
+	srv     *api.Server
+	handler *handler.Handler
 }
 
-func New(lg *zap.Logger, handler *handler.Handler, cfg *Config) (*Transport, error) {
-	srv, err := api.NewServer(handler, api.WithMiddleware(middleware.Logging(lg)))
+func New(handler *handler.Handler, cfg *Config) (*Transport, error) {
+	srv, err := api.NewServer(handler, api.WithMiddleware(middleware.Logging()))
 	if err != nil {
 		return nil, err
 	}
 
 	return &Transport{
-		lg:  lg,
-		srv: srv,
-		cfg: cfg,
+		srv:     srv,
+		cfg:     cfg,
+		handler: handler,
 	}, nil
 }
 
 func (t *Transport) Run() {
-	t.lg.Info("started")
+	log.Ctx(context.Background()).Info("started")
 
 	if err := http.ListenAndServe(fmt.Sprintf(":%d", t.cfg.Port), t.srv); err != nil {
 		panic(err)