[golang] implement shipyards visits

15 files changed, 299 insertions, 45 deletions

diff --git a/golang/cmd/spacetraders/main.go b/golang/cmd/spacetraders/main.go
index bae6c27..5353c68 100644
--- a/golang/cmd/spacetraders/main.go
+++ b/golang/cmd/spacetraders/main.go
@@ -6,6 +6,7 @@ import (
 	"log/slog"
 	"os"
 	"os/signal"
+	"syscall"
 
 	"git.adyxax.org/adyxax/spacetraders/golang/pkg/agent"
 	"git.adyxax.org/adyxax/spacetraders/golang/pkg/api"
@@ -23,7 +24,7 @@ func main() {
 	logger := slog.New(slog.NewJSONHandler(os.Stdout, opts))
 	slog.SetDefault(logger)
 
-	ctx, cancel := signal.NotifyContext(context.Background(), os.Interrupt)
+	ctx, cancel := signal.NotifyContext(context.Background(), os.Interrupt, syscall.SIGTERM)
 	defer cancel()
 
 	db, err := database.NewDB(
diff --git a/golang/pkg/agent/contracting.go b/golang/pkg/agent/contracting.go
index 0f07170..a3eb7aa 100644
--- a/golang/pkg/agent/contracting.go
+++ b/golang/pkg/agent/contracting.go
@@ -11,7 +11,7 @@ func (a *agent) autoContracting(ship *model.Ship) {
 	defer a.wg.Done()
 	contracts, err := a.client.MyContracts()
 	if err != nil {
-		a.sendShipError(fmt.Errorf("failed to get my contracts: %w", err), ship)
+		a.channel <- fmt.Errorf("failed to get my contracts with ship %s: %w", ship.Symbol, err)
 		return
 	}
 	for _, contract := range contracts {
@@ -21,12 +21,12 @@ func (a *agent) autoContracting(ship *model.Ship) {
 		now := time.Now()
 		if now.Before(contract.Terms.Deadline) {
 			if err := a.runContract(&contract, ship); err != nil {
-				a.sendShipError(fmt.Errorf("failed to run contracts: %w", err), ship)
+				a.channel <- fmt.Errorf("failed to run contracts with ship %s: %w", ship.Symbol, err)
 				return
 			}
 		}
 	}
-	a.sendShipError(fmt.Errorf("failed to run contracts: negotiating new contracts is not implemented yet"), ship)
+	a.channel <- fmt.Errorf("failed to run contracts: negotiating new contracts is not implemented yet")
 	// TODO
 	//for {
 	// negotiate
diff --git a/golang/pkg/agent/error.go b/golang/pkg/agent/error.go
deleted file mode 100644
index 64e6b8d..0000000
--- a/golang/pkg/agent/error.go
+++ /dev/null
@@ -1,15 +0,0 @@
-package agent
-
-import "git.adyxax.org/adyxax/spacetraders/golang/pkg/model"
-
-type shipError struct {
-	err  error
-	ship *model.Ship
-}
-
-func (a *agent) sendShipError(err error, ship *model.Ship) {
-	a.channel <- shipError{
-		err:  err,
-		ship: ship,
-	}
-}
diff --git a/golang/pkg/agent/run.go b/golang/pkg/agent/run.go
index 1d70be8..8767c50 100644
--- a/golang/pkg/agent/run.go
+++ b/golang/pkg/agent/run.go
@@ -11,7 +11,7 @@ import (
 )
 
 type agent struct {
-	channel chan shipError
+	channel chan error
 	client  *api.Client
 	db      *database.DB
 	getenv  func(string) string
@@ -32,7 +32,7 @@ func Run(
 	getenv func(string) string,
 ) error {
 	agent := agent{
-		channel: make(chan shipError),
+		channel: make(chan error),
 		client:  client,
 		db:      db,
 		getenv:  getenv,
@@ -57,12 +57,11 @@ func Run(
 				state++
 			case visit_all_shipyards:
 				if err := agent.visitAllShipyards(&agent.ships[1]); err != nil {
-					agent.sendShipError(fmt.Errorf("agent runner returned an error on state %d: %w", state, err), &agent.ships[1])
+					agent.channel <- fmt.Errorf("agent runner returned an error on state %d: %w", state, err)
 				}
 				state++
-				return
 			default:
-				agent.sendShipError(fmt.Errorf("agent runner reach an unknown state: %d", state), nil)
+				agent.channel <- fmt.Errorf("agent runner reach an unknown state: %d", state)
 				return
 			}
 		}
@@ -71,8 +70,8 @@ func Run(
 	errWg.Add(1)
 	go func() {
 		defer errWg.Done()
-		for shipErr := range agent.channel {
-			slog.Error("ship error", "err", shipErr.err, "ship", shipErr.ship.Symbol)
+		for err := range agent.channel {
+			slog.Error("error", "err", err)
 		}
 	}()
 	agent.wg.Wait()
diff --git a/golang/pkg/agent/utils.go b/golang/pkg/agent/utils.go
new file mode 100644
index 0000000..5689405
--- /dev/null
+++ b/golang/pkg/agent/utils.go
@@ -0,0 +1,67 @@
+package agent
+
+import (
+	"cmp"
+	"fmt"
+	"slices"
+
+	"git.adyxax.org/adyxax/spacetraders/golang/pkg/model"
+)
+
+type Point interface {
+	GetX() int
+	GetY() int
+}
+
+func distance2(a Point, b Point) int {
+	x2 := a.GetX() - b.GetX()
+	y2 := a.GetY() - b.GetY()
+	return x2*x2 + y2*y2
+}
+
+func (a *agent) isThereAShipAtWaypoint(waypoint *model.Waypoint) bool {
+	for _, ship := range a.ships {
+		if ship.Nav.WaypointSymbol == waypoint.Symbol {
+			return true
+		}
+	}
+	return false
+}
+
+func (a *agent) listWaypointsInSystemWithTrait(system *model.System, trait string) ([]model.Waypoint, error) {
+	waypoints, err := a.client.ListWaypointsInSystem(system, a.db)
+	if err != nil {
+		return nil, fmt.Errorf("failed to list waypoints with trait: %w", err)
+	}
+	waypoints = slices.DeleteFunc(waypoints, func(waypoint model.Waypoint) bool {
+		for _, t := range waypoint.Traits {
+			if t.Symbol == trait {
+				return false
+			}
+		}
+		return true
+	})
+	return waypoints, nil
+}
+
+func (a *agent) listShipyardsInSystem(system *model.System) ([]model.Shipyard, error) {
+	waypoints, err := a.listWaypointsInSystemWithTrait(system, "SHIPYARD")
+	if err != nil {
+		return nil, fmt.Errorf("failed to list shipyards in system: %w", err)
+	}
+	var shipyards []model.Shipyard
+	for i := range waypoints {
+		shipyard, err := a.client.GetShipyard(&waypoints[i], a.db)
+		if err != nil {
+			return nil, fmt.Errorf("failed to list shipyards in system: %w", err)
+		}
+		shipyards = append(shipyards, *shipyard)
+	}
+	return shipyards, nil
+}
+
+func sortByDistanceFrom[P Point](origin P, destinations []P) {
+	slices.SortFunc(destinations, func(a, b P) int {
+		return cmp.Compare(distance2(origin, a), distance2(origin, b))
+	})
+}
diff --git a/golang/pkg/agent/visit.go b/golang/pkg/agent/visit.go
index 019a6e5..2401b8d 100644
--- a/golang/pkg/agent/visit.go
+++ b/golang/pkg/agent/visit.go
@@ -2,7 +2,7 @@ package agent
 
 import (
 	"fmt"
-	"log/slog"
+	"slices"
 
 	"git.adyxax.org/adyxax/spacetraders/golang/pkg/model"
 )
@@ -12,13 +12,44 @@ func (a *agent) visitAllShipyards(ship *model.Ship) error {
 	if err != nil {
 		return fmt.Errorf("failed to visit all shipyards: %w", err)
 	}
-	waypoints, err := a.client.ListWaypointsInSystem(system, a.db)
+	shipyards, err := a.listShipyardsInSystem(system)
 	if err != nil {
 		return fmt.Errorf("failed to visit all shipyards: %w", err)
 	}
-	//slog.Info("get system", "system", system.Waypoints, "err", err)
-	//waypoint, err := a.client.GetWaypoint("X1-RR14-J88", a.db)
-	slog.Info("get waypoint", "waypoint", waypoints[0])
-
-	return fmt.Errorf("failed to visit all shipyards: not implemented yet")
+	shipyards = slices.DeleteFunc(shipyards, func(shipyard model.Shipyard) bool {
+		// filter out shipyards for which we already have ships prices
+		if shipyard.Ships != nil {
+			return true
+		}
+		// filter out shipyards for which a ship is either present or inbound
+		waypoint, err := a.client.GetWaypoint(shipyard.Symbol, a.db)
+		if err != nil {
+			panic(fmt.Errorf("failed to visit all shipyards: %w", err))
+		}
+		return a.isThereAShipAtWaypoint(waypoint)
+	})
+	if len(shipyards) == 0 {
+		return nil
+	}
+	waypoint, err := a.client.GetWaypoint(ship.Nav.WaypointSymbol, a.db)
+	if err != nil {
+		return fmt.Errorf("failed to visit all shipyards: %w", err)
+	}
+	waypoints := make([]model.Waypoint, 0)
+	for i := range shipyards {
+		waypoint, err := a.client.GetWaypoint(shipyards[i].Symbol, a.db)
+		if err != nil {
+			return fmt.Errorf("failed to visit all shipyards: %w", err)
+		}
+		waypoints = append(waypoints, *waypoint)
+	}
+	sortByDistanceFrom(*waypoint, waypoints)
+	if err := a.client.Navigate(ship, &waypoints[0], a.db); err != nil {
+		return fmt.Errorf("failed to visit all shipyards: %w", err)
+	}
+	if _, err := a.client.GetShipyard(&waypoints[0], a.db); err != nil {
+		return fmt.Errorf("failed to visit all shipyards: %w", err)
+	}
+	// TODO get market data
+	return a.visitAllShipyards(ship)
 }
diff --git a/golang/pkg/api/api.go b/golang/pkg/api/api.go
index 1975e2e..6520251 100644
--- a/golang/pkg/api/api.go
+++ b/golang/pkg/api/api.go
@@ -72,14 +72,14 @@ func (c *Client) Send(method string, uriRef *url.URL, payload any, response any)
 			return res.Err
 		}
 		if err := res.Message.Error; err != nil {
-			return err
-		}
-		err := res.Message.Error
-		if err != nil {
 			switch err.Code {
 			case 4214:
 				e := decodeShipInTransitError(err.Data)
-				time.Sleep(e.SecondsToArrival.Duration() * time.Second)
+				select {
+				case <-c.ctx.Done():
+					return fmt.Errorf("failed to send: ctx cancelled")
+				case <-time.After(e.SecondsToArrival.Duration() * time.Second):
+				}
 				return c.Send(method, uriRef, payload, response)
 			default:
 				return err
@@ -193,7 +193,11 @@ func (c *Client) sendOne(method string, uri *url.URL, payload any) (*APIMessage,
 	switch resp.StatusCode {
 	case 429:
 		e := decodeRateLimitError(msg.Error.Data)
-		time.Sleep(e.RetryAfter.Duration() * time.Second)
+		select {
+		case <-c.ctx.Done():
+			return nil, fmt.Errorf("failed to sendOne: ctx cancelled")
+		case <-time.After(e.RetryAfter.Duration() * time.Second):
+		}
 		return c.sendOne(method, uri, payload)
 	}
 	return &msg, nil
diff --git a/golang/pkg/api/ships.go b/golang/pkg/api/ships.go
index 93963c3..16d4e10 100644
--- a/golang/pkg/api/ships.go
+++ b/golang/pkg/api/ships.go
@@ -4,6 +4,7 @@ import (
 	"fmt"
 	"net/url"
 	"path"
+	"time"
 
 	"git.adyxax.org/adyxax/spacetraders/golang/pkg/database"
 	"git.adyxax.org/adyxax/spacetraders/golang/pkg/model"
@@ -34,6 +35,36 @@ func (c *Client) MyShips() ([]model.Ship, error) {
 	return ships, nil
 }
 
+func (c *Client) Navigate(s *model.Ship, w *model.Waypoint, db *database.DB) error {
+	// TODO shortest path
+	// TODO go refuel if necessary
+	if err := c.orbit(s); err != nil {
+		return fmt.Errorf("failed to navigate ship %s to %s: %w", s.Symbol, w.Symbol, err)
+	}
+	uriRef := url.URL{Path: path.Join("my/ships", s.Symbol, "navigate")}
+	type navigateRequest struct {
+		WaypointSymbol string `json:"waypointSymbol"`
+	}
+	type navigateResponse struct {
+		//Events        []model.Event        `json:"events"`
+		Fuel *model.Fuel `json:"fuel"`
+		Nav  *model.Nav  `json:"nav"`
+	}
+	var response navigateResponse
+	if err := c.Send("POST", &uriRef, navigateRequest{w.Symbol}, &response); err != nil {
+		return fmt.Errorf("failed to navigate ship %s to %s: %w", s.Symbol, w.Symbol, err)
+	}
+	s.Fuel = response.Fuel
+	s.Nav = response.Nav
+	select {
+	case <-c.ctx.Done():
+		return fmt.Errorf("failed to navigate ship %s to %s: ctx cancelled", s.Symbol, w.Symbol)
+	case <-time.After(s.Nav.Route.Arrival.Sub(time.Now())):
+	}
+	s.Nav.Status = "IN_ORBIT"
+	return nil
+}
+
 func (c *Client) orbit(s *model.Ship) error {
 	if s.Nav.Status == "IN_ORBIT" {
 		return nil
@@ -50,7 +81,7 @@ func (c *Client) orbit(s *model.Ship) error {
 	return nil
 }
 
-func (c *Client) Refuel(s *model.Ship, db *database.DB) error {
+func (c *Client) refuel(s *model.Ship, db *database.DB) error {
 	if s.Fuel.Current == s.Fuel.Capacity {
 		return nil
 	}
diff --git a/golang/pkg/api/systems.go b/golang/pkg/api/systems.go
index 3d3a373..05e43e3 100644
--- a/golang/pkg/api/systems.go
+++ b/golang/pkg/api/systems.go
@@ -25,9 +25,10 @@ func (c *Client) GetSystem(symbol string, db *database.DB) (*model.System, error
 }
 
 func (c *Client) ListWaypointsInSystem(system *model.System, db *database.DB) ([]model.Waypoint, error) {
-	// TODO database caching
-	// TODO pagination
-	// TODO check updated
+	if waypoints, err := db.LoadWaypointsInSystem(system); err == nil && waypoints != nil {
+		// TODO check last updated time
+		return waypoints, nil
+	}
 	uriRef := url.URL{Path: path.Join("systems", system.Symbol, "waypoints")}
 	var waypoints []model.Waypoint
 	if err := c.Send("GET", &uriRef, nil, &waypoints); err != nil {
@@ -41,9 +42,26 @@ func (c *Client) ListWaypointsInSystem(system *model.System, db *database.DB) ([
 	return waypoints, nil
 }
 
+func (c *Client) GetShipyard(waypoint *model.Waypoint, db *database.DB) (*model.Shipyard, error) {
+	if shipyard, err := db.LoadShipyard(waypoint.Symbol); err == nil && shipyard != nil &&
+		(shipyard.Ships != nil) { // TODO || !IsThereAShipAtWaypoint(waypoint)) {
+		// TODO check last updated time
+		return shipyard, nil
+	}
+	uriRef := url.URL{Path: path.Join("systems", waypoint.SystemSymbol, "waypoints", waypoint.Symbol, "shipyard")}
+	var shipyard model.Shipyard
+	if err := c.Send("GET", &uriRef, nil, &shipyard); err != nil {
+		return nil, fmt.Errorf("failed to get shipyard at %s: %w", waypoint.Symbol, err)
+	}
+	if err := db.SaveShipyard(&shipyard); err != nil {
+		return nil, fmt.Errorf("failed to get shipyard at %s: %w", waypoint.Symbol, err)
+	}
+	return &shipyard, nil
+}
+
 func (c *Client) GetWaypoint(symbol string, db *database.DB) (*model.Waypoint, error) {
-	// TODO check updated
 	if waypoint, err := db.LoadWaypoint(symbol); err == nil && waypoint != nil {
+		// TODO check last updated time
 		return waypoint, nil
 	}
 	systemSymbol := WaypointSymbolToSystemSymbol(symbol)
diff --git a/golang/pkg/database/shipyards.go b/golang/pkg/database/shipyards.go
new file mode 100644
index 0000000..8dd801e
--- /dev/null
+++ b/golang/pkg/database/shipyards.go
@@ -0,0 +1,42 @@
+package database
+
+import (
+	"database/sql"
+	"encoding/json"
+	"fmt"
+	"time"
+
+	"git.adyxax.org/adyxax/spacetraders/golang/pkg/model"
+)
+
+func (db *DB) LoadShipyard(symbol string) (*model.Shipyard, error) {
+	var buf []byte
+	if err := db.QueryRow(`SELECT data FROM shipyards WHERE data->>'symbol' = ?;`, symbol).Scan(&buf); err != nil {
+		return nil, fmt.Errorf("failed to query shipyard: %w", err)
+	}
+	var shipyard model.Shipyard
+	if err := json.Unmarshal(buf, &shipyard); err != nil {
+		return nil, fmt.Errorf("failed to unmarshal shipyard: %w", err)
+	}
+	return &shipyard, nil
+}
+
+func (db *DB) SaveShipyard(shipyard *model.Shipyard) error {
+	data, err := json.Marshal(shipyard)
+	if err != nil {
+		return fmt.Errorf("failed to marshal shipyard: %w", err)
+	}
+	_, err = db.Exec(
+		`INSERT INTO shipyards(data, updated)
+                VALUES (json(:data), :updated)
+         ON CONFLICT DO UPDATE SET data = :data, updated = :updated
+		                       WHERE data->>'symbol' = :symbol;`,
+		sql.Named("data", data),
+		sql.Named("symbol", shipyard.Symbol),
+		sql.Named("updated", time.Now()),
+	)
+	if err != nil {
+		return fmt.Errorf("failed to append shipyard: %w", err)
+	}
+	return nil
+}
diff --git a/golang/pkg/database/sql/001_trading.sql b/golang/pkg/database/sql/001_trading.sql
index 68f2568..89dd77c 100644
--- a/golang/pkg/database/sql/001_trading.sql
+++ b/golang/pkg/database/sql/001_trading.sql
@@ -10,7 +10,12 @@ CREATE TABLE markets (
 );
 CREATE INDEX markets_systemSymbol on markets (systemSymbol);
 CREATE UNIQUE INDEX markets_data_symbol on markets(json_extract(data, '$.symbol'));
-
+CREATE TABLE shipyards (
+       id INTEGER PRIMARY KEY,
+       data JSON NOT NULL,
+       updated DATE DEFAULT NULL
+);
+CREATE UNIQUE INDEX shipyards_data_symbol on shipyards (json_extract(data, '$.symbol'));
 CREATE TABLE systems (
   id INTEGER PRIMARY KEY,
   data JSON NOT NULL
diff --git a/golang/pkg/database/systems.go b/golang/pkg/database/systems.go
index 858c3dd..0af6aa7 100644
--- a/golang/pkg/database/systems.go
+++ b/golang/pkg/database/systems.go
@@ -45,6 +45,30 @@ func (db *DB) LoadWaypoint(symbol string) (*model.Waypoint, error) {
 	return &waypoint, nil
 }
 
+func (db *DB) LoadWaypointsInSystem(system *model.System) ([]model.Waypoint, error) {
+	rows, err := db.Query(`SELECT data FROM waypoints WHERE data->>'systemSymbol' = ?;`, system.Symbol)
+	if err != nil {
+		return nil, fmt.Errorf("failed to query waypoints: %w", err)
+	}
+	defer rows.Close()
+	waypoints := make([]model.Waypoint, 0)
+	for rows.Next() {
+		var buf []byte
+		if err := rows.Scan(&buf); err != nil {
+			return nil, fmt.Errorf("failed to load waypoint from row: %w", err)
+		}
+		var waypoint model.Waypoint
+		if err := json.Unmarshal(buf, &waypoint); err != nil {
+			return nil, fmt.Errorf("failed to unmarshal waypoint: %w", err)
+		}
+		waypoints = append(waypoints, waypoint)
+	}
+	if err := rows.Err(); err != nil {
+		return nil, fmt.Errorf("failed to load waypoints from rows: %w", err)
+	}
+	return waypoints, nil
+}
+
 func (db *DB) SaveWaypoint(waypoint *model.Waypoint) error {
 	data, err := json.Marshal(waypoint)
 	if err != nil {
diff --git a/golang/pkg/model/common.go b/golang/pkg/model/common.go
index 058b43d..6a2c321 100644
--- a/golang/pkg/model/common.go
+++ b/golang/pkg/model/common.go
@@ -5,3 +5,7 @@ type Common struct {
 	//Name   string `json:"name"`
 	Symbol string `json:"symbol"`
 }
+
+type CommonType struct {
+	Type string `json:"type"`
+}
diff --git a/golang/pkg/model/shipyard.go b/golang/pkg/model/shipyard.go
new file mode 100644
index 0000000..2ba2e95
--- /dev/null
+++ b/golang/pkg/model/shipyard.go
@@ -0,0 +1,35 @@
+package model
+
+import "time"
+
+type Shipyard struct {
+	ModificationFee int                   `json:"modificationFee"`
+	Symbol          string                `json:"symbol"`
+	ShipTypes       []CommonType          `json:"shipTypes"`
+	Transactions    []ShipyardTransaction `json:"transactions"`
+	Ships           []ShipyardShip        `json:"ships"`
+}
+
+type ShipyardShip struct {
+	Activity string `json:"activity"`
+	// crew
+	//Description string `json:"description"`
+	// engine
+	// frame
+	// modules
+	// mounts
+	//Name         string   `json:"name"`
+	PurchasePrice int `json:"purchasePrice"`
+	// reactor
+	Supply string `json:"supply"`
+	Type   string `json:"type"`
+}
+
+type ShipyardTransaction struct {
+	AgentSymbol    string    `json:"agentSymbol"`
+	Price          int       `json:"price"`
+	ShipSymbol     string    `json:"shipSymbol"`
+	ShipType       string    `json:"shipType"`
+	Timestamp      time.Time `json:"timestamp"`
+	WaypointSymbol string    `json:"waypointSymbol"`
+}
diff --git a/golang/pkg/model/waypoint.go b/golang/pkg/model/waypoint.go
index 7b71e6a..d8bd5cd 100644
--- a/golang/pkg/model/waypoint.go
+++ b/golang/pkg/model/waypoint.go
@@ -14,3 +14,11 @@ type Waypoint struct {
 	X            int      `json:"x"`
 	Y            int      `json:"y"`
 }
+
+func (w Waypoint) GetX() int {
+	return w.X
+}
+
+func (w Waypoint) GetY() int {
+	return w.Y
+}