package net.kreatious.pianoleopard.midi;

import java.io.Closeable;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.lang.Thread.State;
import java.util.List;
import java.util.Optional;
import java.util.concurrent.CopyOnWriteArrayList;
import java.util.concurrent.TimeUnit;
import java.util.function.BiFunction;
import java.util.function.Consumer;
import java.util.function.LongConsumer;

import javax.sound.midi.InvalidMidiDataException;
import javax.sound.midi.MidiDevice;
import javax.sound.midi.MidiDevice.Info;
import javax.sound.midi.MidiMessage;
import javax.sound.midi.MidiSystem;
import javax.sound.midi.MidiUnavailableException;
import javax.sound.midi.Receiver;
import javax.sound.midi.Sequencer;
import javax.sound.midi.ShortMessage;

import net.kreatious.pianoleopard.midi.event.Event;
import net.kreatious.pianoleopard.midi.event.EventFactory;
import net.kreatious.pianoleopard.midi.track.ParsedSequence;

import com.google.common.annotations.VisibleForTesting;

/**
 * Model for the MIDI output sequencer, allows controllers to listen for events.
 *
 * @author Jay-R Studer
 */
public class OutputModel implements AutoCloseable {
    /**
     * Indicates which action to take in response to an event handler.
     * <p>
     * The action with the highest priority takes precedence.
     *
     * @author Jay-R Studer
     */
    public enum EventAction {
        /**
         * Return if the event should be played. Has the highest priority.
         */
        PLAY,

        /**
         * Returned if the event should be muted. Has medium priority.
         */
        MUTE,

        /**
         * Returned if it doesn't matter if the event is muted. Has the lowest
         * priority.
         * <p>
         * An event that is not handled by all handlers will be played.
         * <p>
         * Event handlers are allowed to change the MidiMessage before it is
         * sent.
         */
        UNHANDLED;
    }

    private static final long ALWAYS_SEND = -10;
    private final Sequencer sequencer;
    private ParsedSequence sequence = ParsedSequence.createEmpty();
    private Optional<MidiDevice> output = Optional.empty();
    private Optional<Receiver> receiver = Optional.empty();

    private final List<Consumer<? super Info>> outputDeviceListeners = new CopyOnWriteArrayList<>();
    private final List<Consumer<? super ParsedSequence>> openListeners = new CopyOnWriteArrayList<>();
    private final List<Runnable> playListeners = new CopyOnWriteArrayList<>();
    private final List<LongConsumer> currentTimeListeners = new CopyOnWriteArrayList<>();
    private final List<BiFunction<MidiMessage, Optional<Event>, EventAction>> eventHandlers = new CopyOnWriteArrayList<>();
    private final List<Closeable> closeables = new CopyOnWriteArrayList<>();

    private final Thread tickThread = new Thread("output model current tick thread") {
        @Override
        public void run() {
            try {
                while (true) {
                    currentTimeListeners.forEach(listener -> listener.accept(sequencer.getMicrosecondPosition()));
                    Thread.sleep(TimeUnit.SECONDS.toMillis(1) / 120);
                }
            } catch (final InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        };
    };

    /**
     * Constructs a new {@link OutputModel} with the specified initial state.
     * <p>
     * The output model is initially unconnected to any MIDI devices. After
     * construction, it is expected that an output device will be set by the
     * consumer.
     *
     * @param sequencerFactory
     *            A factory for producing the {@link Sequencer}, such as
     *            {@link SystemSequencerFactory}.
     * @throws MidiUnavailableException
     *             if the MIDI system is unavailable.
     */
    public OutputModel(SequencerFactory sequencerFactory) throws MidiUnavailableException {
        sequencer = sequencerFactory.getSequencer();
        setOutputDevice(new InitialMidiDevice());
    }

    /**
     * Reconnects the sequencer to a different MIDI output device.
     *
     * @param output
     *            the new output MIDI device to reconnect to
     * @throws MidiUnavailableException
     *             if the MIDI system is unavailable.
     */
    public synchronized void setOutputDevice(MidiDevice output) throws MidiUnavailableException {
        try {
            sequencer.close();
            this.output.ifPresent(MidiDevice::close);
            this.output = Optional.of(output);

            output.open();
            receiver = Optional.of(new MutingReceiverProxy(output.getReceiver()));
            sequencer.getTransmitter().setReceiver(receiver.get());
            sequencer.open();
            sequencer.setSequence(sequence.getSequence());
            outputDeviceListeners.forEach(listener -> listener.accept(output.getDeviceInfo()));
        } catch (final InvalidMidiDataException e) {
            // Sequence should still be valid since openMidiFile didn't throw
            throw new IllegalStateException(e);
        }
    }

    /**
     * Starts playback of the currently loaded MIDI file.
     * <p>
     * Any registered start listeners will be called with the last opened MIDI
     * sequence.
     */
    public void start() {
        sequencer.stop();
        sequencer.setMicrosecondPosition(0);
        resetReceiver();
        playListeners.forEach(Runnable::run);
        sequencer.start();
    }

    private class MutingReceiverProxy implements Receiver {
        private final Receiver wrapped;

        private MutingReceiverProxy(Receiver wrapped) {
            this.wrapped = wrapped;
        }

        @Override
        public void send(MidiMessage message, long timeStamp) {
            if (timeStamp == ALWAYS_SEND) {
                wrapped.send(message, -1);
                return;
            }

            final Optional<Event> event = EventFactory.create(message, sequencer.getMicrosecondPosition());
            if (eventHandlers.stream().map(eventHandler -> eventHandler.apply(message, event)).min(Enum::compareTo)
                    .orElse(EventAction.UNHANDLED) != EventAction.MUTE) {
                wrapped.send(message, timeStamp);
            }
        }

        @Override
        public void close() {
            wrapped.close();
        }
    }

    /**
     * Adjusts the tempo of played back sequences.
     * <p>
     * Values higher than 1.0 are faster than normal, less than 1.0 are slower
     * than normal. A value of 1.0 indicates that the regular tempo should be
     * applied. Tempo factors do not affect the microsecond values of MIDI
     * events.
     *
     * @param factor
     *            the tempo factor to set
     */
    public void setTempoFactor(float factor) {
        sequencer.setTempoFactor(factor);
    }

    /**
     * Seeks the sequence to the specified time
     *
     * @param time
     *            the time in microseconds to seek to
     */
    public void setCurrentTime(long time) {
        if (sequencer.isRunning()) {
            sequencer.stop();
            sequencer.setMicrosecondPosition(time);
            sequencer.start();
        } else {
            sequencer.setMicrosecondPosition(time);
        }
    }

    /**
     * Parses a MIDI file and prepares it for playback.
     * <p>
     * Any registered start listeners will be called with the parsed sequence.
     * The file of the parsed sequence will be the specified MIDI file.
     *
     * @param midi
     *            the MIDI file to open
     * @throws IOException
     *             if an I/O error occurs
     */
    public void openMidiFile(File midi) throws IOException {
        try (InputStream in = new FileInputStream(midi)) {
            openMidiFile(in, Optional.of(midi));
        }
    }

    @VisibleForTesting
    void openMidiFile(InputStream midiStream, Optional<File> midi) throws IOException {
        try {
            if (tickThread.getState() == State.NEW) {
                tickThread.start();
            }

            sequence = ParsedSequence.parseByTracks(MidiSystem.getSequence(midiStream));
            sequence.setFile(midi);
            sequencer.stop();
            sequencer.setSequence(sequence.getSequence());
            sequencer.setMicrosecondPosition(0);
            resetReceiver();
            openListeners.forEach(listener -> listener.accept(sequence));
        } catch (final InvalidMidiDataException e) {
            throw new IOException(e);
        }
    }

    /**
     * Adds a listener to notify when the output device has changed.
     *
     * @param listener
     *            the listener to add
     */
    public void addOutputDeviceListener(Consumer<? super Info> listener) {
        outputDeviceListeners.add(listener);
    }

    /**
     * Adds a listener to notify when a parsed MIDI file is opened.
     *
     * @param listener
     *            the listener to add
     */
    public void addOpenListener(Consumer<? super ParsedSequence> listener) {
        openListeners.add(listener);
    }

    /**
     * Adds a listener to notify when a parsed MIDI file is played from the
     * beginning.
     *
     * @param listener
     *            the listener to add
     */
    public void addPlayListener(Runnable listener) {
        playListeners.add(listener);
    }

    /**
     * Adds an event handler to handle MIDI events.
     * <p>
     * The return value of the handler determines the action to take. A list of
     * actions is provided on {@link EventAction}. The default action is to play
     * the event.
     * <p>
     * Event handlers are allowed to mutate the channel of the MidiMessage
     * object before returning. The {@link Event} object contains the original
     * message before any mutations are applied. Handlers are encouraged to use
     * the Event object whenever possible.
     *
     * @param handler
     *            the event handler to add.
     */
    public void addEventHandler(BiFunction<MidiMessage, Optional<Event>, EventAction> handler) {
        eventHandlers.add(handler);
    }

    /**
     * Adds a listener to notify when the current playback time in microseconds
     * has changed.
     * <p>
     * This listener is called asynchronously several times per second for the
     * lifetime of this object from a different thread than the one which
     * invokes this method.
     *
     * @param listener
     *            the listener to add
     */
    public void addCurrentTimeListener(LongConsumer listener) {
        currentTimeListeners.add(listener);
    }

    /**
     * Adds a closeable to close when this output model is closed.
     * <p>
     * Used for releasing resources closely tied with the lifetime of this
     * output model. Resources will be released in the same order they are
     * registered.
     *
     * @param closeable
     *            the closeable to add
     */
    public void addCloseable(Closeable closeable) {
        closeables.add(closeable);
    }

    /**
     * Sends a MIDI message to the output.
     *
     * @param message
     *            the MIDI message to send to the connected output device
     */
    public synchronized void sendMessage(MidiMessage message) {
        receiver.ifPresent(receive -> receive.send(message, ALWAYS_SEND));
    }

    @Override
    public void close() throws InterruptedException, IOException {
        tickThread.interrupt();
        tickThread.join();

        sequencer.close();
        resetReceiver();
        output.ifPresent(MidiDevice::close);

        Optional<IOException> exception = Optional.empty();
        for (final Closeable closeable : closeables) {
            try {
                closeable.close();
            } catch (final IOException e) {
                if (exception.isPresent()) {
                    exception.get().addSuppressed(e);
                } else {
                    exception = Optional.of(e);
                }
            }
        }
        if (exception.isPresent()) {
            throw exception.get();
        }
    }

    private synchronized void resetReceiver() {
        try {
            for (int channel = 0; channel != 16; channel++) {
                // All notes off, reset all controllers, reset programs
                sendMessage(new ShortMessage(ShortMessage.CONTROL_CHANGE, channel, 123, 0));
                sendMessage(new ShortMessage(ShortMessage.CONTROL_CHANGE, channel, 121, 0));
                sendMessage(new ShortMessage(ShortMessage.PROGRAM_CHANGE, channel, 0, 0));
            }
        } catch (final InvalidMidiDataException e) {
            // Unreachable
            throw new IllegalStateException(e);
        }
    }
}