package registry

import (
	"net/http"

	"github.com/docker/docker-registry/configuration"

	log "github.com/Sirupsen/logrus"
	"github.com/gorilla/mux"
)

// App is a global registry application object. Shared resources can be placed
// on this object that will be accessible from all requests. Any writable
// fields should be protected.
type App struct {
	Config configuration.Configuration

	router *mux.Router
}

// NewApp takes a configuration and returns a configured app, ready to serve
// requests. The app only implements ServeHTTP and can be wrapped in other
// handlers accordingly.
func NewApp(configuration configuration.Configuration) *App {
	app := &App{
		Config: configuration,
		router: v2APIRouter(),
	}

	// Register the handler dispatchers.
	app.register(routeNameImageManifest, imageManifestDispatcher)
	app.register(routeNameBlob, layerDispatcher)
	app.register(routeNameTags, tagsDispatcher)
	app.register(routeNameBlobUpload, layerUploadDispatcher)
	app.register(routeNameBlobUploadResume, layerUploadDispatcher)

	return app
}

func (app *App) ServeHTTP(w http.ResponseWriter, r *http.Request) {
	app.router.ServeHTTP(w, r)
}

// register a handler with the application, by route name. The handler will be
// passed through the application filters and context will be constructed at
// request time.
func (app *App) register(routeName string, dispatch dispatchFunc) {

	// TODO(stevvooe): This odd dispatcher/route registration is by-product of
	// some limitations in the gorilla/mux router. We are using it to keep
	// routing consistent between the client and server, but we may want to
	// replace it with manual routing and structure-based dispatch for better
	// control over the request execution.

	app.router.GetRoute(routeName).Handler(app.dispatcher(dispatch))
}

// dispatchFunc takes a context and request and returns a constructed handler
// for the route. The dispatcher will use this to dynamically create request
// specific handlers for each endpoint without creating a new router for each
// request.
type dispatchFunc func(ctx *Context, r *http.Request) http.Handler

// TODO(stevvooe): dispatchers should probably have some validation error
// chain with proper error reporting.

// dispatcher returns a handler that constructs a request specific context and
// handler, using the dispatch factory function.
func (app *App) dispatcher(dispatch dispatchFunc) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		vars := mux.Vars(r)
		context := &Context{
			App:  app,
			Name: vars["name"],
		}

		// Store vars for underlying handlers.
		context.vars = vars

		context.log = log.WithField("name", context.Name)
		handler := dispatch(context, r)

		context.log.Infoln("handler", resolveHandlerName(r.Method, handler))
		handler.ServeHTTP(w, r)

		// Automated error response handling here. Handlers may return their
		// own errors if they need different behavior (such as range errors
		// for layer upload).
		if len(context.Errors.Errors) > 0 {
			w.WriteHeader(http.StatusBadRequest)
			serveJSON(w, context.Errors)
		}
	})
}