package main

import (
	"context"

	"github.com/swaggest/fchi"
	"github.com/swaggest/fchi/middleware"
    "github.com/valyala/fasthttp"
)

func main() {
	r := fchi.NewRouter()
	r.Use(middleware.NoCache)
	r.Get("/", fchi.HandlerFunc(func(ctx context.Context, rc *fasthttp.RequestCtx) {
		rc.Write([]byte("welcome"))
	}))
	fasthttp.ListenAndServe(":3000", fchi.RequestHandler(r))
}

import (
  //...
  "context"
  "github.com/swaggest/fchi"
  "github.com/swaggest/fchi/middleware"
)

func main() {
  r := fchi.NewRouter()

  // A good base middleware stack
  r.Use(middleware.RequestID)
  r.Use(middleware.Recoverer)

  // Set a timeout value on the request context (ctx), that will signal
  // through ctx.Done() that the request has timed out and further
  // processing should be stopped.
  r.Use(middleware.Timeout(60 * time.Second))

  r.Get("/", fchi.HandlerFunc(func(ctx context.Context, rc *fasthttp.RequestCtx) {
    rc.Write([]byte("hi"))
  }))

  // RESTy routes for "articles" resource
  r.Route("/articles", func(r fchi.Router) {
    r.With(paginate).Get("/", fchi.HandlerFunc(listArticles))                           // GET /articles
    r.With(paginate).Get("/{month}-{day}-{year}", fchi.HandlerFunc(listArticlesByDate)) // GET /articles/01-16-2017

    r.Post("/", fchi.HandlerFunc(createArticle))                                        // POST /articles
    r.Get("/search", fchi.HandlerFunc(searchArticles))                                  // GET /articles/search

    // Regexp url parameters:
    r.Get("/{articleSlug:[a-z-]+}", fchi.HandlerFunc(getArticleBySlug))                // GET /articles/home-is-toronto

    // Subrouters:
    r.Route("/{articleID}", func(r fchi.Router) {
      r.Use(ArticleCtx)
      r.Get("/", fchi.HandlerFunc(getArticle))                                          // GET /articles/123
      r.Put("/", fchi.HandlerFunc(updateArticle))                                       // PUT /articles/123
      r.Delete("/", fchi.HandlerFunc(deleteArticle))                                    // DELETE /articles/123
    })
  })

  // Mount the admin sub-router
  r.Mount("/admin", adminRouter())

  fasthttp.ListenAndServe(":3333", fchi.RequestHandler(r))
}

func ArticleCtx(next fchi.Handler) fchi.Handler {
  return fchi.HandlerFunc(func(ctx context.Context, rc *fasthttp.RequestCtx) {
    articleID := fchi.URLParam(rc, "articleID")
    article, err := dbGetArticle(articleID)
    if err != nil {
      rc.Error(http.StatusText(404), 404)
      return
    }
    ctx = context.WithValue(ctx, "article", article)
    next.ServeHTTP(ctx, rc)
  })
}

func getArticle(ctx context.Context, rc *fasthttp.RequestCtx) {
  article, ok := ctx.Value("article").(*Article)
  if !ok {
    rc.Error(http.StatusText(422), 422)
    return
  }
  rc.Write([]byte(fmt.Sprintf("title:%s", article.Title)))
}

// A completely separate router for administrator routes
func adminRouter() fchi.Handler {
  r := chi.NewRouter()
  r.Use(AdminOnly)
  r.Get("/", fchi.HandlerFunc(adminIndex))
  r.Get("/accounts", fchi.HandlerFunc(adminListAccounts))
  return r
}

func AdminOnly(next fchi.Handler) fchi.Handler {
  return fchi.HandlerFunc(func(ctx context.Context, rc *fasthttp.RequestCtx) {
    perm, ok := ctx.Value("acl.permission").(YourPermissionType)
    if !ok || !perm.IsAdmin() {
      rc.Error(http.StatusText(403), 403)
      return
    }
    next.ServeHTTP(ctx, rc)
  })
}

// Router consisting of the core routing methods used by chi's Mux.
type Router interface {
	fchi.Handler
	Routes

	// Use appends one or more middlewares onto the Router stack.
	Use(middlewares ...func(fchi.Handler) fchi.Handler)

	// With adds inline middlewares for an endpoint handler.
	With(middlewares ...func(fchi.Handler) fchi.Handler) Router

	// Group adds a new inline-Router along the current routing
	// path, with a fresh middleware stack for the inline-Router.
	Group(fn func(r Router)) Router

	// Route mounts a sub-Router along a `pattern`` string.
	Route(pattern string, fn func(r Router)) Router

	// Mount attaches another fchi.Handler along ./pattern/*
	Mount(pattern string, h fchi.Handler)

	// Handle and HandleFunc adds routes for `pattern` that matches
	// all HTTP methods.
	Handle(pattern string, h fchi.Handler)

	// Method and MethodFunc adds routes for `pattern` that matches
	// the `method` HTTP method.
	Method(method, pattern string, h fchi.Handler)

	// HTTP-method routing along `pattern`
	Connect(pattern string, h fchi.HandlerFunc)
	Delete(pattern string, h fchi.HandlerFunc)
	Get(pattern string, h fchi.HandlerFunc)
	Head(pattern string, h fchi.HandlerFunc)
	Options(pattern string, h fchi.HandlerFunc)
	Patch(pattern string, h fchi.HandlerFunc)
	Post(pattern string, h fchi.HandlerFunc)
	Put(pattern string, h fchi.HandlerFunc)
	Trace(pattern string, h fchi.HandlerFunc)

	// NotFound defines a handler to respond whenever a route could
	// not be found.
	NotFound(h fchi.HandlerFunc)

	// MethodNotAllowed defines a handler to respond whenever a method is
	// not allowed.
	MethodNotAllowed(h fchi.HandlerFunc)
}

// Routes interface adds two methods for router traversal, which is also
// used by the github.com/go-chi/docgen package to generate documentation for Routers.
type Routes interface {
	// Routes returns the routing tree in an easily traversable structure.
	Routes() []Route

	// Middlewares returns the list of middlewares in use by the router.
	Middlewares() Middlewares

	// Match searches the routing tree for a handler that matches
	// the method/path - similar to routing a http request, but without
	// executing the handler thereafter.
	Match(rctx *Context, method, path string) bool
}

// HTTP middleware setting a value on the request context
func MyMiddleware(next fchi.Handler) fchi.Handler {
  return fchi.HandlerFunc(func(ctx context.Context, rc *fasthttp.RequestCtx) {
    ctx = context.WithValue(r.Context(), "user", "123")
    next.ServeHTTP(ctx, rc)
  })
}

// HTTP handler accessing data from the request context.
func MyRequestHandler(ctx context.Context, rc *fasthttp.RequestCtx) {
  user := ctx.Value("user").(string)
  rc.Write([]byte(fmt.Sprintf("hi %s", user)))
}

// HTTP handler accessing the url routing parameters.
func MyRequestHandler(ctx context.Context, rc *fasthttp.RequestCtx) {
  userID := fchi.URLParam(rc, "userID") // from a route like /users/{userID}

  key := ctx.Value("key").(string)

  rc.Write([]byte(fmt.Sprintf("hi %v, %v", userID, key)))
}