package jmri.jmrix.can;

import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
import java.util.Arrays;
import jmri.jmrix.AbstractMRListener;
import jmri.jmrix.AbstractMRMessage;
import jmri.jmrix.AbstractMRReply;
import jmri.jmrix.AbstractMRTrafficController;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * Abstract base for TrafficControllers in a CANbus based Message/Reply
 * protocol.
 * <p>
 * AbstractMRTrafficController is extended to allow for the translation between
 * CAN messages and the message format of the CAN adapter that connects to the
 * layout.
 *
 * @author Andrew Crosland Copyright (C) 2008
 */
abstract public class AbstractCanTrafficController
        extends AbstractMRTrafficController
        implements CanInterface {

    public AbstractCanTrafficController() {
        super();
        allowUnexpectedReply = true;
    }

    // The methods to implement the CAN Interface
    /**
     * {@inheritDoc}
     */
    @Override
    public synchronized void addCanListener(CanListener l) {
        this.addListener(l);
    }

    /**
     * Add a CanListener to start of the notification list.
     * This is intended only for Consoles to receive the CanFrame 1st,
     * not after another Listener has sent a response to that Frame.
     * @param l The CanListener to add.
     */
    public synchronized void addCanConsoleListener(CanListener l) {
        this.addConsoleListener(l);
    }

    /**
     * {@inheritDoc}
     */
    @Override
    public synchronized void removeCanListener(CanListener l) {
        this.removeListener(l);
    }

    /**
     * Actually transmits the next message to the port
     *
     * Overridden to include translation to the correct CAN hardware message
     * format
     * {@inheritDoc}
     */
    @Override
    protected void forwardToPort(AbstractMRMessage m, AbstractMRListener reply) {
//        if (log.isDebugEnabled()) log.debug("forwardToPort message: ["+m+"]");
        log.debug("forwardToPort message: [{}]", m);//warn

        // remember who sent this
        mLastSender = reply;

        // forward the message to the registered recipients,
        // which includes the communications monitor, except the sender.
        // Schedule notification via the Swing event queue to ensure order
        Runnable r = new XmtNotifier(m, mLastSender, this);
        javax.swing.SwingUtilities.invokeLater(r);

        // Create the correct concrete class for sending to the hardware and encode the message to be sent
        AbstractMRMessage hm;
        if (((CanMessage) m).isTranslated()) {
            hm = m;
        } else {
            hm = encodeForHardware((CanMessage) m);
        }
        log.debug("Encoded for hardware: [{}]", hm); // no eager toString(), called for every frame

        // stream to port in single write, as that's needed by serial
        byte msg[] = new byte[lengthOfByteStream(hm)];

        // add header
        int offset = addHeaderToOutput(msg, hm); // always returns 0

        // add data content
        int len = hm.getNumDataElements();
        for (int i = 0; i < len; i++) {
            msg[i + offset] = (byte) hm.getElement(i);
        }

        // add trailer
        addTrailerToOutput(msg, len + offset, hm);

        // and stream the bytes
        try {
            if (ostream != null) {
                if (log.isDebugEnabled()) {
                    //String f = "formatted message: ";
                    StringBuilder buf = new StringBuilder();
                    //for (int i = 0; i<msg.length; i++) f=f+Integer.toHexString(0xFF&msg[i])+" ";
                    for (int i = 0; i < msg.length; i++) {
                        buf.append(Integer.toHexString(0xFF & msg[i]));
                        buf.append(" ");
                    }
                    log.debug("formatted message: {}",buf.toString());
                }
                while (hm.getRetries() >= 0) {
                    if (portReadyToSend(controller)) {
                        ostream.write(msg);
                        log.debug("message written");
                        break;
                    } else if (hm.getRetries() >= 0) {
                        if (log.isDebugEnabled()) {
                            log.debug("Retry message: {} attempts remaining: {}", hm.toString(), hm.getRetries());
                        }
                        hm.setRetries(hm.getRetries() - 1);
                        try {
                            synchronized (xmtRunnable) {
                                xmtRunnable.wait(hm.getTimeout());
                            }
                        } catch (InterruptedException e) {
                            Thread.currentThread().interrupt(); // retain if needed later
                            log.error("retry wait interrupted");
                        }
                    } else {
                        log.warn("sendMessage: port not ready for data sending: {}", Arrays.toString(msg));
                    }
                }
            } else {
                // no stream connected
                connectionWarn();
            }
        } catch (java.io.IOException | RuntimeException e) {
            portWarn(e);
        }
    }

    /**
     * {@inheritDoc}
     * Always null
     */
    @Override
    protected AbstractMRMessage pollMessage() {
        return null;
    }

    /**
     * {@inheritDoc}
     * Always null
     */
    @Override
    protected AbstractMRListener pollReplyHandler() {
        return null;
    }

    /**
     * {@inheritDoc}
     * Always null
     */
    @Override
    protected AbstractMRMessage enterProgMode() {
        return null;
    }

    /**
     * {@inheritDoc}
     * Always null
     */
    @Override
    protected AbstractMRMessage enterNormalMode() {
        return null;
    }

    /**
     * Get the correct concrete class for the hardware connection message
     * @return new blank message
     */
    abstract protected AbstractMRMessage newMessage();

    abstract public CanReply decodeFromHardware(AbstractMRReply m);

    abstract public AbstractMRMessage encodeForHardware(CanMessage m);

    /**
     * Handle each reply when complete.
     * <p>
     * Overridden to include translation form the CAN hardware format
     *
     */
    @SuppressFBWarnings(value = "DLS_DEAD_LOCAL_STORE")
    // Ignore false positive that msg is never used
    @Override
    public void handleOneIncomingReply() throws java.io.IOException {
        // we sit in this until the message is complete, relying on
        // threading to let other stuff happen

        // Create messages off the right concrete classes
        // for the CanReply
        CanReply msg;

        // and for the incoming reply from the hardware
        AbstractMRReply hmsg = newReply();

        // wait for start if needed
        waitForStartOfReply(istream);

        // message exists, now fill it
        loadChars(hmsg, istream);
        if (threadStopRequest) {
            return; // connection closing, do not dispatch a partial or replayed frame
        }

        // Decode the message from the hardware into a CanReply
        msg = decodeFromHardware(hmsg);
        if (msg == null) {
            return;  // some replies don't get forwarded
        }
        // message is complete, dispatch it !!
        replyInDispatch = true;

        if (log.isDebugEnabled()) {
            log.debug("dispatch reply of length {} contains {} state {}", msg.getNumDataElements(), msg.toString(), mCurrentState);
        }

        // Actually distribute the reply, to the registered listeners only.
        // A CAN bus has no request / reply pairing, so the frame is not
        // addressed to whichever listener happened to send last. Passing
        // mLastSender here also delivered every frame to that listener after
        // it had been removed, eg. a closed tool window that sent the last
        // frame kept receiving all traffic.
        distributeOneReply(msg, null);

        if (!msg.isUnsolicited()) {
            log.debug("switch on state {}", mCurrentState);
            // effect on transmit:
            switch (mCurrentState) {

                case WAITMSGREPLYSTATE: {
                    // update state, and notify to continue
                    synchronized (xmtRunnable) {
                        mCurrentState = NOTIFIEDSTATE;
                        replyInDispatch = false;
                        xmtRunnable.notify();
                    }
                    break;
                }

                case WAITREPLYINPROGMODESTATE: {
                    // entering programming mode
                    mCurrentMode = PROGRAMINGMODE;
                    replyInDispatch = false;

                    // check to see if we need to delay to allow decoders to become
                    // responsive
                    int warmUpDelay = enterProgModeDelayTime();
                    if (warmUpDelay != 0) {
                        try {
                            synchronized (xmtRunnable) {
                                xmtRunnable.wait(warmUpDelay);
                            }
                        } catch (InterruptedException e) {
                            Thread.currentThread().interrupt(); // retain if needed later
                        }

                    }

                    // update state, and notify to continue
                    synchronized (xmtRunnable) {
                        mCurrentState = OKSENDMSGSTATE;
                        xmtRunnable.notify();
                    }
                    break;
                }

                case WAITREPLYINNORMMODESTATE: {
                    // entering normal mode
                    mCurrentMode = NORMALMODE;
                    replyInDispatch = false;
                    // update state, and notify to continue
                    synchronized (xmtRunnable) {
                        mCurrentState = OKSENDMSGSTATE;
                        xmtRunnable.notify();
                    }
                    break;
                }

                default: {
                    replyInDispatch = false;
                    if (allowUnexpectedReply == true) {
                        log.debug("Allowed unexpected reply received in state: {} was {}", mCurrentState, msg);
                    } else {
                        unexpectedReplyStateError(mCurrentState,msg.toString());
                    }
                }
            }
            // Unsolicited message
        } else {
            replyInDispatch = false;
        }
    }

    public void distributeOneReply(CanReply msg, AbstractMRListener mLastSender) {
        // forward the message to the registered recipients,
        // which includes the communications monitor
        if (msg == null) log.error("found unexpected null message", new Exception("traceback"));
        Runnable r = newRcvNotifier(msg, mLastSender, this);
        distributeReply(r);
    }

    private static final Logger log = LoggerFactory.getLogger(AbstractCanTrafficController.class);

}