go-cart-actor/cmd/backoffice/fileserver.go

package main

import (
	"bufio"
	"encoding/json"
	"errors"
	"fmt"
	"io"
	"io/fs"
	"log"
	"net/http"
	"os"
	"path/filepath"
	"sort"
	"strconv"
	"strings"
	"time"

	"git.k6n.net/go-cart-actor/pkg/actor"
	"git.k6n.net/go-cart-actor/pkg/cart"
	"git.k6n.net/go-cart-actor/pkg/checkout"
	"google.golang.org/protobuf/proto"
)

type FileServer struct {
	// Define fields here
	dataDir         string
	checkoutDataDir string
	storage         actor.LogStorage[cart.CartGrain]
	checkoutStorage actor.LogStorage[checkout.CheckoutGrain]
}

func NewFileServer(dataDir string, checkoutDataDir string, storage actor.LogStorage[cart.CartGrain], checkoutStorage actor.LogStorage[checkout.CheckoutGrain]) *FileServer {
	return &FileServer{
		dataDir:         dataDir,
		checkoutDataDir: checkoutDataDir,
		storage:         storage,
		checkoutStorage: checkoutStorage,
	}
}

func isValidId(id string) (uint64, bool) {
	if nr, err := strconv.ParseUint(id, 10, 64); err == nil {
		return nr, true
	}
	if nr, ok := cart.ParseCartId(id); ok {
		return uint64(nr), true
	}
	return 0, false
}

func isValidFileId(name string) (uint64, bool) {

	parts := strings.Split(name, ".")
	if len(parts) > 1 && parts[1] == "events" {
		idStr := parts[0]

		return isValidId(idStr)
	}
	return 0, false
}

// func AccessTime(info os.FileInfo) (time.Time, bool) {
// 	switch stat := info.Sys().(type) {
// 	case *syscall.Stat_t:
// 		// Linux: Atim; macOS/BSD: Atimespec
// 		// Use reflection or build tags if naming differs.
// 		// Linux:
// 		if stat.Atim.Sec != 0 || stat.Atim.Nsec != 0 {
// 			return time.Unix(int64(stat.Atim.Sec), int64(stat.Atim.Nsec)), true
// 		}
// 		// macOS/BSD example (uncomment if needed):
// 		//return time.Unix(int64(stat.Atimespec.Sec), int64(stat.Atimespec.Nsec)), true
// 	}
// 	return time.Time{}, false
// }

func appendFileInfo(info fs.FileInfo, out *CartFileInfo) *CartFileInfo {
	//sys := info.Sys()
	//fmt.Printf("sys type %T", sys)
	out.Size = info.Size()
	out.Modified = info.ModTime()
	//out.Accessed, _ = AccessTime(info)
	return out
}

func appendCheckoutFileInfo(info fs.FileInfo, out *CheckoutFileInfo) *CheckoutFileInfo {
	out.Size = info.Size()
	out.Modified = info.ModTime()
	return out
}

// var cartFileRe = regexp.MustCompile(`^(\d+)\.events\.log$`)

func listCartFiles(dir string) ([]*CartFileInfo, error) {
	entries, err := os.ReadDir(dir)
	if err != nil {
		if errors.Is(err, os.ErrNotExist) {
			return []*CartFileInfo{}, nil
		}
		return nil, err
	}
	out := make([]*CartFileInfo, 0)
	for _, e := range entries {
		if e.IsDir() {
			continue
		}
		id, valid := isValidFileId(e.Name())
		if !valid {
			continue
		}

		info, err := e.Info()
		if err != nil {
			continue
		}
		info.Sys()
		out = append(out, appendFileInfo(info, &CartFileInfo{
			ID:     fmt.Sprintf("%d", id),
			CartId: cart.CartId(id),
		}))
	}
	return out, nil
}

func listCheckoutFiles(dir string) ([]*CheckoutFileInfo, error) {
	entries, err := os.ReadDir(dir)
	if err != nil {
		if errors.Is(err, os.ErrNotExist) {
			return []*CheckoutFileInfo{}, nil
		}
		return nil, err
	}
	out := make([]*CheckoutFileInfo, 0)
	for _, e := range entries {
		if e.IsDir() {
			continue
		}
		id, valid := isValidFileId(e.Name())
		if !valid {
			continue
		}

		info, err := e.Info()
		if err != nil {
			continue
		}
		out = append(out, appendCheckoutFileInfo(info, &CheckoutFileInfo{
			ID:         fmt.Sprintf("%d", id),
			CheckoutId: checkout.CheckoutId(id),
		}))
	}
	return out, nil
}

func readRawLogLines(path string) ([]json.RawMessage, error) {
	fh, err := os.Open(path)
	if err != nil {
		return nil, err
	}
	defer fh.Close()
	lines := make([]json.RawMessage, 0, 64)
	s := bufio.NewScanner(fh)
	// increase buffer to handle larger JSON lines
	buf := make([]byte, 0, 1024*1024)
	s.Buffer(buf, 1024*1024)
	for s.Scan() {
		line := s.Bytes()
		if line == nil {
			continue
		}
		lines = append(lines, line)
	}
	if err := s.Err(); err != nil {
		return nil, err
	}
	return lines, nil
}

func writeJSON(w http.ResponseWriter, status int, v any) {
	w.Header().Set("Content-Type", "application/json")
	w.Header().Set("Cache-Control", "no-cache")
	w.WriteHeader(status)
	_ = json.NewEncoder(w).Encode(v)
}

func (fs *FileServer) CartsHandler(w http.ResponseWriter, r *http.Request) {
	list, err := listCartFiles(fs.dataDir)
	if err != nil {
		writeJSON(w, http.StatusInternalServerError, map[string]string{"error": err.Error()})
		return
	}
	// sort by modified desc
	sort.Slice(list, func(i, j int) bool { return list[i].Modified.After(list[j].Modified) })

	writeJSON(w, http.StatusOK, map[string]any{
		"count": len(list),
		"carts": list,
	})
}

func (fs *FileServer) CheckoutsHandler(w http.ResponseWriter, r *http.Request) {
	list, err := listCheckoutFiles(fs.checkoutDataDir)
	if err != nil {
		writeJSON(w, http.StatusInternalServerError, map[string]string{"error": err.Error()})
		return
	}
	// sort by modified desc
	sort.Slice(list, func(i, j int) bool { return list[i].Modified.After(list[j].Modified) })

	writeJSON(w, http.StatusOK, map[string]any{
		"count":     len(list),
		"checkouts": list,
	})
}

func (fs *FileServer) PromotionsHandler(w http.ResponseWriter, r *http.Request) {
	fileName := filepath.Join(fs.dataDir, "promotions.json")
	if r.Method == http.MethodGet {
		file, err := os.Open(fileName)
		if err != nil {
			writeJSON(w, http.StatusInternalServerError, map[string]string{"error": err.Error()})
			return
		}
		defer file.Close()

		io.Copy(w, file)
		return
	}
	if r.Method == http.MethodPost {
		file, err := os.Create(fileName)
		if err != nil {
			writeJSON(w, http.StatusInternalServerError, map[string]string{"error": err.Error()})
			return
		}
		defer file.Close()

		io.Copy(file, r.Body)
		return
	}

	w.WriteHeader(http.StatusMethodNotAllowed)
}

func (fs *FileServer) VoucherHandler(w http.ResponseWriter, r *http.Request) {
	fileName := filepath.Join(fs.dataDir, "vouchers.json")
	if r.Method == http.MethodGet {
		file, err := os.Open(fileName)
		if err != nil {
			writeJSON(w, http.StatusInternalServerError, map[string]string{"error": err.Error()})
			return
		}
		defer file.Close()

		io.Copy(w, file)
		return
	}
	if r.Method == http.MethodPost {
		file, err := os.Create(fileName)
		if err != nil {
			writeJSON(w, http.StatusInternalServerError, map[string]string{"error": err.Error()})
			return
		}
		defer file.Close()

		io.Copy(file, r.Body)
		return
	}

	w.WriteHeader(http.StatusMethodNotAllowed)
}

func (fs *FileServer) PromotionPartHandler(w http.ResponseWriter, r *http.Request) {
	idStr := r.PathValue("id")
	if idStr == "" {
		w.WriteHeader(http.StatusBadRequest)
		fmt.Fprintf(w, "missing id")
		return
	}
	_, ok := isValidId(idStr)
	if !ok {
		w.WriteHeader(http.StatusBadRequest)
		fmt.Fprintf(w, "invalid id %s", idStr)
		return
	}
	w.WriteHeader(http.StatusNotImplemented)
}

type JsonError struct {
	Error string `json:"error"`
}

func acceptAll(_ proto.Message, _ int, _ time.Time) bool {
	return true
}

func acceptUntilIndex(maxIndex int) func(msg proto.Message, index int, when time.Time) bool {
	return func(msg proto.Message, index int, when time.Time) bool {
		return index < maxIndex
	}
}

func acceptUntilTimestamp(until time.Time) func(msg proto.Message, index int, when time.Time) bool {
	return func(msg proto.Message, index int, when time.Time) bool {
		return when.Before(until)
	}
}

func (fs *FileServer) CartHandler(w http.ResponseWriter, r *http.Request) {
	idStr := r.PathValue("id")
	if idStr == "" {
		writeJSON(w, http.StatusBadRequest, JsonError{Error: "missing id"})
		return
	}
	id, ok := isValidId(idStr)
	if !ok {
		writeJSON(w, http.StatusBadRequest, JsonError{Error: "invalid id"})
		return
	}
	// parse query parameters for filtering
	query := r.URL.Query()
	filterFunction := acceptAll
	if maxIndexStr := query.Get("maxIndex"); maxIndexStr != "" {
		log.Printf("filter maxIndex: %s", maxIndexStr)
		maxIndex, err := strconv.Atoi(maxIndexStr)
		if err != nil {
			writeJSON(w, http.StatusBadRequest, JsonError{Error: "invalid maxIndex"})
			return
		}
		filterFunction = acceptUntilIndex(maxIndex)
	} else if untilStr := query.Get("until"); untilStr != "" {
		log.Printf("filter until: %s", untilStr)
		until, err := time.Parse(time.RFC3339, untilStr)
		if err != nil {
			writeJSON(w, http.StatusBadRequest, JsonError{Error: "invalid until timestamp"})
			return
		}
		filterFunction = acceptUntilTimestamp(until)
	}
	// reconstruct state from event log if present
	grain := cart.NewCartGrain(id, time.Now())
	err := fs.storage.LoadEventsFunc(r.Context(), id, grain, filterFunction)
	if err != nil {
		writeJSON(w, http.StatusInternalServerError, JsonError{Error: err.Error()})
		return
	}

	path := filepath.Join(fs.dataDir, fmt.Sprintf("%d.events.log", id))
	info, err := os.Stat(path)
	if err != nil && errors.Is(err, os.ErrNotExist) {
		writeJSON(w, http.StatusNotFound, JsonError{Error: "cart not found"})
		return
	} else if err != nil {
		writeJSON(w, http.StatusInternalServerError, JsonError{Error: err.Error()})
		return
	}
	lines, err := readRawLogLines(path)
	if err != nil {
		writeJSON(w, http.StatusInternalServerError, JsonError{Error: err.Error()})
		return
	}
	writeJSON(w, http.StatusOK, map[string]any{
		"id":        id,
		"cartId":    cart.CartId(id).String(),
		"state":     grain,
		"mutations": lines,
		"meta": map[string]any{
			"size":     info.Size(),
			"modified": info.ModTime(),
			"path":     path,
		},
	})
}

func (fs *FileServer) CheckoutHandler(w http.ResponseWriter, r *http.Request) {
	idStr := r.PathValue("id")
	if idStr == "" {
		writeJSON(w, http.StatusBadRequest, JsonError{Error: "missing id"})
		return
	}
	id, ok := isValidId(idStr)
	if !ok {
		writeJSON(w, http.StatusBadRequest, JsonError{Error: "invalid id"})
		return
	}
	// parse query parameters for filtering
	query := r.URL.Query()
	filterFunction := acceptAll
	if maxIndexStr := query.Get("maxIndex"); maxIndexStr != "" {
		log.Printf("filter maxIndex: %s", maxIndexStr)
		maxIndex, err := strconv.Atoi(maxIndexStr)
		if err != nil {
			writeJSON(w, http.StatusBadRequest, JsonError{Error: "invalid maxIndex"})
			return
		}
		filterFunction = acceptUntilIndex(maxIndex)
	} else if untilStr := query.Get("until"); untilStr != "" {
		log.Printf("filter until: %s", untilStr)
		until, err := time.Parse(time.RFC3339, untilStr)
		if err != nil {
			writeJSON(w, http.StatusBadRequest, JsonError{Error: "invalid until timestamp"})
			return
		}
		filterFunction = acceptUntilTimestamp(until)
	}
	// reconstruct state from event log if present
	grain := checkout.NewCheckoutGrain(id, cart.CartId(id), 0, time.Now(), nil)
	err := fs.checkoutStorage.LoadEventsFunc(r.Context(), id, grain, filterFunction)
	if err != nil {
		writeJSON(w, http.StatusInternalServerError, JsonError{Error: err.Error()})
		return
	}

	path := filepath.Join(fs.checkoutDataDir, fmt.Sprintf("%d.events.log", id))
	info, err := os.Stat(path)
	if err != nil && errors.Is(err, os.ErrNotExist) {
		writeJSON(w, http.StatusNotFound, JsonError{Error: "checkout not found"})
		return
	} else if err != nil {
		writeJSON(w, http.StatusInternalServerError, JsonError{Error: err.Error()})
		return
	}
	lines, err := readRawLogLines(path)
	if err != nil {
		writeJSON(w, http.StatusInternalServerError, JsonError{Error: err.Error()})
		return
	}
	writeJSON(w, http.StatusOK, map[string]any{
		"id":         id,
		"checkoutId": checkout.CheckoutId(id).String(),
		"state":      grain,
		"mutations":  lines,
		"meta": map[string]any{
			"size":     info.Size(),
			"modified": info.ModTime(),
			"path":     path,
		},
	})
}