move-data-nas/internal/api/handlers_syncpairs.go

package api

import (
	"database/sql"
	"encoding/json"
	"fmt"
	"log/slog"
	"net/http"
	"regexp"
	"strconv"
	"strings"

	"github.com/go-chi/chi/v5"
	"github.com/syncserver/internal/models"
)

type SyncPairHandler struct {
	db *sql.DB
}

func NewSyncPairHandler(db *sql.DB) *SyncPairHandler {
	return &SyncPairHandler{db: db}
}

var directionRegex = regexp.MustCompile(`^(push|pull|mirror)$`)

func ValidatePath(path string) error {
	path = strings.TrimSpace(path)
	if path == "" {
		return fmt.Errorf("path cannot be empty")
	}
	if strings.Contains(path, "..") {
		return fmt.Errorf("path cannot contain '..'")
	}
	if strings.HasPrefix(path, "-") {
		return fmt.Errorf("path cannot start with '-'")
	}
	if strings.Contains(path, "\x00") {
		return fmt.Errorf("path cannot contain null bytes")
	}
	return nil
}

func (h *SyncPairHandler) List(w http.ResponseWriter, r *http.Request) {
	repo := models.NewSyncPairRepository(h.db)
	pairs, err := repo.GetAll()
	if err != nil {
		slog.Error("failed to fetch sync pairs", "error", err)
		writeError(w, http.StatusInternalServerError, "failed to fetch sync pairs")
		return
	}
	out := make([]SyncPairResponse, len(pairs))
	for i, p := range pairs {
		out[i] = syncPairToResp(p)
	}
	writeJSON(w, out)
}

func (h *SyncPairHandler) Get(w http.ResponseWriter, r *http.Request) {
	id, err := strconv.ParseInt(chi.URLParam(r, "id"), 10, 64)
	if err != nil {
		writeError(w, http.StatusBadRequest, "invalid id")
		return
	}
	repo := models.NewSyncPairRepository(h.db)
	p, err := repo.GetByID(id)
	if err == sql.ErrNoRows {
		writeError(w, http.StatusNotFound, "sync pair not found")
		return
	}
	if err != nil {
		slog.Error("failed to fetch sync pair", "id", id, "error", err)
		writeError(w, http.StatusInternalServerError, "failed to fetch sync pair")
		return
	}
	writeJSON(w, syncPairToResp(*p))
}

func (h *SyncPairHandler) Create(w http.ResponseWriter, r *http.Request) {
	var req SyncPairRequest
	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
		writeError(w, http.StatusBadRequest, "invalid request body")
		return
	}

	if req.Name == "" || req.SourcePath == "" || req.DestPath == "" {
		writeError(w, http.StatusBadRequest, "name, source_path and dest_path are required")
		return
	}
	if err := ValidatePath(req.SourcePath); err != nil {
		writeError(w, http.StatusBadRequest, "invalid source_path: "+err.Error())
		return
	}
	if err := ValidatePath(req.DestPath); err != nil {
		writeError(w, http.StatusBadRequest, "invalid dest_path: "+err.Error())
		return
	}
	if req.Direction == "" {
		req.Direction = "push"
	}
	if !directionRegex.MatchString(req.Direction) {
		writeError(w, http.StatusBadRequest, "direction must be push, pull, or mirror")
		return
	}
	if req.SourceMachineID != nil && req.DestMachineID != nil && *req.SourceMachineID == *req.DestMachineID {
		writeError(w, http.StatusBadRequest, "source and destination cannot be the same machine")
		return
	}
	if req.RsyncFlags == "" {
		req.RsyncFlags = "-aP"
	}
	if !req.Enabled {
		req.Enabled = true
	}

	sp := &models.SyncPair{
		Name:            req.Name,
		SourceMachineID: req.SourceMachineID,
		SourcePath:      req.SourcePath,
		DestMachineID:   req.DestMachineID,
		DestPath:        req.DestPath,
		Direction:       req.Direction,
		RsyncFlags:      req.RsyncFlags,
		ExcludePatterns: req.ExcludePatterns,
		Enabled:         req.Enabled,
	}

	repo := models.NewSyncPairRepository(h.db)
	id, err := repo.Create(sp)
	if err != nil {
		slog.Error("failed to create sync pair", "name", req.Name, "error", err)
		writeError(w, http.StatusInternalServerError, "failed to create sync pair")
		return
	}
	sp.ID = id
	w.Header().Set("Location", "/api/sync-pairs/"+strconv.FormatInt(id, 10))
	writeJSON(w, syncPairToResp(*sp), http.StatusCreated)
}

func (h *SyncPairHandler) Update(w http.ResponseWriter, r *http.Request) {
	id, err := strconv.ParseInt(chi.URLParam(r, "id"), 10, 64)
	if err != nil {
		writeError(w, http.StatusBadRequest, "invalid id")
		return
	}

	var req SyncPairRequest
	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
		writeError(w, http.StatusBadRequest, "invalid request body")
		return
	}

	if req.Name == "" || req.SourcePath == "" || req.DestPath == "" {
		writeError(w, http.StatusBadRequest, "name, source_path and dest_path are required")
		return
	}
	if err := ValidatePath(req.SourcePath); err != nil {
		writeError(w, http.StatusBadRequest, "invalid source_path: "+err.Error())
		return
	}
	if err := ValidatePath(req.DestPath); err != nil {
		writeError(w, http.StatusBadRequest, "invalid dest_path: "+err.Error())
		return
	}
	if !directionRegex.MatchString(req.Direction) {
		writeError(w, http.StatusBadRequest, "direction must be push, pull, or mirror")
		return
	}
	if req.SourceMachineID != nil && req.DestMachineID != nil && *req.SourceMachineID == *req.DestMachineID {
		writeError(w, http.StatusBadRequest, "source and destination cannot be the same machine")
		return
	}

	repo := models.NewSyncPairRepository(h.db)
	existing, err := repo.GetByID(id)
	if err == sql.ErrNoRows {
		writeError(w, http.StatusNotFound, "sync pair not found")
		return
	}
	if err != nil {
		slog.Error("failed to fetch sync pair", "id", id, "error", err)
		writeError(w, http.StatusInternalServerError, "failed to fetch sync pair")
		return
	}

	existing.Name = req.Name
	existing.SourceMachineID = req.SourceMachineID
	existing.SourcePath = req.SourcePath
	existing.DestMachineID = req.DestMachineID
	existing.DestPath = req.DestPath
	existing.Direction = req.Direction
	existing.RsyncFlags = req.RsyncFlags
	existing.ExcludePatterns = req.ExcludePatterns
	existing.Enabled = req.Enabled

	if err := repo.Update(existing); err != nil {
		slog.Error("failed to update sync pair", "id", id, "error", err)
		writeError(w, http.StatusInternalServerError, "failed to update sync pair")
		return
	}
	writeJSON(w, syncPairToResp(*existing))
}

func (h *SyncPairHandler) Delete(w http.ResponseWriter, r *http.Request) {
	id, err := strconv.ParseInt(chi.URLParam(r, "id"), 10, 64)
	if err != nil {
		writeError(w, http.StatusBadRequest, "invalid id")
		return
	}

	repo := models.NewSyncPairRepository(h.db)
	if err := repo.Delete(id); err != nil {
		slog.Error("failed to delete sync pair", "id", id, "error", err)
		writeError(w, http.StatusInternalServerError, "failed to delete sync pair")
		return
	}
	w.WriteHeader(http.StatusNoContent)
}

func syncPairToResp(p models.SyncPair) SyncPairResponse {
	return SyncPairResponse{
		ID:              p.ID,
		Name:            p.Name,
		SourceMachineID: p.SourceMachineID,
		SourcePath:      p.SourcePath,
		DestMachineID:   p.DestMachineID,
		DestPath:        p.DestPath,
		Direction:       p.Direction,
		RsyncFlags:      p.RsyncFlags,
		ExcludePatterns: p.ExcludePatterns,
		Enabled:         p.Enabled,
	}
}