//go:build go1.22

// Package api provides primitives to interact with the openapi HTTP API.
//
// Code generated by github.com/oapi-codegen/oapi-codegen/v2 version v2.8.0 DO NOT EDIT.
package api

import (
	"errors"
	"fmt"
	"net/http"

	"github.com/oapi-codegen/runtime"
)

// ServerInterface represents all server handlers.
type ServerInterface interface {
	// LoginUser Authenticate user and return token
	// (POST /v1/auth/login)
	LoginUser(w http.ResponseWriter, r *http.Request)
	// RegisterUser Register a new user
	// (POST /v1/auth/register)
	RegisterUser(w http.ResponseWriter, r *http.Request)
	// ListInstances List all Elasticsearch instances
	// (GET /v1/elasticsearch/instances)
	ListInstances(w http.ResponseWriter, r *http.Request)
	// CreateInstance Create a new Elasticsearch instance
	// (POST /v1/elasticsearch/instances)
	CreateInstance(w http.ResponseWriter, r *http.Request)
	// DeleteInstance Delete an Elasticsearch instance
	// (DELETE /v1/elasticsearch/instances/{instanceId})
	DeleteInstance(w http.ResponseWriter, r *http.Request, instanceId string)
	// GetInstance Get details of a specific instance
	// (GET /v1/elasticsearch/instances/{instanceId})
	GetInstance(w http.ResponseWriter, r *http.Request, instanceId string)
	// GetInstanceLogs Get operation logs for a specific instance
	// (GET /v1/elasticsearch/instances/{instanceId}/logs)
	GetInstanceLogs(w http.ResponseWriter, r *http.Request, instanceId string)
	// SearchDocs Search documents in an index
	// (GET /v1/search/{instanceId}/docs)
	SearchDocs(w http.ResponseWriter, r *http.Request, instanceId string, params SearchDocsParams)
	// IndexDoc Index a text document
	// (POST /v1/search/{instanceId}/docs)
	IndexDoc(w http.ResponseWriter, r *http.Request, instanceId string)
	// DeleteDoc Delete a document
	// (DELETE /v1/search/{instanceId}/docs/{docId})
	DeleteDoc(w http.ResponseWriter, r *http.Request, instanceId string, docId string, params DeleteDocParams)
	// ListIndices List indices in an Elasticsearch instance
	// (GET /v1/search/{instanceId}/indices)
	ListIndices(w http.ResponseWriter, r *http.Request, instanceId string)
}

// ServerInterfaceWrapper converts contexts to parameters.
type ServerInterfaceWrapper struct {
	Handler            ServerInterface
	HandlerMiddlewares []MiddlewareFunc
	ErrorHandlerFunc   func(w http.ResponseWriter, r *http.Request, err error)
}

type MiddlewareFunc func(http.Handler) http.Handler

// LoginUser operation middleware
func (siw *ServerInterfaceWrapper) LoginUser(w http.ResponseWriter, r *http.Request) {

	handler := http.Handler(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		siw.Handler.LoginUser(w, r)
	}))

	for _, middleware := range siw.HandlerMiddlewares {
		handler = middleware(handler)
	}

	handler.ServeHTTP(w, r)
}

// RegisterUser operation middleware
func (siw *ServerInterfaceWrapper) RegisterUser(w http.ResponseWriter, r *http.Request) {

	handler := http.Handler(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		siw.Handler.RegisterUser(w, r)
	}))

	for _, middleware := range siw.HandlerMiddlewares {
		handler = middleware(handler)
	}

	handler.ServeHTTP(w, r)
}

// ListInstances operation middleware
func (siw *ServerInterfaceWrapper) ListInstances(w http.ResponseWriter, r *http.Request) {

	handler := http.Handler(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		siw.Handler.ListInstances(w, r)
	}))

	for _, middleware := range siw.HandlerMiddlewares {
		handler = middleware(handler)
	}

	handler.ServeHTTP(w, r)
}

// CreateInstance operation middleware
func (siw *ServerInterfaceWrapper) CreateInstance(w http.ResponseWriter, r *http.Request) {

	handler := http.Handler(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		siw.Handler.CreateInstance(w, r)
	}))

	for _, middleware := range siw.HandlerMiddlewares {
		handler = middleware(handler)
	}

	handler.ServeHTTP(w, r)
}

// DeleteInstance operation middleware
func (siw *ServerInterfaceWrapper) DeleteInstance(w http.ResponseWriter, r *http.Request) {

	var err error
	_ = err

	// ------------- Path parameter "instanceId" -------------
	var instanceId string

	err = runtime.BindStyledParameterWithOptions("simple", "instanceId", r.PathValue("instanceId"), &instanceId, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true, Type: "string", Format: "", ValueIsUnescaped: true})
	if err != nil {
		siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "instanceId", Err: err})
		return
	}

	handler := http.Handler(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		siw.Handler.DeleteInstance(w, r, instanceId)
	}))

	for _, middleware := range siw.HandlerMiddlewares {
		handler = middleware(handler)
	}

	handler.ServeHTTP(w, r)
}

// GetInstance operation middleware
func (siw *ServerInterfaceWrapper) GetInstance(w http.ResponseWriter, r *http.Request) {

	var err error
	_ = err

	// ------------- Path parameter "instanceId" -------------
	var instanceId string

	err = runtime.BindStyledParameterWithOptions("simple", "instanceId", r.PathValue("instanceId"), &instanceId, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true, Type: "string", Format: "", ValueIsUnescaped: true})
	if err != nil {
		siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "instanceId", Err: err})
		return
	}

	handler := http.Handler(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		siw.Handler.GetInstance(w, r, instanceId)
	}))

	for _, middleware := range siw.HandlerMiddlewares {
		handler = middleware(handler)
	}

	handler.ServeHTTP(w, r)
}

// GetInstanceLogs operation middleware
func (siw *ServerInterfaceWrapper) GetInstanceLogs(w http.ResponseWriter, r *http.Request) {

	var err error
	_ = err

	// ------------- Path parameter "instanceId" -------------
	var instanceId string

	err = runtime.BindStyledParameterWithOptions("simple", "instanceId", r.PathValue("instanceId"), &instanceId, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true, Type: "string", Format: "", ValueIsUnescaped: true})
	if err != nil {
		siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "instanceId", Err: err})
		return
	}

	handler := http.Handler(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		siw.Handler.GetInstanceLogs(w, r, instanceId)
	}))

	for _, middleware := range siw.HandlerMiddlewares {
		handler = middleware(handler)
	}

	handler.ServeHTTP(w, r)
}

// SearchDocs operation middleware
func (siw *ServerInterfaceWrapper) SearchDocs(w http.ResponseWriter, r *http.Request) {

	var err error
	_ = err

	// ------------- Path parameter "instanceId" -------------
	var instanceId string

	err = runtime.BindStyledParameterWithOptions("simple", "instanceId", r.PathValue("instanceId"), &instanceId, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true, Type: "string", Format: "", ValueIsUnescaped: true})
	if err != nil {
		siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "instanceId", Err: err})
		return
	}

	// Parameter object where we will unmarshal all parameters from the context
	var params SearchDocsParams

	// ------------- Required query parameter "q" -------------

	err = runtime.BindQueryParameterWithOptions("form", true, true, "q", r.URL.Query(), &params.Q, runtime.BindQueryParameterOptions{Type: "string", Format: ""})
	if err != nil {
		var requiredError *runtime.RequiredParameterError
		if errors.As(err, &requiredError) {
			siw.ErrorHandlerFunc(w, r, &RequiredParamError{ParamName: "q"})
		} else {
			siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "q", Err: err})
		}
		return
	}

	// ------------- Optional query parameter "index" -------------

	err = runtime.BindQueryParameterWithOptions("form", true, false, "index", r.URL.Query(), &params.Index, runtime.BindQueryParameterOptions{Type: "string", Format: ""})
	if err != nil {
		var requiredError *runtime.RequiredParameterError
		if errors.As(err, &requiredError) {
			siw.ErrorHandlerFunc(w, r, &RequiredParamError{ParamName: "index"})
		} else {
			siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "index", Err: err})
		}
		return
	}

	handler := http.Handler(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		siw.Handler.SearchDocs(w, r, instanceId, params)
	}))

	for _, middleware := range siw.HandlerMiddlewares {
		handler = middleware(handler)
	}

	handler.ServeHTTP(w, r)
}

// IndexDoc operation middleware
func (siw *ServerInterfaceWrapper) IndexDoc(w http.ResponseWriter, r *http.Request) {

	var err error
	_ = err

	// ------------- Path parameter "instanceId" -------------
	var instanceId string

	err = runtime.BindStyledParameterWithOptions("simple", "instanceId", r.PathValue("instanceId"), &instanceId, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true, Type: "string", Format: "", ValueIsUnescaped: true})
	if err != nil {
		siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "instanceId", Err: err})
		return
	}

	handler := http.Handler(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		siw.Handler.IndexDoc(w, r, instanceId)
	}))

	for _, middleware := range siw.HandlerMiddlewares {
		handler = middleware(handler)
	}

	handler.ServeHTTP(w, r)
}

// DeleteDoc operation middleware
func (siw *ServerInterfaceWrapper) DeleteDoc(w http.ResponseWriter, r *http.Request) {

	var err error
	_ = err

	// ------------- Path parameter "instanceId" -------------
	var instanceId string

	err = runtime.BindStyledParameterWithOptions("simple", "instanceId", r.PathValue("instanceId"), &instanceId, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true, Type: "string", Format: "", ValueIsUnescaped: true})
	if err != nil {
		siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "instanceId", Err: err})
		return
	}

	// ------------- Path parameter "docId" -------------
	var docId string

	err = runtime.BindStyledParameterWithOptions("simple", "docId", r.PathValue("docId"), &docId, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true, Type: "string", Format: "", ValueIsUnescaped: true})
	if err != nil {
		siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "docId", Err: err})
		return
	}

	// Parameter object where we will unmarshal all parameters from the context
	var params DeleteDocParams

	// ------------- Required query parameter "index" -------------

	err = runtime.BindQueryParameterWithOptions("form", true, true, "index", r.URL.Query(), &params.Index, runtime.BindQueryParameterOptions{Type: "string", Format: ""})
	if err != nil {
		var requiredError *runtime.RequiredParameterError
		if errors.As(err, &requiredError) {
			siw.ErrorHandlerFunc(w, r, &RequiredParamError{ParamName: "index"})
		} else {
			siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "index", Err: err})
		}
		return
	}

	handler := http.Handler(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		siw.Handler.DeleteDoc(w, r, instanceId, docId, params)
	}))

	for _, middleware := range siw.HandlerMiddlewares {
		handler = middleware(handler)
	}

	handler.ServeHTTP(w, r)
}

// ListIndices operation middleware
func (siw *ServerInterfaceWrapper) ListIndices(w http.ResponseWriter, r *http.Request) {

	var err error
	_ = err

	// ------------- Path parameter "instanceId" -------------
	var instanceId string

	err = runtime.BindStyledParameterWithOptions("simple", "instanceId", r.PathValue("instanceId"), &instanceId, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true, Type: "string", Format: "", ValueIsUnescaped: true})
	if err != nil {
		siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "instanceId", Err: err})
		return
	}

	handler := http.Handler(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		siw.Handler.ListIndices(w, r, instanceId)
	}))

	for _, middleware := range siw.HandlerMiddlewares {
		handler = middleware(handler)
	}

	handler.ServeHTTP(w, r)
}

type UnescapedCookieParamError struct {
	ParamName string
	Err       error
}

func (e *UnescapedCookieParamError) Error() string {
	return fmt.Sprintf("error unescaping cookie parameter '%s'", e.ParamName)
}

func (e *UnescapedCookieParamError) Unwrap() error {
	return e.Err
}

type UnmarshalingParamError struct {
	ParamName string
	Err       error
}

func (e *UnmarshalingParamError) Error() string {
	return fmt.Sprintf("Error unmarshaling parameter %s as JSON: %s", e.ParamName, e.Err.Error())
}

func (e *UnmarshalingParamError) Unwrap() error {
	return e.Err
}

type RequiredParamError struct {
	ParamName string
}

func (e *RequiredParamError) Error() string {
	return fmt.Sprintf("Query argument %s is required, but not found", e.ParamName)
}

type RequiredHeaderError struct {
	ParamName string
	Err       error
}

func (e *RequiredHeaderError) Error() string {
	return fmt.Sprintf("Header parameter %s is required, but not found", e.ParamName)
}

func (e *RequiredHeaderError) Unwrap() error {
	return e.Err
}

type InvalidParamFormatError struct {
	ParamName string
	Err       error
}

func (e *InvalidParamFormatError) Error() string {
	return fmt.Sprintf("Invalid format for parameter %s: %s", e.ParamName, e.Err.Error())
}

func (e *InvalidParamFormatError) Unwrap() error {
	return e.Err
}

type TooManyValuesForParamError struct {
	ParamName string
	Count     int
}

func (e *TooManyValuesForParamError) Error() string {
	return fmt.Sprintf("Expected one value for %s, got %d", e.ParamName, e.Count)
}

// Handler creates http.Handler with routing matching OpenAPI spec.
func Handler(si ServerInterface) http.Handler {
	return HandlerWithOptions(si, StdHTTPServerOptions{})
}

// ServeMux is an abstraction of [http.ServeMux].
type ServeMux interface {
	HandleFunc(pattern string, handler func(http.ResponseWriter, *http.Request))
	http.Handler
}

type StdHTTPServerOptions struct {
	BaseURL          string
	BaseRouter       ServeMux
	Middlewares      []MiddlewareFunc
	ErrorHandlerFunc func(w http.ResponseWriter, r *http.Request, err error)
}

// HandlerFromMux creates http.Handler with routing matching OpenAPI spec based on the provided mux.
func HandlerFromMux(si ServerInterface, m ServeMux) http.Handler {
	return HandlerWithOptions(si, StdHTTPServerOptions{
		BaseRouter: m,
	})
}

func HandlerFromMuxWithBaseURL(si ServerInterface, m ServeMux, baseURL string) http.Handler {
	return HandlerWithOptions(si, StdHTTPServerOptions{
		BaseURL:    baseURL,
		BaseRouter: m,
	})
}

// HandlerWithOptions creates http.Handler with additional options
func HandlerWithOptions(si ServerInterface, options StdHTTPServerOptions) http.Handler {
	m := options.BaseRouter

	if m == nil {
		m = http.NewServeMux()
	}
	if options.ErrorHandlerFunc == nil {
		options.ErrorHandlerFunc = func(w http.ResponseWriter, r *http.Request, err error) {
			http.Error(w, err.Error(), http.StatusBadRequest)
		}
	}

	wrapper := ServerInterfaceWrapper{
		Handler:            si,
		HandlerMiddlewares: options.Middlewares,
		ErrorHandlerFunc:   options.ErrorHandlerFunc,
	}

	m.HandleFunc(http.MethodPost+" "+options.BaseURL+"/v1/auth/register", wrapper.RegisterUser)
	m.HandleFunc(http.MethodPost+" "+options.BaseURL+"/v1/auth/login", wrapper.LoginUser)
	m.HandleFunc(http.MethodGet+" "+options.BaseURL+"/v1/elasticsearch/instances", wrapper.ListInstances)
	m.HandleFunc(http.MethodPost+" "+options.BaseURL+"/v1/elasticsearch/instances", wrapper.CreateInstance)
	m.HandleFunc(http.MethodDelete+" "+options.BaseURL+"/v1/elasticsearch/instances/{instanceId}", wrapper.DeleteInstance)
	m.HandleFunc(http.MethodGet+" "+options.BaseURL+"/v1/elasticsearch/instances/{instanceId}", wrapper.GetInstance)
	m.HandleFunc(http.MethodGet+" "+options.BaseURL+"/v1/elasticsearch/instances/{instanceId}/logs", wrapper.GetInstanceLogs)
	m.HandleFunc(http.MethodGet+" "+options.BaseURL+"/v1/search/{instanceId}/docs", wrapper.SearchDocs)
	m.HandleFunc(http.MethodPost+" "+options.BaseURL+"/v1/search/{instanceId}/docs", wrapper.IndexDoc)
	m.HandleFunc(http.MethodGet+" "+options.BaseURL+"/v1/search/{instanceId}/indices", wrapper.ListIndices)
	m.HandleFunc(http.MethodDelete+" "+options.BaseURL+"/v1/search/{instanceId}/docs/{docId}", wrapper.DeleteDoc)

	return m
}