function.go

package ghastly

import (
	"encoding/json"
	"net/http"
)

type Response struct {
	Body       any
	Headers    map[string]string
	StatusCode int
	Cookies    []http.Cookie
}

type Middleware[T any] func(state *T, response *Response, request *http.Request, next func(*T) *T, cancel func(*T)) *T

type Service[T any] interface {
	HandleRequest(*T, *Response, *http.Request) *T
}

type RegisteredHandler[T any] struct {
	Server      *Ghastly[T]
	Method      string
	Endpoint    string
	FullPath    string
	Middlewares []Middleware[T]
	Service     Service[T]
}

func run[T any](handler *RegisteredHandler[T], response *Response, request *http.Request, state *T, index int, cancelled bool) *T {
	if cancelled {
		return state
	}
	if index < len(handler.Middlewares) {
		return handler.Middlewares[index](state, response, request, func(state *T) *T {
			return run(handler, response, request, state, index+1, false)
		}, func(state *T) {
			run(handler, response, request, state, index, true)
		})
	} else {
		return handler.Service.HandleRequest(state, response, request)
	}
}

func (handler *RegisteredHandler[T]) ServeHTTP(responseWriter http.ResponseWriter, request *http.Request) {
	var state T
	response := &Response{
		StatusCode: -1,
	}

	_ = run(handler, response, request, &state, 0, false)

	if response.StatusCode == -1 {
		response.StatusCode = 200
	}

	responseWriter.WriteHeader(response.StatusCode)
	for _, cookie := range response.Cookies {
		http.SetCookie(responseWriter, &cookie)
	}

	for key, value := range response.Headers {
		responseWriter.Header().Add(key, value)
	}
	body, err := json.Marshal(response.Body)
	if err != nil {
		panic("error - failed marshaling body")
	}
	_, err = responseWriter.Write(body)
	if err != nil {
		panic("error -failed writing body")
	}
}