import asyncdispatch, asynchttpserver

proc server() =
    var server = newAsyncHttpServer()

    proc timeoutCb(fd: AsyncFD) = echo "Timeout fd ", repr fd
    setTimeout(1000, timeoutCb) 

    proc cb(req: Request) {.async.} = echo "Request"   
    asyncCheck server.serve(Port(5555), cb)

    runForever()

FdTimer = ref object
    fd: AsyncFD   
    timeout: float  # milliseconds timeout

FdTimerTable = ref object
    fds: TableRef[AsyncFD, DoublyLinkedNode[FdTimer]]
    timers: DoublyLinkedList[FdTimer]                

proc newFdTimerTable(): FdTimerTable  = 
    new(result)
    result.fds = newTable[AsyncFD, DoublyLinkedNode[FdTimer]]()
    result.timers = initDoublyLinkedList[FdTimer]()

proc hasKey(tb: FdTimerTable, fd: AsyncFD): bool =
    result = tb.fds.hasKey(fd)

proc add(tb: FdTimerTable, fd: AsyncFD, timeout: float) =
    var timer = new(FdTimer)
    timer.fd = fd
    timer.timeout = timeout
    var node = newDoublyLinkedNode(timer) 
    tb.fds[fd] = node
    tb.timers.append(node)

proc del(tb: FdTimerTable, fd: AsyncFD) =
    var node = tb.fds[fd]
    tb.fds.del(fd)
    tb.timers.remove(node)

iterator items(tb: FdTimerTable) {.inline.} =
    for timer in tb.timers:
        yield timer 

# Modify PDispatcher
# `readTimers` and `readTimeout` to record `AsyncFD` may be timeout,  
PDispatcher* = ref object of PDispatcherBase
    selector: Selector
    readTimers: FdTimerTable
    readTimeout: int
    timeoutCb: proc(fd: AsyncFD) {.closure, gcsafe.}

proc newDispatcher*(): PDispatcher =
    new result
    result.selector = newSelector()
    result.timers = @[]
    result.readTimers = newFdTimerTable()


# Setting timeout before start server
proc setTimeout*(timeout: int, cb = proc(fd: AsyncFD) = discard) =
    let p = getGlobalDispatcher()
    p.readTimeout = timeout
    p.timeoutCb = cb 

# Record the `AsyncFD` that is expected to read
proc addTimeout(fd: AsyncFD) =
    let p = getGlobalDispatcher()
    if p.readTimeout > 0 and not p.readTimers.hasKey(fd):
        p.readTimers.add(fd, epochTime()   p.readTimeout / 1000)

# Delete the `AsyncFD` if successfully read in the expected time.
proc delTimeout(fd: AsyncFD) =
    let p = getGlobalDispatcher()
    if p.readTimers.hasKey(fd):
        p.readTimers.del(fd)

# Iterative the ordered table to check for the timeout `AsyncFD`. 
proc processReadTimers(p: PDispatcher) = 
    let now = epochTime()
    for timer in p.readTimers.items():
        if now < timer.timeout:
            break
        if now >= timer.timeout:
            echo "Timeout ", repr timer.fd
            timer.fd.closeSocket()
            p.readTimers.del(timer.fd)
            if not isNil(p.timeoutCb):
                p.timeoutCb(timer.fd)


proc poll*(timeout = 500) =
    ...
    processReadTimers(p)

proc recv*(socket: AsyncFD, size: int,
                 flags = {SocketFlag.SafeDisconn}): Future[string] =
    ...
    proc cb(sock: AsyncFD): bool =
        delTimeout(sock)
        ...
    addTimeout(socket)
    ...

proc recvInto*(socket: AsyncFD, buf: cstring, size: int,
                       flags = {SocketFlag.SafeDisconn}): Future[int] =
    ...
    proc cb(sock: AsyncFD): bool =
        delTimeout(sock)
        ...
    addTimeout(socket)
    ...

import asyncdispatch, asyncnet, asynchttpserver, os, net, threadpool

proc server() =
    var server = newAsyncHttpServer()

    proc timeoutCb(fd: AsyncFD) = echo "Timeout fd ", repr fd
    setTimeout(1000, timeoutCb) 

    proc cb(req: Request) {.async.} = echo "Request"   
    asyncCheck server.serve(Port(5555), cb)

    runForever()

proc request() =
    var client = newSocket()
    client.connect("127.0.0.1", Port(5555))
    client.send("GET /path HTTP/1.1\r\Lname:value")
    #sleep(3 * 1000)
    client.send("GET /path HTTP/1.1\r\Lname:value")

proc main() =
    parallel:
        spawn server()
        for i in 0..1:
            spawn request()
main()