package server

import (
	"errors"
	"io"
	"net/http"
	"unsafe"
)

// maxParams defines the maximum number of parameters per route.
const maxParams = 16

// Context represents the interface for a request & response context.
type Context interface {
	Bytes([]byte) error
	Error(messages ...any) error
	Get(param string) string
	Header(key string, value string)
	Host() string
	Method() string
	Next() error
	Path() string
	Protocol() string
	Reader(io.Reader) error
	RequestHeader(key string) string
	ResponseHeader(key string) string
	Status(status int) Context
	String(string) error
	Write([]byte) (int, error)
}

// ctx represents a request & response context.
type ctx struct {
	request      *http.Request
	response     http.ResponseWriter
	server       *Server
	paramNames   [maxParams]string
	paramValues  [maxParams]string
	paramCount   int
	handlerCount int
}

// newContext returns a new context from the pool.
func newContext(req *http.Request, res http.ResponseWriter, server *Server) *ctx {
	ctx := contextPool.Get().(*ctx)
	ctx.request = req
	ctx.response = res
	ctx.server = server
	ctx.paramCount = 0
	ctx.handlerCount = 0
	return ctx
}

// Bytes responds with a raw byte slice.
func (ctx *ctx) Bytes(body []byte) error {
	_, err := ctx.response.Write(body)
	return err
}

// Error is used for sending error messages to the client.
func (ctx *ctx) Error(messages ...any) error {
	var combined []error

	for _, msg := range messages {
		switch err := msg.(type) {
		case error:
			combined = append(combined, err)
		case string:
			combined = append(combined, errors.New(err))
		}
	}

	return errors.Join(combined...)
}

// Get retrieves a parameter.
func (ctx *ctx) Get(param string) string {
	for i := 0; i < ctx.paramCount; i++ {
		if ctx.paramNames[i] == param {
			return ctx.paramValues[i]
		}
	}

	return ""
}

// Next executes the next handler in the middleware chain.
func (ctx *ctx) Next() error {
	ctx.handlerCount++
	return ctx.server.handlers[ctx.handlerCount](ctx)
}

// RequestHeader returns the request header value for the given key.
func (ctx *ctx) RequestHeader(key string) string {
	return ctx.request.Header.Get(key)
}

// ResponseHeader returns the response header value for the given key.
func (ctx *ctx) ResponseHeader(key string) string {
	return ctx.response.Header().Get(key)
}

// Header sets the header value for the given key.
func (ctx *ctx) Header(key string, value string) {
	ctx.response.Header().Set(key, value)
}

// Method returns the request method.
func (ctx *ctx) Method() string {
	return ctx.request.Method
}

// Protocol returns the request protocol.
func (ctx *ctx) Protocol() string {
	return ctx.request.Proto
}

// Host returns the requested host.
func (ctx *ctx) Host() string {
	return ctx.request.Host
}

// Path returns the requested path.
func (ctx *ctx) Path() string {
	return ctx.request.URL.Path
}

// Reader sends the contents of the io.Reader without creating an in-memory copy.
func (ctx *ctx) Reader(reader io.Reader) error {
	_, err := io.Copy(ctx.response, reader)
	return err
}

// Status sets the HTTP status of the response.
func (ctx *ctx) Status(status int) Context {
	ctx.response.WriteHeader(status)
	return ctx
}

// String responds with the given string.
func (ctx *ctx) String(body string) error {
	slice := unsafe.Slice(unsafe.StringData(body), len(body))
	return ctx.Bytes(slice)
}

// Write implements the io.Writer interface.
func (ctx *ctx) Write(body []byte) (int, error) {
	return ctx.response.Write(body)
}

// addParameter adds a new parameter to the context.
func (ctx *ctx) addParameter(name string, value string) {
	ctx.paramNames[ctx.paramCount] = name
	ctx.paramValues[ctx.paramCount] = value
	ctx.paramCount++
}