go-cart-actor/cmd/cart/main.go

package main

import (
	"context"
	"encoding/json"
	"fmt"
	"log"
	"net"
	"net/http"
	"net/http/pprof"
	"os"
	"os/signal"
	"strings"
	"sync"
	"time"

	"git.k6n.net/mats/go-cart-actor/internal/ucp"
	"git.k6n.net/mats/go-cart-actor/pkg/actor"
	"git.k6n.net/mats/go-cart-actor/pkg/cart"
	cartmcp "git.k6n.net/mats/go-cart-actor/pkg/cart/mcp"
	"git.k6n.net/mats/go-cart-actor/pkg/promotions"
	"git.k6n.net/mats/go-cart-actor/pkg/proxy"
	"git.k6n.net/mats/go-cart-actor/pkg/telemetry"
	"git.k6n.net/mats/go-cart-actor/pkg/voucher"
	"git.k6n.net/mats/go-redis-inventory/pkg/inventory"
	"git.k6n.net/mats/platform/catalog"
	"git.k6n.net/mats/platform/config"
	"git.k6n.net/mats/platform/event"
	"git.k6n.net/mats/platform/rabbit"
	"github.com/prometheus/client_golang/prometheus"
	"github.com/prometheus/client_golang/prometheus/promauto"
	"github.com/prometheus/client_golang/prometheus/promhttp"
	amqp "github.com/rabbitmq/amqp091-go"
	"github.com/redis/go-redis/v9"
	"go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp"
)

var (
	grainSpawns = promauto.NewCounter(prometheus.CounterOpts{
		Name: "cart_grain_spawned_total",
		Help: "The total number of spawned grains",
	})
)

func init() {
	os.Mkdir("data", 0755)
}

type App struct {
	pool   *actor.SimpleGrainPool[cart.CartGrain]
	server *PoolServer
}

var podIp = os.Getenv("POD_IP")
var name = os.Getenv("POD_NAME")
var amqpUrl = os.Getenv("AMQP_URL")
var redisAddress = os.Getenv("REDIS_ADDRESS")
var redisPassword = os.Getenv("REDIS_PASSWORD")

// normalizeListenAddr accepts either a bare port ("8080") or a full listen
// address (":8080", "0.0.0.0:8080") and returns a value usable by http.Server.Addr.
func normalizeListenAddr(v string) string {
	if strings.Contains(v, ":") {
		return v
	}
	return ":" + v
}

// loadUCPCartSigner loads the UCP ECDSA signing key from the path specified in
// the UCP_SIGNING_KEY_PATH environment variable. Returns nil if unset or unreadable.
func loadUCPCartSigner() *ucp.SigningConfig {
	path := os.Getenv("UCP_SIGNING_KEY_PATH")
	if path == "" {
		return nil
	}
	pemData, err := os.ReadFile(path)
	if err != nil {
		log.Printf("ucp signing: cannot read key %s: %v", path, err)
		return nil
	}
	cfg, err := ucp.NewSigningConfigFromPEM(pemData, "k6n-ecdsa-2026")
	if err != nil {
		log.Printf("ucp signing: invalid key at %s: %v", path, err)
		return nil
	}
	return cfg
}

func getCountryFromHost(host string) string {
	if strings.Contains(strings.ToLower(host), "-no") {
		return "no"
	}
	if strings.Contains(strings.ToLower(host), "-se") {
		return "se"
	}
	return "se"
}

type MutationContext struct {
	VoucherService voucher.Service
}

type CartChangeEvent struct {
	CartId    cart.CartId         `json:"cartId"`
	Mutations []actor.ApplyResult `json:"mutations"`
}

func matchesSkuAndLocation(update inventory.InventoryResult, item cart.CartItem) bool {
	if string(update.SKU) == item.Sku {
		if update.LocationID == "se" && item.StoreId == nil {
			return true
		}
		if item.StoreId == nil {
			return false
		}
		if *item.StoreId == string(update.LocationID) {
			return true
		}
	}
	return false
}

// catalogProjectionCache is the cart's in-process map of SKU → catalog.Projection,
// updated by reading catalog.projection_published events off the bus. It is the
// cart-side source of truth for catalog facts (price, tax_class, inventory_tracked
// flag, currency, image, brand) used at add-to-cart / checkout-reserve decisions.
// Stock state is NOT cached here — exact qty is still queried synchronously from
// the inventory service at decision points per docs/inventory-shape.md.
//
// Concurrency: read-mostly workload justifies sync.RWMutex.
//
// Single-tier storage. The bus is the only writer — the cart does not separately
// seed from a snapshot file at boot, because the access pattern is point lookup
// of cart-active SKUs only, and coupling two sources (mmap snapshot + bus-fed
// map) created duplicated state with subtle drift risk and an mmap-SIGBUS hazard.
// Cold-grace: the cache may be incomplete for an SKU the cart sees before the
// first projection_published arrives for it; the cart falls back to the existing
// PRODUCT_BASE_URL HTTP fetch and overlays the cache fields on top of it.
//
// Deletes carry a tombstone in the map (not a plain delete) so a bus delete of
// an SKU that already fits the cache rules correctly shadows it for Get /
// IsDeleted lookups — preventing an oversight from re-fetching a deleted SKU
// before the cache rebuilds. Tombstones have a per-pod lifetime; bus-driven,
// so the next sweep on the same SKU flips the entry back to live.
type catalogProjectionCache struct {
	mu    sync.RWMutex
	items map[string]projectionEntry
}

// projectionEntry is a cache slot: a live projection, or a tombstone (deleted)
// that shadows the live fallback.
type projectionEntry struct {
	proj    catalog.Projection
	deleted bool
}

func newCatalogProjectionCache() *catalogProjectionCache {
	return &catalogProjectionCache{items: make(map[string]projectionEntry, 8192)}
}

func (c *catalogProjectionCache) Apply(updates []catalog.ProjectionUpdate) (upserts, deletes int) {
	c.mu.Lock()
	defer c.mu.Unlock()
	for _, u := range updates {
		if u.Deleted {
			c.items[u.SKU] = projectionEntry{deleted: true}
			deletes++
			continue
		}
		if u.SKU == "" {
			continue
		}
		c.items[u.SKU] = projectionEntry{proj: u.Projection}
		upserts++
	}
	return
}

func (c *catalogProjectionCache) Get(sku string) (catalog.Projection, bool) {
	c.mu.RLock()
	e, ok := c.items[sku]
	c.mu.RUnlock()
	if !ok {
		return catalog.Projection{}, false
	}
	if e.deleted {
		return catalog.Projection{}, false
	}
	return e.proj, true
}

// IsDeleted reports whether a tombstone exists for sku — used by HTTP-fetch
// call sites to skip the fallback for an SKU the bus has explicitly deleted,
// avoiding a wasteful round-trip on items the writer has just removed.
func (c *catalogProjectionCache) IsDeleted(sku string) bool {
	c.mu.RLock()
	e, ok := c.items[sku]
	c.mu.RUnlock()
	return ok && e.deleted
}

// Len reports the number of map entries (bus-fed upserts + tombstones). Used
// for log gauges only.
func (c *catalogProjectionCache) Len() int {
	c.mu.RLock()
	defer c.mu.RUnlock()
	return len(c.items)
}

// projectionDeliveryHandler is the AMQP delivery handler for
// `catalog.projection_published` on the `catalog` topic exchange. Decodes the
// []ProjectionUpdate batch and merges it into cache. Returns nil on a batch
// that doesn't apply locally so the AMQP delivery is acked; returns an error
// on a decode failure so the broker knows to redeliver / quarantine.
//
// Recovery: any panic in a single event is caught so the goroutine keeps
// draining the queue; the bus stays live across malformed events.
func projectionDeliveryHandler(cache *catalogProjectionCache) func(amqp.Delivery) error {
	return func(d amqp.Delivery) (err error) {
		defer func() {
			if r := recover(); r != nil {
				err = fmt.Errorf("projection handler panic recovered: %v", r)
			}
		}()
		var ev event.Event
		if err := json.Unmarshal(d.Body, &ev); err != nil {
			return fmt.Errorf("decode event envelope: %w", err)
		}
		updates, err := catalog.DecodeUpdates(ev.Payload)
		if err != nil {
			return fmt.Errorf("decode projection updates: %w", err)
		}
		upserts, deletes := cache.Apply(updates)
		log.Printf("cart: catalog projection batch applied: upserts=%d deletes=%d total=%d eventID=%s source=%q",
			upserts, deletes, cache.Len(), ev.ID, ev.Source)
		return nil
	}
}

func main() {

	// cartPort is the bare HTTP port. It drives both the local listener and the
	// port used to proxy to peer pods, so a cluster must run all pods on the
	// same CART_PORT.
	cartPort := config.EnvString("CART_PORT", "8080")
	if i := strings.LastIndex(cartPort, ":"); i >= 0 {
		cartPort = cartPort[i+1:]
	}

	controlPlaneConfig := actor.DefaultServerConfig()

	promotionStore, err := promotions.NewStore("data/promotions.json")
	if err != nil {
		log.Fatalf("Error loading promotions: %v\n", err)
	}

	log.Printf("loaded %d promotions", len(promotionStore.List()))

	promotionService := promotions.NewPromotionService(nil)

	//inventoryPubSub := actor.NewPubSub[inventory.InventoryChange]()

	rdb := redis.NewClient(&redis.Options{
		Addr:     redisAddress,
		Password: redisPassword,
		DB:       0,
	})
	inventoryService, err := inventory.NewRedisInventoryService(rdb)
	if err != nil {
		log.Fatalf("Error creating inventory service: %v\n", err)
	}
	_ = inventoryService

	inventoryReservationService, err := inventory.NewRedisCartReservationService(rdb)
	if err != nil {
		log.Fatalf("Error creating inventory reservation service: %v\n", err)
	}

	reg := cart.NewCartMultationRegistry(cart.NewCartMutationContext(inventoryReservationService))
	reg.RegisterProcessor(
		actor.NewMutationProcessor(func(ctx context.Context, g *cart.CartGrain) error {
			_, span := tracer.Start(ctx, "Totals and promotions")
			defer span.End()

			// Clear bypass flags first
			for _, v := range g.Vouchers {
				if v != nil {
					v.BypassedByPromotions = false
				}
			}

			g.UpdateTotals()
			promotionCtx := promotions.NewContextFromCart(g, promotions.WithNow(time.Now()))
			results, _ := promotionService.EvaluateAll(promotionStore.Snapshot(), promotionCtx)

			// Check if any qualified promotion rule has a coupon_code condition matching our vouchers
			hasBypassed := false
			for _, res := range results {
				if res.Applicable {
					promotions.WalkConditions(res.Rule.Conditions, func(c promotions.Condition) bool {
						if bc, ok := c.(promotions.BaseCondition); ok && bc.Type == promotions.CondCouponCode {
							var codes []string
							if s, ok := bc.Value.AsString(); ok {
								codes = append(codes, strings.ToLower(s))
							} else if arr, ok := bc.Value.AsStringSlice(); ok {
								for _, s := range arr {
									codes = append(codes, strings.ToLower(s))
								}
							}
							for _, code := range codes {
								for _, v := range g.Vouchers {
									if v != nil && strings.ToLower(v.Code) == code {
										if !v.BypassedByPromotions {
											v.BypassedByPromotions = true
											hasBypassed = true
										}
									}
								}
							}
						}
						return true
					})
				}
			}

			if hasBypassed {
				// Re-evaluate with bypassed vouchers
				g.UpdateTotals()
				promotionCtx = promotions.NewContextFromCart(g, promotions.WithNow(time.Now()))
				results, _ = promotionService.EvaluateAll(promotionStore.Snapshot(), promotionCtx)
			}

			// ApplyResults applies qualifying actions in priority order and records
			// every effect — both applied discounts and pending "spend X more for ..."
			// nudges with their progress — in g.AppliedPromotions.
			promotionService.ApplyResults(g, results, promotionCtx)
			g.Version++
			return nil
		}),
	)

	diskStorage := actor.NewDiskStorage[cart.CartGrain](config.EnvString("CART_DIR", "data"), reg)
	poolConfig := actor.GrainPoolConfig[cart.CartGrain]{
		MutationRegistry: reg,
		Storage:          diskStorage,
		Spawn: func(ctx context.Context, id uint64) (actor.Grain[cart.CartGrain], error) {
			_, span := tracer.Start(ctx, fmt.Sprintf("Spawn cart id %d", id))
			defer span.End()
			grainSpawns.Inc()
			ret := cart.NewCartGrain(id, time.Now())
			// Set baseline lastChange at spawn; replay may update it to last event timestamp.

			// inventoryPubSub.Subscribe(ret.HandleInventoryChange)
			err := diskStorage.LoadEvents(ctx, id, ret)
			// if err == nil && inventoryService != nil {
			// 	refs := make([]*inventory.InventoryReference, 0)
			// 	for _, item := range ret.Items {
			// 		refs = append(refs, &inventory.InventoryReference{
			// 			SKU:        inventory.SKU(item.Sku),
			// 			LocationID: getLocationId(item),
			// 		})
			// 	}
			// 	_, span := tracer.Start(ctx, "update inventory")
			// 	defer span.End()
			// 	res, err := inventoryService.GetInventoryBatch(ctx, refs...)
			// 	if err != nil {
			// 		log.Printf("unable to update inventory %v", err)
			// 	} else {
			// 		for _, update := range res {
			// 			for _, item := range ret.Items {
			// 				if matchesSkuAndLocation(update, *item) && update.Quantity != uint32(item.Stock) {
			// 					// maybe apply an update to give visibility to the cart
			// 					item.Stock = uint16(update.Quantity)
			// 				}
			// 			}
			// 		}
			// 	}
			// }

			return ret, err
		},
		Destroy: func(grain actor.Grain[cart.CartGrain]) error {
			// cart, err := grain.GetCurrentState()
			// if err != nil {
			// 	return err
			// }
			//inventoryPubSub.Unsubscribe(cart.HandleInventoryChange)

			return nil
		},
		SpawnHost: func(host string) (actor.Host[cart.CartGrain], error) {
			return proxy.NewRemoteHost[cart.CartGrain](host, cartPort)
		},
		TTL:      5 * time.Minute,
		PoolSize: 2 * 65535,
		Hostname: podIp,
	}

	pool, err := actor.NewSimpleGrainPool(poolConfig)
	if err != nil {
		log.Fatalf("Error creating cart pool: %v\n", err)
	}

	cartMCP := cartmcp.New(pool)

	// Stream each applied mutation to the shared "mutations" exchange (routing key
	// mutation.cart) so the backoffice /commerce live feed (and other consumers)
	// see cart activity. Best-effort: if AMQP is unreachable the cart still serves.
	if amqpUrl != "" {
		if conn, derr := rabbit.Dial(amqpUrl, "cart"); derr != nil {
			log.Printf("cart: AMQP connect failed, mutation feed disabled: %v", derr)
		} else {
			listener := actor.NewAmqpListener(conn.Connection(), "cart", actor.MutationSummary)
			listener.DefineTopics()
			pool.AddListener(listener)
			log.Printf("cart: mutation feed enabled (mutation.cart)")
		}
	}

	// catalog.projection_published consumer (the cart is the canonical
	// consumer of the projection wire per docs/inventory-shape.md; inventory
	// emits level crossings back to finder only, never the reverse). Own
	// connection keeps the cart's mutation-feed lifecycle decoupled from a
	// read-write-consume connection that could grow event handlers later
	// (e.g. promotions reacting to a price drop on a watched SKU).
	projectionCache := newCatalogProjectionCache()
	if amqpUrl != "" {
		if pConn, perr := rabbit.Dial(amqpUrl, "cart-catalog-projection"); perr != nil {
			log.Printf("cart: catalog projection consumer DISABLED (dial failed): %v", perr)
		} else {
			pConn.NotifyOnReconnect(func() {
				ch, err := pConn.Channel()
				if err != nil {
					log.Printf("cart: channel on projection reconnect: %v", err)
					return
				}
				if err := rabbit.ListenToPattern(ch, "catalog", string(event.CatalogProjectionPublished), projectionDeliveryHandler(projectionCache)); err != nil {
					log.Printf("cart: bind catalog.projection_published on reconnect: %v", err)
					_ = ch.Close()
				}
			})
			defer func() { _ = pConn.Close() }()
			log.Printf("cart: catalog projection consumer ENABLED (catalog.projection_published on 'catalog' exchange)")
		}
	}

	syncedServer := NewPoolServer(pool, fmt.Sprintf("%s, %s", name, podIp), projectionCache) //inventoryService, inventoryReservationService)

	app := &App{
		pool:   pool,
		server: syncedServer,
	}

	mux := http.NewServeMux()
	debugMux := http.NewServeMux()

	grpcSrv, err := actor.NewControlServer[cart.CartGrain](controlPlaneConfig, pool)
	if err != nil {
		log.Fatalf("Error starting control plane gRPC server: %v\n", err)
	}
	defer grpcSrv.GracefulStop()

	// go diskStorage.SaveLoop(10 * time.Second)
	UseDiscovery(pool)

	ctx, stop := signal.NotifyContext(context.Background(), os.Interrupt)
	defer stop()

	otelShutdown, err := telemetry.SetupOTelSDK(ctx)
	if err != nil {
		log.Fatalf("Unable to start otel %v", err)
	}

	syncedServer.Serve(mux)

	// Cart MCP edge: inspect and mutate carts — get_cart, get_cart_items,
	// update_item_quantity, remove_cart_item, clear_cart, apply_voucher, etc.
	// Exposes 11 tools on the same grain pool, mounted at /cart-mcp so it does
	// not conflict with the Promotions MCP at /promotions-mcp.
	mux.Handle("/cart-mcp", cartMCP.Handler())
	mux.Handle("/cart-mcp/", cartMCP.Handler())

	// UCP REST adapter — Universal Commerce Protocol
	cartUCP := ucp.CartHandler(pool)
	if signer := loadUCPCartSigner(); signer != nil {
		cartUCP = ucp.WithSigning(cartUCP, signer)
		log.Print("ucp signing enabled")
	}
	// StripPrefix is required because the sub-mux (CartHandler) registers
	// routes like "GET /{id}" which expect a relative path; Go's ServeMux
	// passes the full request path (e.g. /ucp/v1/carts/123) without stripping
	// the prefix, so the sub-mux would never match.
	//
	// Only the subtree pattern (/ucp/v1/carts/) is registered, NOT the exact
	// pattern (/ucp/v1/carts), because registering both causes Go's ServeMux
	// to redirect the exact match to the subtree root, and StripPrefix
	// interferes with the redirect target (producing a 307 to "/" instead
	// of "/ucp/v1/carts/"). Consumers should use the trailing-slash variant.
	mux.Handle("/ucp/v1/carts/", http.StripPrefix("/ucp/v1/carts", cartUCP))

	// Stateless promotion evaluation: POST a (possibly partial) eval context and
	// get back the resulting totals plus the applied/pending effect breakdown,
	// without creating or mutating a real cart.
	mux.HandleFunc("POST /promotions/evaluate", newPromotionEvaluateHandler(promotionStore, promotionService))

	// only for local
	mux.HandleFunc("GET /add/remote/{host}", func(w http.ResponseWriter, r *http.Request) {
		pool.AddRemote(r.PathValue("host"))
	})

	debugMux.HandleFunc("/debug/pprof/", pprof.Index)
	debugMux.HandleFunc("/debug/pprof/cmdline", pprof.Cmdline)
	debugMux.HandleFunc("/debug/pprof/profile", pprof.Profile)
	debugMux.HandleFunc("/debug/pprof/symbol", pprof.Symbol)
	debugMux.HandleFunc("/debug/pprof/trace", pprof.Trace)
	debugMux.Handle("/metrics", promhttp.Handler())

	// Projection cache probe (dev/verification). GET /debug/projection/{sku} →
	// the resolved projection + the bus-fed map size. map_entries counts both
	// live projections and tombstones; a found=true response confirms the bus
	// consumer delivered the SKU to this pod.
	debugMux.HandleFunc("/debug/projection/", func(w http.ResponseWriter, r *http.Request) {
		sku := strings.TrimPrefix(r.URL.Path, "/debug/projection/")
		p, found := projectionCache.Get(sku)
		w.Header().Set("Content-Type", "application/json")
		_ = json.NewEncoder(w).Encode(map[string]any{
			"sku":         sku,
			"found":       found,
			"projection":  p,
			"map_entries": projectionCache.Len(),
			"deleted":     projectionCache.IsDeleted(sku),
		})
	})
	mux.HandleFunc("/healthz", func(w http.ResponseWriter, r *http.Request) {
		// Grain pool health: simple capacity check (mirrors previous GrainHandler.IsHealthy)
		grainCount, capacity := app.pool.LocalUsage()
		if grainCount >= capacity {
			w.WriteHeader(http.StatusInternalServerError)
			w.Write([]byte("grain pool at capacity"))
			return
		}
		if !pool.IsHealthy() {
			w.WriteHeader(http.StatusInternalServerError)
			w.Write([]byte("control plane not healthy"))
			return
		}
		w.WriteHeader(http.StatusOK)
		w.Write([]byte("ok"))
	})
	mux.HandleFunc("/readyz", func(w http.ResponseWriter, r *http.Request) {
		w.WriteHeader(http.StatusOK)
		w.Write([]byte("ok"))
	})
	mux.HandleFunc("/livez", func(w http.ResponseWriter, r *http.Request) {
		w.WriteHeader(http.StatusOK)
		w.Write([]byte("ok"))
	})

	mux.HandleFunc("/version", func(w http.ResponseWriter, r *http.Request) {
		w.WriteHeader(http.StatusOK)
		w.Write([]byte("1.0.0"))
	})

	mux.HandleFunc("/openapi.json", ServeEmbeddedOpenAPI)

	httpAddr := normalizeListenAddr(cartPort)
	debugAddr := normalizeListenAddr(config.EnvString("CART_DEBUG_PORT", "8081"))

	srv := &http.Server{
		Addr:        httpAddr,
		BaseContext: func(net.Listener) context.Context { return ctx },
		ReadTimeout: 10 * time.Second,
		// Close idle keep-alive connections so a load test with many short-lived
		// clients doesn't pin file handles open indefinitely.
		IdleTimeout:  60 * time.Second,
		WriteTimeout: 20 * time.Second,
		Handler:      otelhttp.NewHandler(mux, "/"),
	}

	defer func() {

		fmt.Println("Shutting down due to signal")
		otelShutdown(context.Background())
		diskStorage.Close()
		pool.Close()

	}()

	srvErr := make(chan error, 1)
	go func() {
		srvErr <- srv.ListenAndServe()
	}()

	// Inventory change consumption used to live here over the bare Redis
	// `inventory_changed` channel; it is now owned by the cart-inventory
	// service, which translates quantity changes into inventory.level_changed
	// bus crossings. The cart reads exact stock synchronously when it needs it.
	// See docs/inventory-shape.md.

	log.Printf("Server started at %s (debug %s)", httpAddr, debugAddr)

	go http.ListenAndServe(debugAddr, debugMux)

	select {
	case err = <-srvErr:
		// Error when starting HTTP server.
		log.Fatalf("Unable to start server: %v", err)
	case <-ctx.Done():
		// Wait for first CTRL+C.
		// Stop receiving signal notifications as soon as possible.
		stop()
	}

}