/*
 *  C eventloop example (c_eventloop.c).
 *
 *  ECMAScript code to initialize the exposed API (setTimeout() etc) when
 *  using the C eventloop.
 *
 *  https://developer.mozilla.org/en-US/docs/Web/JavaScript/Timers
 */

/*
 *  Timer API
 */

function setTimeout(func, delay) {
    var cb_func;
    var bind_args;
    var timer_id;

    // Delay can be optional at least in some contexts, so tolerate that.
    // https://developer.mozilla.org/en-US/docs/Web/API/WindowOrWorkerGlobalScope/setTimeout
    if (typeof delay !== 'number') {
        if (typeof delay === 'undefined') {
            delay = 0;
        } else {
            throw new TypeError('invalid delay');
        }
    }

    if (typeof func === 'string') {
        // Legacy case: callback is a string.
        cb_func = eval.bind(this, func);
    } else if (typeof func !== 'function') {
        throw new TypeError('callback is not a function/string');
    } else if (arguments.length > 2) {
        // Special case: callback arguments are provided.
        bind_args = Array.prototype.slice.call(arguments, 2);  // [ arg1, arg2, ... ]
        bind_args.unshift(this);  // [ global(this), arg1, arg2, ... ]
        cb_func = func.bind.apply(func, bind_args);
    } else {
        // Normal case: callback given as a function without arguments.
        cb_func = func;
    }

    timer_id = EventLoop.createTimer(cb_func, delay, true /*oneshot*/);

    return timer_id;
}

function clearTimeout(timer_id) {
    if (typeof timer_id !== 'number') {
        throw new TypeError('timer ID is not a number');
    }
    var success = EventLoop.deleteTimer(timer_id);  /* retval ignored */
}

function setInterval(func, delay) {
    var cb_func;
    var bind_args;
    var timer_id;

    if (typeof delay !== 'number') {
        if (typeof delay === 'undefined') {
            delay = 0;
        } else {
            throw new TypeError('invalid delay');
        }
    }

    if (typeof func === 'string') {
        // Legacy case: callback is a string.
        cb_func = eval.bind(this, func);
    } else if (typeof func !== 'function') {
        throw new TypeError('callback is not a function/string');
    } else if (arguments.length > 2) {
        // Special case: callback arguments are provided.
        bind_args = Array.prototype.slice.call(arguments, 2);  // [ arg1, arg2, ... ]
        bind_args.unshift(this);  // [ global(this), arg1, arg2, ... ]
        cb_func = func.bind.apply(func, bind_args);
    } else {
        // Normal case: callback given as a function without arguments.
        cb_func = func;
    }

    timer_id = EventLoop.createTimer(cb_func, delay, false /*oneshot*/);

    return timer_id;
}

function clearInterval(timer_id) {
    if (typeof timer_id !== 'number') {
        throw new TypeError('timer ID is not a number');
    }
    EventLoop.deleteTimer(timer_id);
}

function requestEventLoopExit() {
    EventLoop.requestExit();
}

/*
 *  Socket handling
 *
 *  Ideally this would be implemented more in C than here for more speed
 *  and smaller footprint: C code would directly maintain the callback state
 *  and such.
 *
 *  Also for more optimal I/O, the buffer churn caused by allocating and
 *  freeing a lot of buffer values could be eliminated by reusing buffers.
 *  Socket reads would then go into a pre-allocated buffer, for instance.
 */

EventLoop.socketListening = {};
EventLoop.socketReading = {};
EventLoop.socketConnecting = {};

EventLoop.fdPollHandler = function(fd, revents) {
    var data;
    var cb;
    var rc;
    var acc_res;

    //print('activity on fd', fd, 'revents', revents);

    if (revents & Poll.POLLIN) {
        cb = this.socketReading[fd];
        if (cb) {
            data = Socket.read(fd);  // no size control now
            //print('READ', Duktape.enc('jx', data));
            if (data.length === 0) {
                this.close(fd);
                return;
            }
            cb(fd, data);
        } else {
            cb = this.socketListening[fd];
            if (cb) {
                acc_res = Socket.accept(fd);
                //print('ACCEPT:', Duktape.enc('jx', acc_res));
                cb(acc_res.fd, acc_res.addr, acc_res.port);
            } else {
                //print('UNKNOWN');
            }
        }
    }

    if (revents & Poll.POLLOUT) {
        // Connected
        cb = this.socketConnecting[fd];
        if (cb) {
            delete this.socketConnecting[fd];
            cb(fd);
        }
    }

    if ((revents & ~(Poll.POLLIN | Poll.POLLOUT)) !== 0) {
        //print('unexpected revents, close fd');
        this.close(fd);
    }
}

EventLoop.server = function(address, port, cb_accepted) {
    var fd = Socket.createServerSocket(address, port);
    this.socketListening[fd] = cb_accepted;
    this.listenFd(fd, Poll.POLLIN);
}

EventLoop.connect = function(address, port, cb_connected) {
    var fd = Socket.connect(address, port);
    this.socketConnecting[fd] = cb_connected;
    this.listenFd(fd, Poll.POLLOUT);
}

EventLoop.close = function(fd) {
    EventLoop.listenFd(fd, 0);
    delete this.socketListening[fd];
    delete this.socketReading[fd];
    delete this.socketConnecting[fd];
    Socket.close(fd);
}

EventLoop.setReader = function(fd, cb_read) {
    this.socketReading[fd] = cb_read;
    this.listenFd(fd, Poll.POLLIN);
}

EventLoop.write = function(fd, data) {
    // This simple example doesn't have support for write blocking / draining
    if (typeof data === 'string') {
        data = new TextEncoder().encode(data);
    }
    var rc = Socket.write(fd, data);
}