medi-wol/internal/handlers/pc_handler.go

package handlers

import (
	"medi-wol/internal/database"
	"medi-wol/internal/models"
	"medi-wol/internal/ping"
	"medi-wol/internal/wol"
	"net/http"
	"strconv"

	"github.com/gin-gonic/gin"
)

// PCHandler verwaltet die HTTP-Anfragen für PC-Operationen
type PCHandler struct {
	db          *database.DB
	wolService  *wol.Service
	pingService *ping.PingService
}

// NewPCHandler erstellt einen neuen PC-Handler
func NewPCHandler(db *database.DB, wolService *wol.Service) *PCHandler {
	return &PCHandler{
		db:          db,
		wolService:  wolService,
		pingService: ping.NewPingService(),
	}
}

// Index zeigt die Hauptseite an
func (h *PCHandler) Index(c *gin.Context) {
	c.HTML(http.StatusOK, "index.html", gin.H{
		"title": "Medi-WOL - Wake-on-LAN Manager",
	})
}

// GetAllPCs gibt alle gespeicherten PCs zurück
func (h *PCHandler) GetAllPCs(c *gin.Context) {
	pcs, err := h.db.GetAllPCs()
	if err != nil {
		c.JSON(http.StatusInternalServerError, models.PCResponse{
			Success: false,
			Message: "Fehler beim Laden der PCs: " + err.Error(),
		})
		return
	}

	c.JSON(http.StatusOK, models.PCResponse{
		Success: true,
		PCs:     pcs,
	})
}

// CreatePC erstellt einen neuen PC-Eintrag
func (h *PCHandler) CreatePC(c *gin.Context) {
	var req models.CreatePCRequest
	if err := c.ShouldBindJSON(&req); err != nil {
		c.JSON(http.StatusBadRequest, models.PCResponse{
			Success: false,
			Message: "Ungültige Anfrage: " + err.Error(),
		})
		return
	}

	// MAC-Adresse validieren
	if !wol.ValidateMAC(req.MAC) {
		c.JSON(http.StatusBadRequest, models.PCResponse{
			Success: false,
			Message: "Ungültige MAC-Adresse",
		})
		return
	}

	// PC erstellen
	pc, err := h.db.CreatePC(req.Name, req.MAC, req.IP)
	if err != nil {
		c.JSON(http.StatusInternalServerError, models.PCResponse{
			Success: false,
			Message: "Fehler beim Erstellen des PCs: " + err.Error(),
		})
		return
	}

	c.JSON(http.StatusCreated, models.PCResponse{
		Success: true,
		Message: "PC erfolgreich erstellt",
		PC:      pc,
	})
}

// UpdatePC aktualisiert einen bestehenden PC-Eintrag
func (h *PCHandler) UpdatePC(c *gin.Context) {
	idStr := c.Param("id")
	id, err := strconv.Atoi(idStr)
	if err != nil {
		c.JSON(http.StatusBadRequest, models.PCResponse{
			Success: false,
			Message: "Ungültige PC-ID",
		})
		return
	}

	var req models.UpdatePCRequest
	if err := c.ShouldBindJSON(&req); err != nil {
		c.JSON(http.StatusBadRequest, models.PCResponse{
			Success: false,
			Message: "Ungültige Anfrage: " + err.Error(),
		})
		return
	}

	// MAC-Adresse validieren
	if !wol.ValidateMAC(req.MAC) {
		c.JSON(http.StatusBadRequest, models.PCResponse{
			Success: false,
			Message: "Ungültige MAC-Adresse",
		})
		return
	}

	// PC aktualisieren
	pc, err := h.db.UpdatePC(id, req.Name, req.MAC, req.IP)
	if err != nil {
		c.JSON(http.StatusInternalServerError, models.PCResponse{
			Success: false,
			Message: "Fehler beim Aktualisieren des PCs: " + err.Error(),
		})
		return
	}

	c.JSON(http.StatusOK, models.PCResponse{
		Success: true,
		Message: "PC erfolgreich aktualisiert",
		PC:      pc,
	})
}

// DeletePC löscht einen PC-Eintrag
func (h *PCHandler) DeletePC(c *gin.Context) {
	idStr := c.Param("id")
	id, err := strconv.Atoi(idStr)
	if err != nil {
		c.JSON(http.StatusBadRequest, models.PCResponse{
			Success: false,
			Message: "Ungültige PC-ID",
		})
		return
	}

	err = h.db.DeletePC(id)
	if err != nil {
		c.JSON(http.StatusInternalServerError, models.PCResponse{
			Success: false,
			Message: "Fehler beim Löschen des PCs: " + err.Error(),
		})
		return
	}

	c.JSON(http.StatusOK, models.PCResponse{
		Success: true,
		Message: "PC erfolgreich gelöscht",
	})
}

// WakePC sendet ein Wake-on-LAN Paket
func (h *PCHandler) WakePC(c *gin.Context) {
	idStr := c.Param("id")
	id, err := strconv.Atoi(idStr)
	if err != nil {
		c.JSON(http.StatusBadRequest, models.PCResponse{
			Success: false,
			Message: "Ungültige PC-ID",
		})
		return
	}

	// PC aus der Datenbank holen
	pc, err := h.db.GetPCByID(id)
	if err != nil {
		c.JSON(http.StatusNotFound, models.PCResponse{
			Success: false,
			Message: "PC nicht gefunden",
		})
		return
	}

	// Wake-on-LAN Paket senden
	err = h.wolService.WakePC(pc.MAC)
	if err != nil {
		c.JSON(http.StatusInternalServerError, models.PCResponse{
			Success: false,
			Message: "Fehler beim Senden des Wake-on-LAN Pakets: " + err.Error(),
		})
		return
	}

	c.JSON(http.StatusOK, models.PCResponse{
		Success: true,
		Message: "Wake-on-LAN Paket erfolgreich gesendet an " + pc.Name,
	})
}

// GetPCStatus gibt den Online-Status aller PCs zurück
func (h *PCHandler) GetPCStatus(c *gin.Context) {
	pcs, err := h.db.GetAllPCs()
	if err != nil {
		c.JSON(http.StatusInternalServerError, models.PCResponse{
			Success: false,
			Message: "Fehler beim Laden der PCs: " + err.Error(),
		})
		return
	}

	// Online-Status für alle PCs überprüfen
	var statusList []models.PCStatus
	for _, pc := range pcs {
		online := h.pingService.IsOnline(pc.IP)
		statusList = append(statusList, models.PCStatus{
			ID:     pc.ID,
			Name:   pc.Name,
			MAC:    pc.MAC,
			IP:     pc.IP,
			Online: online,
		})
	}

	c.JSON(http.StatusOK, gin.H{
		"success": true,
		"status":  statusList,
	})
}