package net.kreatious.pianoleopard.midi;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.concurrent.CopyOnWriteArrayList;
import java.util.function.Consumer;

import javax.sound.midi.MidiDevice;
import javax.sound.midi.MidiDevice.Info;
import javax.sound.midi.MidiMessage;
import javax.sound.midi.MidiUnavailableException;
import javax.sound.midi.Receiver;

import net.kreatious.pianoleopard.intervalset.IntervalSet;
import net.kreatious.pianoleopard.midi.event.Event;
import net.kreatious.pianoleopard.midi.event.EventFactory;
import net.kreatious.pianoleopard.midi.event.EventPair;
import net.kreatious.pianoleopard.midi.event.NoteEvent;
import net.kreatious.pianoleopard.midi.event.PedalEvent;
import net.kreatious.pianoleopard.midi.track.ParsedSequence;
import net.kreatious.pianoleopard.midi.track.ParsedTrack;

/**
 * Model for the MIDI input keyboard, allows controllers to listen for events.
 *
 * @author Jay-R Studer
 */
public class InputModel implements AutoCloseable, ParsedTrack {
    private Optional<MidiDevice> input = Optional.empty();
    private final UserNoteRecorder userRecorder = new UserNoteRecorder();

    private final IntervalSet<EventPair<NoteEvent>> notes = new IntervalSet<>();
    private final IntervalSet<EventPair<PedalEvent>> pedals = new IntervalSet<>();

    private final List<Consumer<? super Info>> inputDeviceListeners = new CopyOnWriteArrayList<>();
    private final List<Consumer<? super Event>> inputListeners = new CopyOnWriteArrayList<>();

    private InputModel(MidiDevice input) throws MidiUnavailableException {
        setInputDevice(input);
    }

    /**
     * Constructs a new {@link InputModel} with the specified initial state.
     * <p>
     * After construction, the input model is not connected to any actual
     * devices. It is expected that the consumer will change the input device.
     *
     * @param outputModel
     *            the output model to coordinate with
     * @return a new instance of {@link InputModel}. The caller is responsible
     *         for releasing the resource.
     * @throws MidiUnavailableException
     *             if the MIDI system is unavailable.
     */
    public static InputModel create(OutputModel outputModel) throws MidiUnavailableException {
        final InputModel input = new InputModel(new InitialMidiDevice());
        outputModel.addOpenListener(input::setCurrentSequence);
        outputModel.addPlayListener(input.userRecorder::clear);
        outputModel.addCurrentTimeListener(input.userRecorder::setCurrentTime);
        return input;
    }

    private void setCurrentSequence(@SuppressWarnings("unused") ParsedSequence sequence) {
        userRecorder.clear();
    }

    private final class UserNoteRecorder implements Receiver, ParsedTrack {
        private final Map<Object, NoteEvent> onNotes = new HashMap<>();
        private final Map<Object, PedalEvent> onPedals = new HashMap<>();

        private long currentTime;

        private synchronized void setCurrentTime(long time) {
            currentTime = time;
        }

        @Override
        public synchronized void send(MidiMessage message, long timeStamp) {
            EventFactory.create(message, currentTime).ifPresent(this::userPressedEvent);
        }

        private void userPressedEvent(Event event) {
            if (event instanceof NoteEvent) {
                userPressedEvent((NoteEvent) event, onNotes, notes);
            } else if (event instanceof PedalEvent) {
                userPressedEvent((PedalEvent) event, onPedals, pedals);
            }
            inputListeners.forEach(listener -> listener.accept(event));
        }

        private <K extends Event> void userPressedEvent(K event, Map<Object, K> onEvents,
                IntervalSet<EventPair<K>> fullEvents) {
            synchronized (fullEvents) {
                final long eventTime = event.getTime();
                if (event.isOn()) {
                    onEvents.put(event.getSlot(), event);
                } else {
                    Optional.ofNullable(onEvents.remove(event.getSlot())).ifPresent(onEvent -> {
                        fullEvents.put(onEvent.getTime(), eventTime, new EventPair<>(onEvent, event));
                    });
                }
            }
        }

        @Override
        public Iterable<EventPair<NoteEvent>> getNotePairs(long low, long high) {
            return getPairs(low, high, onNotes, notes);
        }

        @Override
        public Iterable<EventPair<PedalEvent>> getPedalPairs(long low, long high) {
            return getPairs(low, high, onPedals, pedals);
        }

        private synchronized <K extends Event> Iterable<EventPair<K>> getPairs(long low, long high,
                Map<Object, K> onEvents, IntervalSet<EventPair<K>> fullEvents) {
            synchronized (fullEvents) {
                final List<EventPair<K>> result = new ArrayList<>();
                fullEvents.subSet(low, high).forEach(result::add);
                onEvents.values().forEach(event -> result.add(new EventPair<>(event, event.createOff(currentTime))));
                return result;
            }
        }

        void clear() {
            synchronized (notes) {
                notes.clear();
                onNotes.clear();
            }
            synchronized (pedals) {
                pedals.clear();
                onPedals.clear();
            }
        }

        @Override
        public void close() {
            // Intentionally empty; this receiver holds no system resources
        }
    }

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

        input.open();
        input.getTransmitter().setReceiver(userRecorder);
        userRecorder.clear();
        inputDeviceListeners.forEach(listener -> listener.accept(input.getDeviceInfo()));
    }

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

    /**
     * Adds a listener to notify when the user has pressed a key
     *
     * @param listener
     *            the listener to add
     */
    public void addInputListener(Consumer<? super Event> listener) {
        inputListeners.add(listener);
    }

    @Override
    public void close() {
        input.ifPresent(MidiDevice::close);
    }

    @Override
    public Iterable<EventPair<NoteEvent>> getNotePairs(long low, long high) {
        return userRecorder.getNotePairs(low, high);
    }

    @Override
    public Iterable<EventPair<PedalEvent>> getPedalPairs(long low, long high) {
        return userRecorder.getPedalPairs(low, high);
    }
}