Client-Server Architecture

package main

import (
	"encoding/json"
	"fmt"
	"log"
	"net/http"
	"os"
	"os/signal"
	"context"
	"strings"
	"sync"
	"sync/atomic"
	"syscall"
	"time"
)

// --- Types ---
type Todo struct {
	ID        string `json:"id"`
	Title     string `json:"title"`
	Completed bool   `json:"completed"`
	CreatedAt string `json:"createdAt"`
}

type ApiResponse struct {
	Data   interface{} `json:"data,omitempty"`
	Error  string      `json:"error,omitempty"`
	Status int         `json:"status"`
}

// --- In-memory store ---
type TodoStore struct {
	mu     sync.RWMutex
	todos  map[string]Todo
	nextID atomic.Int64
}

func NewTodoStore() *TodoStore {
	s := &TodoStore{todos: make(map[string]Todo)}
	s.nextID.Store(1)
	return s
}

func (s *TodoStore) List() []Todo {
	s.mu.RLock()
	defer s.mu.RUnlock()
	items := make([]Todo, 0, len(s.todos))
	for _, t := range s.todos {
		items = append(items, t)
	}
	return items
}

func (s *TodoStore) Get(id string) (Todo, bool) {
	s.mu.RLock()
	defer s.mu.RUnlock()
	t, ok := s.todos[id]
	return t, ok
}

func (s *TodoStore) Create(title string) Todo {
	s.mu.Lock()
	defer s.mu.Unlock()
	id := fmt.Sprintf("%d", s.nextID.Add(1)-1)
	t := Todo{
		ID:        id,
		Title:     title,
		Completed: false,
		CreatedAt: time.Now().UTC().Format(time.RFC3339),
	}
	s.todos[id] = t
	return t
}

func (s *TodoStore) Update(id string, title *string, completed *bool) (Todo, bool) {
	s.mu.Lock()
	defer s.mu.Unlock()
	t, ok := s.todos[id]
	if !ok {
		return Todo{}, false
	}
	if title != nil {
		t.Title = *title
	}
	if completed != nil {
		t.Completed = *completed
	}
	s.todos[id] = t
	return t, true
}

func (s *TodoStore) Delete(id string) bool {
	s.mu.Lock()
	defer s.mu.Unlock()
	_, ok := s.todos[id]
	if ok {
		delete(s.todos, id)
	}
	return ok
}

// --- Helpers ---
func writeJSON(w http.ResponseWriter, statusCode int, resp ApiResponse) {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(statusCode)
	json.NewEncoder(w).Encode(resp)
}

// --- Handlers ---
type TodoHandler struct {
	store *TodoStore
}

func (h *TodoHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
	path := strings.TrimPrefix(r.URL.Path, "/api/todos")
	path = strings.TrimPrefix(path, "/")

	switch {
	case path == "" && r.Method == http.MethodGet:
		h.list(w, r)
	case path == "" && r.Method == http.MethodPost:
		h.create(w, r)
	case path != "" && r.Method == http.MethodGet:
		h.get(w, r, path)
	case path != "" && r.Method == http.MethodPut:
		h.update(w, r, path)
	case path != "" && r.Method == http.MethodDelete:
		h.delete(w, r, path)
	default:
		writeJSON(w, http.StatusMethodNotAllowed, ApiResponse{
			Error: "Method not allowed", Status: http.StatusMethodNotAllowed,
		})
	}
}

func (h *TodoHandler) list(w http.ResponseWriter, _ *http.Request) {
	writeJSON(w, http.StatusOK, ApiResponse{Data: h.store.List(), Status: 200})
}

func (h *TodoHandler) get(w http.ResponseWriter, _ *http.Request, id string) {
	todo, ok := h.store.Get(id)
	if !ok {
		writeJSON(w, http.StatusNotFound, ApiResponse{Error: "Todo not found", Status: 404})
		return
	}
	writeJSON(w, http.StatusOK, ApiResponse{Data: todo, Status: 200})
}

func (h *TodoHandler) create(w http.ResponseWriter, r *http.Request) {
	var input struct {
		Title string `json:"title"`
	}
	if err := json.NewDecoder(http.MaxBytesReader(w, r.Body, 1<<20)).Decode(&input); err != nil {
		writeJSON(w, http.StatusBadRequest, ApiResponse{Error: "Invalid JSON", Status: 400})
		return
	}

	title := strings.TrimSpace(input.Title)
	if title == "" {
		writeJSON(w, http.StatusBadRequest, ApiResponse{
			Error: "title is required and must be non-empty", Status: 400,
		})
		return
	}

	todo := h.store.Create(title)
	writeJSON(w, http.StatusCreated, ApiResponse{Data: todo, Status: 201})
}

func (h *TodoHandler) update(w http.ResponseWriter, r *http.Request, id string) {
	var input struct {
		Title     *string `json:"title"`
		Completed *bool   `json:"completed"`
	}
	if err := json.NewDecoder(http.MaxBytesReader(w, r.Body, 1<<20)).Decode(&input); err != nil {
		writeJSON(w, http.StatusBadRequest, ApiResponse{Error: "Invalid JSON", Status: 400})
		return
	}

	todo, ok := h.store.Update(id, input.Title, input.Completed)
	if !ok {
		writeJSON(w, http.StatusNotFound, ApiResponse{Error: "Todo not found", Status: 404})
		return
	}
	writeJSON(w, http.StatusOK, ApiResponse{Data: todo, Status: 200})
}

func (h *TodoHandler) delete(w http.ResponseWriter, _ *http.Request, id string) {
	if !h.store.Delete(id) {
		writeJSON(w, http.StatusNotFound, ApiResponse{Error: "Todo not found", Status: 404})
		return
	}
	w.WriteHeader(http.StatusNoContent)
}

// --- Main with graceful shutdown ---
func main() {
	port := os.Getenv("PORT")
	if port == "" {
		port = "3000"
	}

	store := NewTodoStore()
	handler := &TodoHandler{store: store}

	mux := http.NewServeMux()
	mux.Handle("/api/todos", handler)
	mux.Handle("/api/todos/", handler)

	srv := &http.Server{
		Addr:         ":" + port,
		Handler:      mux,
		ReadTimeout:  5 * time.Second,
		WriteTimeout: 10 * time.Second,
		IdleTimeout:  120 * time.Second,
	}

	// Start server in goroutine
	go func() {
		log.Printf("Server listening on http://localhost:%s", port)
		if err := srv.ListenAndServe(); err != http.ErrServerClosed {
			log.Fatalf("Server error: %v", err)
		}
	}()

	// Wait for interrupt signal
	quit := make(chan os.Signal, 1)
	signal.Notify(quit, syscall.SIGINT, syscall.SIGTERM)
	sig := <-quit
	log.Printf("%s received. Shutting down gracefully...", sig)

	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
	defer cancel()

	if err := srv.Shutdown(ctx); err != nil {
		log.Fatalf("Forced shutdown: %v", err)
	}
	log.Println("Server closed. Exiting.")
}