rename backend to core

core/internal/server/wayland/handlers.go

@@ -0,0 +1,205 @@
+package wayland
+
+import (
+	"encoding/json"
+	"fmt"
+	"net"
+	"time"
+
+	"github.com/AvengeMedia/DankMaterialShell/core/internal/server/models"
+)
+
+type Request struct {
+	ID     int                    `json:"id,omitempty"`
+	Method string                 `json:"method"`
+	Params map[string]interface{} `json:"params,omitempty"`
+}
+
+type SuccessResult struct {
+	Success bool   `json:"success"`
+	Message string `json:"message"`
+}
+
+func HandleRequest(conn net.Conn, req Request, manager *Manager) {
+	if manager == nil {
+		models.RespondError(conn, req.ID, "wayland manager not initialized")
+		return
+	}
+
+	switch req.Method {
+	case "wayland.gamma.getState":
+		handleGetState(conn, req, manager)
+	case "wayland.gamma.setTemperature":
+		handleSetTemperature(conn, req, manager)
+	case "wayland.gamma.setLocation":
+		handleSetLocation(conn, req, manager)
+	case "wayland.gamma.setManualTimes":
+		handleSetManualTimes(conn, req, manager)
+	case "wayland.gamma.setUseIPLocation":
+		handleSetUseIPLocation(conn, req, manager)
+	case "wayland.gamma.setGamma":
+		handleSetGamma(conn, req, manager)
+	case "wayland.gamma.setEnabled":
+		handleSetEnabled(conn, req, manager)
+	case "wayland.gamma.subscribe":
+		handleSubscribe(conn, req, manager)
+	default:
+		models.RespondError(conn, req.ID, fmt.Sprintf("unknown method: %s", req.Method))
+	}
+}
+
+func handleGetState(conn net.Conn, req Request, manager *Manager) {
+	state := manager.GetState()
+	models.Respond(conn, req.ID, state)
+}
+
+func handleSetTemperature(conn net.Conn, req Request, manager *Manager) {
+	var lowTemp, highTemp int
+
+	if temp, ok := req.Params["temp"].(float64); ok {
+		lowTemp = int(temp)
+		highTemp = int(temp)
+	} else {
+		low, okLow := req.Params["low"].(float64)
+		high, okHigh := req.Params["high"].(float64)
+
+		if !okLow || !okHigh {
+			models.RespondError(conn, req.ID, "missing temperature parameters (provide 'temp' or both 'low' and 'high')")
+			return
+		}
+
+		lowTemp = int(low)
+		highTemp = int(high)
+	}
+
+	if err := manager.SetTemperature(lowTemp, highTemp); err != nil {
+		models.RespondError(conn, req.ID, err.Error())
+		return
+	}
+
+	models.Respond(conn, req.ID, SuccessResult{Success: true, Message: "temperature set"})
+}
+
+func handleSetLocation(conn net.Conn, req Request, manager *Manager) {
+	lat, ok := req.Params["latitude"].(float64)
+	if !ok {
+		models.RespondError(conn, req.ID, "missing or invalid 'latitude' parameter")
+		return
+	}
+
+	lon, ok := req.Params["longitude"].(float64)
+	if !ok {
+		models.RespondError(conn, req.ID, "missing or invalid 'longitude' parameter")
+		return
+	}
+
+	if err := manager.SetLocation(lat, lon); err != nil {
+		models.RespondError(conn, req.ID, err.Error())
+		return
+	}
+
+	models.Respond(conn, req.ID, SuccessResult{Success: true, Message: "location set"})
+}
+
+func handleSetManualTimes(conn net.Conn, req Request, manager *Manager) {
+	sunriseParam := req.Params["sunrise"]
+	sunsetParam := req.Params["sunset"]
+
+	if sunriseParam == nil || sunsetParam == nil {
+		manager.ClearManualTimes()
+		models.Respond(conn, req.ID, SuccessResult{Success: true, Message: "manual times cleared"})
+		return
+	}
+
+	sunriseStr, ok := sunriseParam.(string)
+	if !ok || sunriseStr == "" {
+		manager.ClearManualTimes()
+		models.Respond(conn, req.ID, SuccessResult{Success: true, Message: "manual times cleared"})
+		return
+	}
+
+	sunsetStr, ok := sunsetParam.(string)
+	if !ok || sunsetStr == "" {
+		manager.ClearManualTimes()
+		models.Respond(conn, req.ID, SuccessResult{Success: true, Message: "manual times cleared"})
+		return
+	}
+
+	sunrise, err := time.Parse("15:04", sunriseStr)
+	if err != nil {
+		models.RespondError(conn, req.ID, "invalid sunrise format (use HH:MM)")
+		return
+	}
+
+	sunset, err := time.Parse("15:04", sunsetStr)
+	if err != nil {
+		models.RespondError(conn, req.ID, "invalid sunset format (use HH:MM)")
+		return
+	}
+
+	if err := manager.SetManualTimes(sunrise, sunset); err != nil {
+		models.RespondError(conn, req.ID, err.Error())
+		return
+	}
+
+	models.Respond(conn, req.ID, SuccessResult{Success: true, Message: "manual times set"})
+}
+
+func handleSetUseIPLocation(conn net.Conn, req Request, manager *Manager) {
+	use, ok := req.Params["use"].(bool)
+	if !ok {
+		models.RespondError(conn, req.ID, "missing or invalid 'use' parameter")
+		return
+	}
+
+	manager.SetUseIPLocation(use)
+	models.Respond(conn, req.ID, SuccessResult{Success: true, Message: "IP location preference set"})
+}
+
+func handleSetGamma(conn net.Conn, req Request, manager *Manager) {
+	gamma, ok := req.Params["gamma"].(float64)
+	if !ok {
+		models.RespondError(conn, req.ID, "missing or invalid 'gamma' parameter")
+		return
+	}
+
+	if err := manager.SetGamma(gamma); err != nil {
+		models.RespondError(conn, req.ID, err.Error())
+		return
+	}
+
+	models.Respond(conn, req.ID, SuccessResult{Success: true, Message: "gamma set"})
+}
+
+func handleSetEnabled(conn net.Conn, req Request, manager *Manager) {
+	enabled, ok := req.Params["enabled"].(bool)
+	if !ok {
+		models.RespondError(conn, req.ID, "missing or invalid 'enabled' parameter")
+		return
+	}
+
+	manager.SetEnabled(enabled)
+	models.Respond(conn, req.ID, SuccessResult{Success: true, Message: "enabled state set"})
+}
+
+func handleSubscribe(conn net.Conn, req Request, manager *Manager) {
+	clientID := fmt.Sprintf("client-%p", conn)
+	stateChan := manager.Subscribe(clientID)
+	defer manager.Unsubscribe(clientID)
+
+	initialState := manager.GetState()
+	if err := json.NewEncoder(conn).Encode(models.Response[State]{
+		ID:     req.ID,
+		Result: &initialState,
+	}); err != nil {
+		return
+	}
+
+	for state := range stateChan {
+		if err := json.NewEncoder(conn).Encode(models.Response[State]{
+			Result: &state,
+		}); err != nil {
+			return
+		}
+	}
+}