httpcrud

type Action interface {
	BeforeValidate() error // Prepare for input validation.
	Validate() error       // Validate the input.
	AfterValidate() error  // Post processing after the input has been validated.
	BeforeExecute() error  // Prepare for main task execution.
	Execute() error        // Execute the main task.
	AfterExecute() error   // Post processing after the main task has been executed.

	// Done is the last of the Action's methods to be invoked, it is special
	// in that regard that it will be invoked irrespective of whether or not
	// one of the preceding methods returned an error.
	//
	// The in error parameter will either be nil or it will hold the error
	// value returned by one of the preceding methods. The out error paremeter
	// is used as the final return value of the ExecuteAction function and this
	// gives Done the ability to override the error returned from one of those
	// preceding methods if need be.
	//
	// The IsDone value, when returned by any of the preceding methods,
	// will NOT be passed into Done.
	Done(in error) (out error)
}

type ErrorHandler interface {
	HandleError(w http.ResponseWriter, r *http.Request, err error)
}

type Handler interface {
	// Authenticate and authorize the incoming request.
	AuthCheck(r *http.Request, c context.Context) error
	// Read the input from the incoming request (headers, url, query, body).
	ReadRequest(r *http.Request, c context.Context) error
	// Prepare the response. In the general case this is unnecessary and
	// most handlers do not need to do anything in this method.
	//
	// However this method becomes useful when one needs to stream data,
	// more specifically it allows the Handler to setup the writer as the
	// destination for the data and then, piece by piece, the Handler can
	// send the data to the writer as it is being retrieved.
	InitResponse(w http.ResponseWriter) error
	// The meat of the Handler.
	Action
	// Write the output to the response (headers, body).
	WriteResponse(w http.ResponseWriter, r *http.Request) error
}

type HandlerInitializer interface {
	// Init returns a Handler instance (in general a new one).
	//
	// Init will be invoked once for every incoming request and the returned
	// Handler will be used to handle that request. As long as Init is implemented
	// to return a new Handler instance everytime it's invoked it is guaranteed
	// that each request will be handled by their own Handler instance.
	//
	// The given request can be used by the initializer to decide what type
	// of Handler to initialize. For example one could implement a common
	// version-specific handler initializer that would, based on the value
	// of the Accept header, choose which version of the handler to initialize.
	//
	//	type VersionHandlerInitializer struct {
	//		V0 HandlerInitializer
	//		V1 HandlerInitializer
	//		V2 HandlerInitializer
	//	}
	//
	//	func (v VersionHandlerInitializer) Init(r *http.Request) Handler {
	//		switch r.Header.Get("Accept") {
	//		case "application/vnd.example.v1":
	//			return v.V1.Init(r)
	//		case "application/vnd.example.v2":
	//			return v.V2.Init(r)
	//		}
	//		return v.V0.Init(r)
	//      }
	Init(r *http.Request) Handler
}

type HandlerInitializerAdapter interface {
	AdaptHandlerInitializer(hi interface{}, path, method string) HandlerInitializer
}

type NopAction struct {
	// contains filtered or unexported fields
}

type NopHandler struct {
	// contains filtered or unexported fields
}

type RouteList []struct {
	// The path pattern for which to register the HandlerInitializer.
	Path string
	// The HTTP method for which to register the HandlerInitializer.
	Method string
	// The HandlerInitializer to be registered.
	HandlerInitializer interface{}
}

type RouteOptions struct {
	// The HandlerInitializerAdapter to be used to convert the custom
	// route Handler value into an httpcrud.Handler.
	HandlerInitializerAdapter HandlerInitializerAdapter
	// The ErrorHandler to be used to handle errors returned
	// from the route Handlers.
	ErrorHandler ErrorHandler
	// The prefix to be applied to the routes' paths.
	PathPrefix string
}