package main

import (
    "io"
	"net/http"
	"log"
)

func main() {
    http.HandleFunc("/hello", func (w http.ResponseWriter, req *http.Request) {
		io.WriteString(w, "hello, world!\n")
	})
	log.Fatal(http.ListenAndServe(":12345", nil))
}

    Accept() (Conn, error)
    Close() error
    Addr() Addr

    // ask net to create a tcp listener and return us the interface
    lsn, err := net.Listen("tcp", ":8080")
    if err != nil {
        // handle error
    }
    // ensure that we're releasing the listener
    defer lsn.Close()
    for {
        type accepted struct {
            conn net.Conn
            err  error
        }
        // create a channel to
        c := make(chan accepted, 1)
        go func() {
            conn, err := lsn.Accept() // accept incoming connections
            c <- accepted{conn, err} // send the struct to the channel
        }()
        select {
            case a := <-c: // receive from the channel
                // if the error of the struct is not nil
                if a.err != nil {
                    // handle error and continue, for the next struct to get here
                    continue
                }
                // no error has occurred, we handle the connection
                go handleConnection(a.conn)
            case e := <-ev: // let's say we have a ev channel which transports shutdown requests
                // handle shutdown event
                return
        }
    }

    type(
        ServerEventType int

        srvEvDispatcher struct {
            lsns map[ServerEventType][]srvEvListner
            mu   sync.RWMutex
        }

        srvEvListner struct {
            ch chan ServerEventType
        }
        // a helper struct which embeds a waitgroup
        ServerEventHandler struct {
            sync.WaitGroup
            ch          chan ServerEventType // channel for receiving events
            handler     func()               // function which gets called if event is met
            eventType   ServerEventType      // which kind of event we're listening to
            willRemount bool                 // internal, so we can continuosly listen
        }
    )

    const(
        killListeners               ServerEventType = 0
        ServerServe                 ServerEventType = 1
        EnterRoundTripEvent         ServerEventType = 2
        RoundTripRetriedEvent       ServerEventType = 3
        PrePendingDialEvent         ServerEventType = 4
        PostPendingDialEvent        ServerEventType = 5
        WaitResLoopEvent            ServerEventType = 6
        ReadLoopBeforeNextReadEvent ServerEventType = 7
    )

    func (r *srvEvDispatcher) dispatch(event ServerEventType) {
    	if len(r.lsns[event]) == 0{
    	     return
        }
        r.mu.Lock()
        defer r.mu.Unlock()
        // for each listener of that event type
        for i := 0; i < len(r.lsns[event]); i++ {
            lisn := r.lsns[event][i]
            select {
            case lisn.ch <- event: // we're writting into the channel
            default:
            }
        }
    }
    // "mounting" the effective listener
    func (r *srvEvDispatcher) on(event ServerEventType) chan ServerEventType {
        r.mu.Lock()
        defer r.mu.Unlock()
        ch := make(chan ServerEventType, 1)
        r.lsns[event] = append(r.lsns[event], srvEvListner{ch: ch})
        return ch
    }
    // helper method that will receive an event via a channel, then mount itself to listen for more
    func (h ServerEventHandler) Next() {
        h.Add(1)
        go func() {
            defer h.Done()
            func() {
                switch <-h.ch {
                case h.eventType:
                    h.handler()
                case killListeners:
                    // on kill, we will not do "next" execution
                    h.willRemount = false
                }
            }()
        }()
        h.Wait()
        if h.willRemount {
            // next execution
            go h.Next()
        }
    }
    // usage "defer eventListener.Kill()". Will use a custom type that tells the above helper to stop mounting itself
    func (h ServerEventHandler) Kill() {
        h.ch <- killListeners
    }
    // called from tests, to listen for server events
    func ListenTestEvent(eventType ServerEventType, f func()) ServerEventHandler {
        wg := ServerEventHandler{ch: testEventsEmitter.on(eventType), handler: f, eventType: eventType, willRemount: true}
        // first execution
        go wg.Next()
        return wg
    }