/*
 * Copyright (c) 2015 Pantheon Technologies s.r.o. and others. All rights reserved.
 *
 * This program and the accompanying materials are made available under the
 * terms of the Eclipse Public License v1.0 which accompanies this distribution,
 * and is available at http://www.eclipse.org/legal/epl-v10.html
 */
package org.opendaylight.openflowjava.protocol.impl.core.connection;

import com.google.common.annotations.VisibleForTesting;
import com.google.common.base.Preconditions;
import com.google.common.util.concurrent.FutureCallback;

import java.util.function.Function;

import org.opendaylight.openflowjava.protocol.api.connection.OutboundQueueException;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.BarrierInput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.MultipartReplyMessage;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.OfHeader;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.PacketOutInput;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

final class OutboundQueueEntry {
    private static final Logger LOG = LoggerFactory.getLogger(OutboundQueueEntry.class);
    public static final Function<OfHeader, Boolean> DEFAULT_IS_COMPLETE = new Function<OfHeader, Boolean>() {

        @Override
        public Boolean apply(final OfHeader message) {
            if (message instanceof MultipartReplyMessage) {
                return !((MultipartReplyMessage) message).getFlags().isOFPMPFREQMORE();
            }

            return true;
        }

    };

    private FutureCallback<OfHeader> callback;
    private OfHeader message;
    private boolean completed;
    private boolean barrier;
    private volatile boolean committed;
    private OutboundQueueException lastException = null;
    private Function<OfHeader, Boolean> isCompletedFunction = DEFAULT_IS_COMPLETE;

    void commit(final OfHeader message, final FutureCallback<OfHeader> callback) {
        commit(message, callback, DEFAULT_IS_COMPLETE);
    }

    void commit(final OfHeader message, final FutureCallback<OfHeader> callback,
            final Function<OfHeader, Boolean> isCompletedFunction) {
        if (this.completed) {
            LOG.warn("Can't commit a completed message.");
            if (callback != null) {
                callback.onFailure(lastException);
            }
        } else {
            this.message = message;
            this.callback = callback;
            this.barrier = message instanceof BarrierInput;
            this.isCompletedFunction = isCompletedFunction;

            // Volatile write, needs to be last
            this.committed = true;
        }
    }

    void reset() {
        barrier = false;
        callback = null;
        completed = false;
        message = null;

        // Volatile write, needs to be last
        committed = false;
    }

    boolean isBarrier() {
        return barrier;
    }

    boolean isCommitted() {
        return committed;
    }

    boolean isCompleted() {
        return completed;
    }

    OfHeader takeMessage() {
        final OfHeader ret = message;
        if (!barrier) {
            checkCompletionNeed();
        }
        message = null;
        return ret;
    }

    private void checkCompletionNeed() {
        if (callback == null || (message instanceof PacketOutInput)) {
            completed = true;
            if (callback != null) {
                callback.onSuccess(null);
                callback = null;
            }
            committed = false;
        }
    }

    boolean complete(final OfHeader response) {
        Preconditions.checkState(!completed, "Attempted to complete a completed message with response %s", response);

        // Multipart requests are special, we have to look at them to see
        // if there is something outstanding and adjust ourselves accordingly
        final boolean reallyComplete = isCompletedFunction.apply(response);

        completed = reallyComplete;
        if (callback != null) {
            callback.onSuccess(response);
            if (reallyComplete) {
                // We will not need the callback anymore, make sure it can be GC'd
                callback = null;
            }
        }
        LOG.debug("Entry {} completed {} with response {}", this, completed, response);
        return reallyComplete;
    }

    void fail(final OutboundQueueException cause) {
        if (!completed) {
            lastException = cause;
            completed = true;
            if (callback != null) {
                callback.onFailure(cause);
                callback = null;
            }
        } else {
            LOG.warn("Ignoring failure {} for completed message", cause);
        }
    }

    @VisibleForTesting
    /** This method is only for testing to prove that after queue entry is completed there is not callback future */
    boolean hasCallback() {
        return (callback != null);
    }
}