main.go

package main

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

type Feedback struct {
	Name      string    `json:"name"`
	Message   string    `json:"message"`
	Rating    int       `json:"rating"`
	Timestamp time.Time `json:"timestamp"`
}

var PORT string = ":8080"
var FILE string = "feedback.ndjson"

const QueueSize = 1000

func main() {
	feedbackChan := make(chan Feedback, QueueSize)

	ctx, cancel := context.WithCancel(context.Background())
	defer cancel()

	// goroutine
	go fileWriterLoop(ctx, FILE, feedbackChan)

	mux := http.NewServeMux()

	fs := http.FileServer(http.Dir("public"))
	mux.Handle("/public/", http.StripPrefix("/public/", fs))

	mux.HandleFunc("GET /add", func(w http.ResponseWriter, r *http.Request) {
		http.ServeFile(w, r, "public/add.html")
	})

	mux.HandleFunc("GET /list", func(w http.ResponseWriter, r *http.Request) {
		http.ServeFile(w, r, "public/list.html")
	})

	mux.HandleFunc("GET /feedback", func(w http.ResponseWriter, r *http.Request) {
		f, err := os.Open(FILE)
		if err != nil {
			if os.IsNotExist(err) {
				w.Header().Set("Content-Type", "application/json")
				_ = json.NewEncoder(w).Encode([]Feedback{})
				return
			}

			http.Error(w, "file open failed: "+err.Error(), http.StatusInternalServerError)
			return
		}
		defer f.Close()

		var items []Feedback

		scanner := bufio.NewScanner(f)
		for scanner.Scan() {
			line := scanner.Bytes()
			if len(line) == 0 {
				continue
			}

			var fb Feedback
			if err := json.Unmarshal(line, &fb); err != nil {
				// continue
				http.Error(w, "invalid ndjson line: "+err.Error(), http.StatusInternalServerError)
				return
			}
			items = append(items, fb)
		}

		if err := scanner.Err(); err != nil {
			http.Error(w, "scanner error: "+err.Error(), http.StatusInternalServerError)
			return
		}

		w.Header().Set("Content-Type", "application/json")
		w.WriteHeader(http.StatusOK)
		_ = json.NewEncoder(w).Encode(items)
	})

	// POST
	mux.HandleFunc("POST /feedback", func(w http.ResponseWriter, r *http.Request) {
		var fb Feedback
		if err := json.NewDecoder(r.Body).Decode(&fb); err != nil {
			http.Error(w, "invalid json: "+err.Error(), http.StatusBadRequest)
			return
		}

		fb.Name = strings.TrimSpace(fb.Name)
		fb.Message = strings.TrimSpace(fb.Message)

		if fb.Name == "" || fb.Message == "" {
			http.Error(w, "name and message is required", http.StatusBadRequest)
			return
		}
		if fb.Rating < 1 || fb.Rating > 5 {
			http.Error(w, "rating should be between 1-5", http.StatusBadRequest)
			return
		}

		if fb.Timestamp.IsZero() {
			fb.Timestamp = time.Now().UTC()
		}

		// Add to queue
		select {
		case feedbackChan <- fb:
			w.Header().Set("Content-Type", "application/json")
			w.WriteHeader(http.StatusCreated)
			_ = json.NewEncoder(w).Encode(map[string]string{"status": "queued"})
			return
		default:
			http.Error(w, "queue full, try again", http.StatusServiceUnavailable)
			return
		}
	})

	server := &http.Server{
		Addr:              PORT,
		Handler:           mux,
		ReadHeaderTimeout: 5 * time.Second,
	}

	log.Printf("server listening on http://localhost%s", PORT)

	go func() {
		ch := make(chan os.Signal, 1)
		signal.Notify(ch, os.Interrupt, syscall.SIGTERM)
		<-ch

		log.Println("shutdown requested")
		cancel()

		ctxTimeout, cancelTimeout := context.WithTimeout(context.Background(), 5*time.Second)
		defer cancelTimeout()
		_ = server.Shutdown(ctxTimeout)
	}()

	if err := server.ListenAndServe(); err != nil && err != http.ErrServerClosed {
		log.Fatalf("server failed: %v", err)
	}
}

func fileWriterLoop(ctx context.Context, path string, in <-chan Feedback) {
	f, err := os.OpenFile(path, os.O_CREATE|os.O_APPEND|os.O_WRONLY, 0644)
	if err != nil {
		log.Fatalf("writer: openfile failed: %v", err)
	}
	defer f.Close()

	writer := bufio.NewWriterSize(f, 64*1024)
	enc := json.NewEncoder(writer)

	flushTicker := time.NewTicker(500 * time.Millisecond)
	defer flushTicker.Stop()

	for {
		select {
		case <-ctx.Done():
			drainAndFlush(enc, writer, in)
			return
		case fb := <-in:
			if err := enc.Encode(fb); err != nil {
				log.Printf("writer: encode failed: %v", err)
			}
		case <-flushTicker.C:
			if err := writer.Flush(); err != nil {
				log.Printf("writer: flush failed: %v", err)
			}
		}
	}
}

func drainAndFlush(enc *json.Encoder, w *bufio.Writer, in <-chan Feedback) {
	for {
		select {
		case fb := <-in:
			if err := enc.Encode(fb); err != nil {
				log.Printf("writer: encode failed during drain: %v", err)
			}
		default:
			if err := w.Flush(); err != nil {
				log.Printf("writer: flush failed during draing: %v", err)
			}
			return
		}
	}
}