OrchestrAD/backend/internal/api/backups_handlers.go

// Package api - Backups handlers
package api

import (
	"net/http"
	"time"

	"github.com/Grace-Solutions/OrchestrAD/internal/audit"
	"github.com/Grace-Solutions/OrchestrAD/internal/logging"
	"github.com/Grace-Solutions/OrchestrAD/internal/services"
	"github.com/go-chi/chi/v5"
)

// BackupsHandler handles database backup endpoints
type BackupsHandler struct {
	service      *services.BackupService
	auditService *audit.Service
	logger       *logging.Logger
}

// NewBackupsHandler creates a new BackupsHandler
func NewBackupsHandler(service *services.BackupService, auditService *audit.Service, logger *logging.Logger) *BackupsHandler {
	return &BackupsHandler{service: service, auditService: auditService, logger: logger}
}

// BackupResponse represents a backup in responses
type BackupResponse struct {
	ID         string    `json:"id,omitempty"`
	Filename   string    `json:"filename"`
	FilePath   string    `json:"filePath"`
	SizeBytes  int64     `json:"sizeBytes"`
	BackupType string    `json:"backupType,omitempty"`
	CreatedAt  time.Time `json:"createdAt"`
}

// CreateBackupRequest represents a backup creation request
type CreateBackupRequest struct {
	BackupType string `json:"backupType,omitempty"`
}

// RestoreBackupRequest represents a restore request body
type RestoreBackupRequest struct {
	FilePath string `json:"filePath,omitempty"`
}

// List handles GET /api/v1/backups
func (h *BackupsHandler) List(w http.ResponseWriter, r *http.Request) {
	backups, err := h.service.ListBackups()
	if err != nil {
		h.logger.Error("BackupsHandler", "List failed: %v", err)
		WriteError(w, http.StatusInternalServerError, ErrCodeInternalError, "Failed to list backups")
		return
	}
	resp := make([]BackupResponse, 0, len(backups))
	for i := range backups {
		resp = append(resp, backupToResponse(&backups[i]))
	}
	WriteJSON(w, http.StatusOK, resp)
}

// Create handles POST /api/v1/backups
func (h *BackupsHandler) Create(w http.ResponseWriter, r *http.Request) {
	var req CreateBackupRequest
	if r.ContentLength > 0 {
		if err := DecodeJSON(r, &req); err != nil {
			WriteError(w, http.StatusBadRequest, ErrCodeBadRequest, "Invalid request body")
			return
		}
	}
	backupType := req.BackupType
	if backupType == "" {
		backupType = "manual"
	}

	triggeredBy := "api"
	if user := GetUserFromContext(r.Context()); user != nil {
		triggeredBy = user.Username
	}

	backup, err := h.service.CreateBackup(backupType, triggeredBy)
	if err != nil {
		h.logger.Error("BackupsHandler", "Create failed: %v", err)
		emitAudit(h.auditService, r, audit.EventBackup, "Backup", "", "Create", false,
			map[string]any{"backupType": backupType}, err.Error())
		WriteError(w, http.StatusInternalServerError, ErrCodeInternalError, "Failed to create backup")
		return
	}
	emitAudit(h.auditService, r, audit.EventBackup, "Backup", backup.ID, "Create", true,
		map[string]any{"filename": backup.Filename, "backupType": backup.BackupType}, "")
	WriteJSON(w, http.StatusCreated, backupToResponse(backup))
}

// Restore handles POST /api/v1/backups/{id}/restore
// The {id} parameter is the backup filename; alternatively callers may pass a
// filePath in the request body for backups that are not in the default location.
func (h *BackupsHandler) Restore(w http.ResponseWriter, r *http.Request) {
	var req RestoreBackupRequest
	if r.ContentLength > 0 {
		if err := DecodeJSON(r, &req); err != nil {
			WriteError(w, http.StatusBadRequest, ErrCodeBadRequest, "Invalid request body")
			return
		}
	}

	filePath := req.FilePath
	if filePath == "" {
		filename := chi.URLParam(r, "id")
		if filename == "" {
			WriteError(w, http.StatusBadRequest, ErrCodeValidation, "backup filename or filePath is required")
			return
		}
		backups, err := h.service.ListBackups()
		if err != nil {
			h.logger.Error("BackupsHandler", "ListBackups failed: %v", err)
			WriteError(w, http.StatusInternalServerError, ErrCodeInternalError, "Failed to locate backup")
			return
		}
		for i := range backups {
			if backups[i].Filename == filename {
				filePath = backups[i].FilePath
				break
			}
		}
		if filePath == "" {
			WriteError(w, http.StatusNotFound, ErrCodeNotFound, "Backup not found")
			return
		}
	}

	if err := h.service.RestoreBackup(filePath); err != nil {
		h.logger.Error("BackupsHandler", "Restore failed: %v", err)
		emitAudit(h.auditService, r, audit.EventRestore, "Backup", "", "Restore", false,
			map[string]any{"filePath": filePath}, err.Error())
		WriteError(w, http.StatusInternalServerError, ErrCodeInternalError, err.Error())
		return
	}
	emitAudit(h.auditService, r, audit.EventRestore, "Backup", "", "Restore", true,
		map[string]any{"filePath": filePath}, "")
	WriteJSON(w, http.StatusOK, map[string]any{
		"staged":          true,
		"restartRequired": true,
		"message": "Restore staged and validated. It is applied the next time OrchestrAD starts; " +
			"the database being replaced is preserved alongside it.",
	})
}

// CancelRestore handles DELETE /api/v1/backups/restore — discards a staged
// restore that has not been applied yet.
func (h *BackupsHandler) CancelRestore(w http.ResponseWriter, r *http.Request) {
	if err := h.service.CancelRestore(); err != nil {
		h.logger.Error("BackupsHandler", "CancelRestore failed: %v", err)
		WriteError(w, http.StatusInternalServerError, ErrCodeInternalError, "Failed to cancel the staged restore")
		return
	}
	emitAudit(h.auditService, r, audit.EventRestore, "Backup", "", "CancelRestore", true, nil, "")
	WriteJSON(w, http.StatusOK, map[string]bool{"cancelled": true})
}

// RestoreStatus handles GET /api/v1/backups/restore — reports whether a restore
// is staged and waiting for a restart.
func (h *BackupsHandler) RestoreStatus(w http.ResponseWriter, r *http.Request) {
	WriteJSON(w, http.StatusOK, map[string]bool{"pending": h.service.PendingRestore()})
}

func backupToResponse(b *services.BackupInfo) BackupResponse {
	return BackupResponse{
		ID:         b.ID,
		Filename:   b.Filename,
		FilePath:   b.FilePath,
		SizeBytes:  b.SizeBytes,
		BackupType: b.BackupType,
		CreatedAt:  b.CreatedAt,
	}
}