package main

import (
	"context"
	"log"
	"net/http"
	"time"
)

const (
	contextTimeout = 3 * time.Second
	handlerTimeout = 5 * time.Second
)

func main() {
	listenAddr := "127.0.0.1:8080"
	log.Printf("Server is listening on [%s]...\n", listenAddr)

	http.Handle("/", middleware(sleep))
	log.Fatalln(http.ListenAndServe(listenAddr, nil))
}

func middleware(next http.HandlerFunc) http.HandlerFunc {
	return func(w http.ResponseWriter, r *http.Request) {
		ctx, _ := context.WithTimeout(r.Context(), contextTimeout)

		go next.ServeHTTP(w, r) // <-- passing parent context (r) instead of child (r.WithContext(ctx))

		<-ctx.Done()
	}
}

func sleep(w http.ResponseWriter, r *http.Request) {
	log.Println("Got request")

	timer := time.NewTimer(handlerTimeout)
	defer timer.Stop()

	select {
	case <-timer.C:
		log.Println("Timer expired")
	case <-r.Context().Done():
		log.Println("Context expired")
	}
}

    // Done returns a channel that's closed when work done on behalf of this
    // context should be canceled. Done may return nil if this context can
    // never be canceled. Successive calls to Done return the same value.
    //
    // WithCancel arranges for Done to be closed when cancel is called;
    // WithDeadline arranges for Done to be closed when the deadline
    // expires; WithTimeout arranges for Done to be closed when the timeout
    // elapses.
    //
    // Done is provided for use in select statements:
    //
    //  // Stream generates values with DoSomething and sends them to out
    //  // until DoSomething returns an error or ctx.Done is closed.
    //  func Stream(ctx context.Context, out chan<- Value) error {
    //  	for {
    //  		v, err := DoSomething(ctx)
    //  		if err != nil {
    //  			return err
    //  		}
    //  		select {
    //  		case <-ctx.Done():
    //  			return ctx.Err()
    //  		case out <- v:
    //  		}
    //  	}
    //  }
    //
    // See https://blog.golang.org/pipelines for more examples of how to use
    // a Done channel for cancelation.
    Done() <-chan struct{}

    // If Done is not yet closed, Err returns nil.
    // If Done is closed, Err returns a non-nil error explaining why:
    // Canceled if the context was canceled
    // or DeadlineExceeded if the context's deadline passed.
    // After Err returns a non-nil error, successive calls to Err return the same error.
    Err() error