import java.util.ArrayDeque;

import java.util.BitSet;

import java.util.Deque;

import java.util.Map;

import java.util.concurrent.TimeUnit;

import static sun.nio.ch.KQueue.EVFILT_READ;

import static sun.nio.ch.KQueue.EVFILT_WRITE;

import static sun.nio.ch.KQueue.EV_ADD;

import static sun.nio.ch.KQueue.EV_DELETE;

/**

 * KQueue based Selector implementation for macOS

 */

class KQueueSelectorImpl extends SelectorImpl {

    // maximum number of events to poll in one call to kqueue

    private static final int MAX_KEVENTS = 256;

    // kqueue file descriptor

    private final int kqfd;

    // address of poll array (event list) when polling for pending events

    private final long pollArrayAddress;

    // file descriptors used for interrupt

    // maps file descriptor to selection key, synchronize on selector

    private final Map<Integer, SelectionKeyImpl> fdToKey = new HashMap<>();

    // file descriptors registered with kqueue, synchronize on selector

    private final BitSet registeredReadFilter = new BitSet();

    private final BitSet registeredWriteFilter = new BitSet();

    // pending new registrations/updates, queued by implRegister and putEventOps

    private final Object updateLock = new Object();

    private final Deque<SelectionKeyImpl> newKeys = new ArrayDeque<>();

    private final Deque<SelectionKeyImpl> updateKeys = new ArrayDeque<>();

    private final Deque<Integer> updateOps = new ArrayDeque<>();

    // interrupt triggering and clearing

    private int pollCount;

        this.kqfd = KQueue.create();

        this.pollArrayAddress = KQueue.allocatePollArray(MAX_KEVENTS);

            long fds = IOUtil.makePipe(false);

            this.fd0 = (int) (fds >>> 32);

            this.fd1 = (int) fds;

        } catch (IOException ioe) {

            KQueue.freePollArray(pollArrayAddress);

            FileDispatcherImpl.closeIntFD(kqfd);

            throw ioe;

        // register one end of the socket pair for wakeups

        KQueue.register(kqfd, fd0, EVFILT_READ, EV_ADD);

        if (!isOpen())

    protected int doSelect(long timeout) throws IOException {

        assert Thread.holdsLock(this);

        processUpdateQueue();

            long to = Math.min(timeout, Integer.MAX_VALUE);  // max kqueue timeout

            boolean timedPoll = (to > 0);

            do {

                long startTime = timedPoll ? System.nanoTime() : 0;

                numEntries = KQueue.poll(kqfd, pollArrayAddress, MAX_KEVENTS, to);

                if (numEntries == IOStatus.INTERRUPTED && timedPoll) {

                    // timed poll interrupted so need to adjust timeout

                    long adjust = System.nanoTime() - startTime;

                    to -= TimeUnit.MILLISECONDS.convert(adjust, TimeUnit.NANOSECONDS);

                    if (to <= 0) {

                        // timeout expired so no retry

                        numEntries = 0;

                    }

                }

            } while (numEntries == IOStatus.INTERRUPTED);

            assert IOStatus.check(numEntries);

     * Process new registrations and changes to the interest ops.

     */

    private void processUpdateQueue() {

        assert Thread.holdsLock(this);

        synchronized (updateLock) {

            SelectionKeyImpl ski;

            // new registrations

            while ((ski = newKeys.pollFirst()) != null) {

                if (ski.isValid()) {

                    SelChImpl ch = ski.channel;

                    int fd = ch.getFDVal();

                    SelectionKeyImpl previous = fdToKey.put(fd, ski);

                    assert previous == null;

                    assert registeredReadFilter.get(fd) == false;

                    assert registeredWriteFilter.get(fd) == false;

                }

            }

            // changes to interest ops

            assert updateKeys.size() == updateOps.size();

            while ((ski = updateKeys.pollFirst()) != null) {

                int ops = updateOps.pollFirst();

                int fd = ski.channel.getFDVal();

                if (ski.isValid() && fdToKey.containsKey(fd)) {

                    // add or delete interest in read events

                    if (registeredReadFilter.get(fd)) {

                        if ((ops & Net.POLLIN) == 0) {

                            KQueue.register(kqfd, fd, EVFILT_READ, EV_DELETE);

                            registeredReadFilter.clear(fd);

                        }

                    } else if ((ops & Net.POLLIN) != 0) {

                        KQueue.register(kqfd, fd, EVFILT_READ, EV_ADD);

                        registeredReadFilter.set(fd);

                    }

                    // add or delete interest in write events

                    if (registeredWriteFilter.get(fd)) {

                        if ((ops & Net.POLLOUT) == 0) {

                            KQueue.register(kqfd, fd, EVFILT_WRITE, EV_DELETE);

                            registeredWriteFilter.clear(fd);

                        }

                    } else if ((ops & Net.POLLOUT) != 0) {

                        KQueue.register(kqfd, fd, EVFILT_WRITE, EV_ADD);

                        registeredWriteFilter.set(fd);

                    }

                }

            }

        }

    }

    /**

    private int updateSelectedKeys(int numEntries) throws IOException {

        assert Thread.holdsLock(this);

        assert Thread.holdsLock(nioSelectedKeys());

        // filter and so there may be more than one event for a fd. The poll

        // count is incremented here and compared against the SelectionKey's

        // "lastPolled" field. This ensures that the ready ops is updated rather

        // than replaced when a file descriptor is polled by both the read and

        // write filter.

        pollCount++;

            long kevent = KQueue.getEvent(pollArrayAddress, i);

            int fd = KQueue.getDescriptor(kevent);

            if (fd == fd0) {

                SelectionKeyImpl ski = fdToKey.get(fd);

                if (ski != null) {

                    int rOps = 0;

                    short filter = KQueue.getFilter(kevent);

                    if (filter == EVFILT_READ) {

                        rOps |= Net.POLLIN;

                    } else if (filter == EVFILT_WRITE) {

                        rOps |= Net.POLLOUT;

                    }

                        // file descriptor may be polled more than once per poll

                        if (ski.lastPolled != pollCount) {

                                ski.lastPolled = pollCount;

                            ski.lastPolled = pollCount;

        assert !isOpen();

        assert Thread.holdsLock(this);

        assert Thread.holdsLock(nioKeys());

        // prevent further wakeup

        synchronized (interruptLock) {

            interruptTriggered = true;

        }

        FileDispatcherImpl.closeIntFD(kqfd);

        KQueue.freePollArray(pollArrayAddress);

        FileDispatcherImpl.closeIntFD(fd0);

        FileDispatcherImpl.closeIntFD(fd1);

        // Deregister channels

        Iterator<SelectionKey> i = keys.iterator();

        while (i.hasNext()) {

            SelectionKeyImpl ski = (SelectionKeyImpl)i.next();

            deregister(ski);

            SelectableChannel selch = ski.channel();

            if (!selch.isOpen() && !selch.isRegistered())

                ((SelChImpl)selch).kill();

            i.remove();

        assert Thread.holdsLock(nioKeys());

        synchronized (updateLock) {

            newKeys.addLast(ski);

        }

        assert !ski.isValid();

        assert Thread.holdsLock(this);

        assert Thread.holdsLock(nioKeys());

        assert Thread.holdsLock(nioSelectedKeys());

        fdToKey.remove(fd);

        if (registeredReadFilter.get(fd)) {

            KQueue.register(kqfd, fd, EVFILT_READ, EV_DELETE);

            registeredReadFilter.clear(fd);

        }

        if (registeredWriteFilter.get(fd)) {

            KQueue.register(kqfd, fd, EVFILT_WRITE, EV_DELETE);

            registeredWriteFilter.clear(fd);

        }

        selectedKeys.remove(ski);

        // remove from channel's key set

            ((SelChImpl) selch).kill();

        synchronized (updateLock) {

            updateOps.addLast(ops);   // ops first in case adding the key fails

            updateKeys.addLast(ski);

        }

                try {

                    IOUtil.write1(fd1, (byte)0);

                } catch (IOException ioe) {

                    throw new InternalError(ioe);

                }