module hunt.io.channel.AbstractChannel;

import hunt.event.selector.Selector;
import hunt.io.channel.Common;
import hunt.io.IoError;
import hunt.logging;
import hunt.util.worker;

import core.atomic;
import std.bitmanip;
import std.socket : socket_t;


/**
 *
 */
abstract class AbstractChannel : Channel {
    socket_t handle = socket_t.init;
    ErrorEventHandler errorHandler;
    
    Worker taskWorker = null;

    protected bool _isRegistered = false;
    private shared bool _isClosing = false;
    protected shared bool _isClosed = false;

    this(Selector loop, ChannelType type) {
        this._inLoop = loop;
        _type = type;
        _flags = BitArray([false, false, false, false, false, false, false,
                false, false, false, false, false, false, false, false, false]);
    }

    /**
     *
     */
    bool isRegistered() {
        return _isRegistered;
    }

    /**
     *
     */
    bool isClosing() {
        return _isClosing;
    }

    /**
     *
     */
    bool isClosed() {
        return _isClosed;
    }

    /**
     *
     */
    void close() {
        if (!_isClosed && cas(&_isClosing, false, true) ) {
            version (HUNT_IO_DEBUG_MORE)
                tracef("channel[fd=%d] closing...", this.handle);

            // closing
            doClose(); // close
            _isClosed = true;

            // closed
            onClose(); 
            _isClosing = false;
            version (HUNT_IO_DEBUG)
                tracef("channel[fd=%d] closed", this.handle);

        } else {
            version (HUNT_IO_DEBUG) {
                warningf("The channel[fd=%d] has already been closed (%s) or closing (%s)",
                 this.handle, _isClosed, _isClosing);
            }
        }
    }

    protected void doClose() {

    }

     void onClose() {
        version (HUNT_IO_DEBUG)
            tracef("onClose [fd=%d]...", this.handle);
        _isRegistered = false;
        _isClosed = true;
        clear();

        _inLoop.deregister(this);
        version (HUNT_IO_DEBUG_MORE)
            tracef("onClose done [fd=%d]...", this.handle);
    }

    protected void errorOccurred(ErrorCode code, string msg) {
        debug warningf("isRegistered: %s, _isClosing: %s, isClosed: %s, code: %s, msg=%s", 
            _isRegistered, _isClosing, _isClosed, code, msg);
            
        if (errorHandler !is null) {
            errorHandler(new IoError(code, msg));
        }
    }

    void onRead() {
        assert(false, "not implemented");
    }

    void onWrite() {
        assert(false, "not implemented");
    }

    final bool hasFlag(ChannelFlag index) {
        return _flags[index];
    }

    @property ChannelType type() {
        return _type;
    }

    @property Selector eventLoop() {
        return _inLoop;
    }

    void setNext(AbstractChannel next) {
        if (next is this)
            return; // Can't set to self
        next._next = _next;
        next._priv = this;
        if (_next)
            _next._priv = next;
        this._next = next;
    }

    void clear() {
        if (_priv)
            _priv._next = _next;
        if (_next)
            _next._priv = _priv;
        _next = null;
        _priv = null;
    }

    mixin OverrideErro;

protected:
    final void setFlag(ChannelFlag index, bool enable) {
        _flags[index] = enable;
    }

    Selector _inLoop;

private:
    BitArray _flags;
    ChannelType _type;

    AbstractChannel _priv;
    AbstractChannel _next;
}



/**
    https://stackoverflow.com/questions/40361869/how-to-wake-up-epoll-wait-before-any-event-happened
*/
class EventChannel : AbstractChannel {
    this(Selector loop) {
        super(loop, ChannelType.Event);
    }

    abstract void trigger();
    // override void close() {
    //     if(_isClosing)
    //         return;
    //     _isClosing = true;
    //     version (HUNT_DEBUG) tracef("closing [fd=%d]...", this.handle);

    //     if(isBusy) {
    //         import std.parallelism;
    //         version (HUNT_DEBUG) warning("Close operation delayed");
    //         auto theTask = task(() {
    //             while(isBusy) {
    //                 version (HUNT_DEBUG) infof("waitting for idle [fd=%d]...", this.handle);
    //                 // Thread.sleep(20.msecs);
    //             }
    //             super.close();
    //         });
    //         taskPool.put(theTask);
    //     } else {
    //         super.close();
    //     }
    // }
}

mixin template OverrideErro() {
    bool isError() {
        return _error;
    }

    deprecated("Using errorMessage instead.")
    alias erroString = errorMessage;

    string errorMessage() {
        return _errorMessage;
    }

    void clearError() {
        _error = false;
        _errorMessage = "";
    }

    bool _error = false;
    string _errorMessage;
}