main.go

package main

import (
	"encoding/json"
	"fmt"
	"math/rand"
	"net/http"
	"strconv"
	"strings"
	"sync"
	"time"
)

type Task struct {
	ID     int    `json:"id"`
	Input  string `json:"input"`
	Status string `json:"status"`
	Result string `json:"result"`
}

var tasks = make(map[int]Task)

func main() {

	taskQueueChan := make(chan *Task)

	resultQueueChan := make(chan *Task)

	wg := sync.WaitGroup{}
	wg.Add(4)

	go processTask(&wg, taskQueueChan, resultQueueChan)
	go processTask(&wg, taskQueueChan, resultQueueChan)
	go processTask(&wg, taskQueueChan, resultQueueChan)

	go resultListener(&wg, resultQueueChan)

	mux := http.NewServeMux()

	mux.HandleFunc("GET /health", health)
	mux.HandleFunc("POST /tasks", createTask(taskQueueChan))
	mux.HandleFunc("GET /tasks/{id}", getTask)

	http.ListenAndServe(":8080", mux)

}

func health(w http.ResponseWriter, r *http.Request) {
	w.WriteHeader(http.StatusOK)
	w.Write([]byte("Level 2 running"))

}

func createTask(taskQueueChan chan<- *Task) http.HandlerFunc {
	return func(w http.ResponseWriter, r *http.Request) {
		var req struct {
			Input string
		}

		dec := json.NewDecoder(r.Body)
		err := dec.Decode(&req)

		if err != nil {
			http.Error(w, "Invalid input format", http.StatusBadRequest)
			return
		}

		id := len(tasks) + 1
		status := "Pending"
		result := ""

		task := Task{
			ID:     id,
			Input:  req.Input,
			Status: status,
			Result: result,
		}
		taskQueueChan <- &task
		tasks[id] = task

		w.Header().Set("Content-Type", "application/json")
		w.WriteHeader(http.StatusCreated)
		json.NewEncoder(w).Encode("Task" + strconv.Itoa(task.ID) + "created")

	}

}

func getTask(w http.ResponseWriter, r *http.Request) {

	id, nerr := strconv.Atoi(r.PathValue("id"))

	if nerr != nil {
		http.Error(w, nerr.Error(), http.StatusInternalServerError)
		return
	}
	task, ok := tasks[id]

	if !ok {
		http.Error(w, "Task not found", http.StatusNotFound)
		return
	}

	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(http.StatusOK)
	r_err := json.NewEncoder(w).Encode(task)

	if r_err != nil {
		http.Error(w, "Task not found", http.StatusInternalServerError)
		return
	}

}
func processTask(wg *sync.WaitGroup, taskQueueChan <-chan *Task, resultQueueChan chan<- *Task) {
	defer wg.Done()

	for task := range taskQueueChan {

		task.Result = strings.ToUpper(task.Input)
		task.Status = "completed"
		resultQueueChan <- task

		time.Sleep(time.Duration(rand.Intn(400)) * time.Millisecond)
		fmt.Println("Task " + strconv.Itoa(task.ID) + " processed")

	}
}
func resultListener(wg *sync.WaitGroup, resultQueueChan <-chan *Task) {
	defer wg.Done()

	for task := range resultQueueChan {
		tasks[task.ID] = *task

		fmt.Println("Task " + strconv.Itoa(task.ID) + " completed. result: " + task.Result)

	}

}