feat(server): restructure Pomodoro server into modular components

- move server logic to cmd/server/main.go
- create packages for websocket, pomodoro and broadcast handling
- define models for messages
- remove old GoTomato.go file
- update README

🤖

GoTomato.go

@@ -1,155 +0,0 @@
-package main
-
-import (
-	"encoding/json"
-	"log"
-	"net/http"
-	"sync"
-	"time"
-
-	"github.com/gorilla/websocket"
-)
-
-const (
-	workDuration       = 15 * 60
-	shortBreakDuration = 5 * 60
-	longBreakDuration  = 10 * 60
-	sessions           = 4
-)
-
-type BroadcastMessage struct {
-	Mode       string `json:"mode"`
-	Session    int    `json:"session"`
-	MaxSession int    `json:"max_session"`
-	TimeLeft   int    `json:"time_left"`
-}
-
-type ClientCommand struct {
-	Command string `json:"command"`
-}
-
-var clients = make(map[*websocket.Conn]bool)
-var timerRunning bool
-var timerStopChannel = make(chan bool, 1)
-var mu sync.Mutex // to synchronize access to shared state
-
-// broadcastMessage sends the remaining time to all connected clients.
-func broadcastMessage(message BroadcastMessage) {
-	jsonMessage, _ := json.Marshal(message)
-	for client := range clients {
-		err := client.WriteMessage(websocket.TextMessage, jsonMessage)
-		if err != nil {
-			log.Printf("Error broadcasting to client: %v", err)
-			client.Close()
-			delete(clients, client)
-		}
-	}
-}
-
-// startTimer runs the countdown and broadcasts every second.
-func startTimer(remainingSeconds int, mode string, session int) bool {
-	for remainingSeconds > 0 {
-		select {
-		case <-timerStopChannel:
-			return false // Stop the timer if a stop command is received
-		default:
-			broadcastMessage(BroadcastMessage{
-				Mode:       mode,
-				Session:    session,
-				MaxSession: sessions,
-				TimeLeft:   remainingSeconds,
-			})
-			time.Sleep(time.Second)
-			remainingSeconds--
-		}
-	}
-	broadcastMessage(BroadcastMessage{
-		Mode:       mode,
-		Session:    session,
-		MaxSession: sessions,
-		TimeLeft:   0,
-	})
-	return true
-}
-
-// runPomodoroTimer iterates the Pomodoro work/break sessions.
-func runPomodoroTimer() {
-	mu.Lock()
-	timerRunning = true
-
-	for session := 1; session <= sessions; session++ {
-		if !startTimer(workDuration, "Work", session) {
-			break
-		}
-		if session == sessions {
-			if !startTimer(longBreakDuration, "LongBreak", session) {
-				break
-			}
-		} else {
-			if !startTimer(shortBreakDuration, "ShortBreak", session) {
-				break
-			}
-		}
-	}
-
-	timerRunning = false
-	mu.Unlock()
-}
-
-// upgrade HTTP requests to WebSocket connections.
-var upgrader = websocket.Upgrader{
-	CheckOrigin: func(r *http.Request) bool { return true },
-}
-
-func handleConnections(w http.ResponseWriter, r *http.Request) {
-	// Upgrade initial GET request to a WebSocket
-	ws, err := upgrader.Upgrade(w, r, nil)
-	if err != nil {
-		log.Printf("WebSocket upgrade error: %v", err)
-		return
-	}
-	defer ws.Close()
-
-	// Register the new client
-	clients[ws] = true
-
-	// Listen for commands from this client
-	for {
-		_, message, err := ws.ReadMessage()
-		if err != nil {
-			log.Printf("Client disconnected: %v", err)
-			delete(clients, ws)
-			break
-		}
-
-		// Handle incoming commands
-		var command ClientCommand
-		err = json.Unmarshal(message, &command)
-		if err != nil {
-			log.Printf("Error unmarshalling command: %v", err)
-			continue
-		}
-
-		// Process the commands
-		switch command.Command {
-		case "start":
-			if !timerRunning {
-				go runPomodoroTimer()
-			}
-		case "stop":
-			if timerRunning {
-				timerStopChannel <- true
-			}
-		}
-	}
-}
-
-func main() {
-	http.HandleFunc("/ws", handleConnections)
-
-	log.Println("Pomodoro WebSocket server started on :8080")
-	err := http.ListenAndServe(":8080", nil)
-	if err != nil {
-		log.Fatalf("Error starting server: %v", err)
-	}
-}