using QuikDawEditor.Undo;
using System.Collections.Generic;
using System.Linq;
using System.Windows;
using System.Windows.Input;
using static QuikDawEditor.EDITING.ShorcutKeys;
using static QuikDawEditor.EDITING.MidiMethods;
using static QuikDawEditor.EDITING.StaticProperties;
using QuikDawEditor.EditingClasses;

namespace QuikDawEditor
{
    public partial class PianoRoll
    {
        UserCommandKeyPair TransposeMidiUpUCKP { get { return userCommandKeyPairs.Where(uckp => uckp.CommandName == "TransposeMidiUp").FirstOrDefault(); } }
        UserCommandKeyPair TransposeMidiDownUCKP { get { return userCommandKeyPairs.Where(uckp => uckp.CommandName == "TransposeMidiDown").FirstOrDefault(); } }
        UserCommandKeyPair QuantizeUCKP { get { return  userCommandKeyPairs.Where(uckp => uckp.CommandName == "Quantize").FirstOrDefault(); } }

        private void PianoRoll_PreviewKeyDown(object sender, KeyEventArgs e)
        {

            if (HotKeysDisabled) return;
            
            //Check for shorcut keys
            if (TransposeMidiUpUCKP?.shortcutKey == e.Key)
                if (TransposeMidiUpUCKP.modifierKeysMatch(Keyboard.Modifiers))
                    TransposeMidiUp_Execute();
            
            if (TransposeMidiDownUCKP?.shortcutKey == e.Key)
                if (TransposeMidiDownUCKP.modifierKeysMatch(Keyboard.Modifiers))
                    TransposeMidiDown_Execute();

            if (QuantizeUCKP?.shortcutKey == e.Key)
                if (QuantizeUCKP.modifierKeysMatch(Keyboard.Modifiers))
                    Quantize_Execute();


            switch (e.Key)
            {
                case Key.Delete:

                    if (MidiEventsIC.ItemsSource == myClip.ClipMidiNotes)
                    {
                        if (myClip.ClipMidiNotes.Where(cmn => cmn.Selected).Count() == 1)
                        {
                            QDMidiNote qmnote = myClip.ClipMidiNotes.Where(cmn => cmn.Selected).FirstOrDefault();
                            int i = myClip.ClipMidiNotes.IndexOf(qmnote);
                            undoActions.Add(new MidiNotesDeleteUndo(myClip.UndoClipID, new List<QDMidiNote>() { qmnote }, new List<int>() { i }));
                            myClip.ClipMidiNotes.RemoveAt(i);
                        }
                        else
                        {
                            List<QDMidiNote> deleteNotes = myClip.ClipMidiNotes.Where(cmn => cmn.Selected).ToList();
                            List<int> deleteIndexes = deleteNotes.ConvertAll(dn => myClip.ClipMidiNotes.IndexOf(dn));
                            if (deleteNotes.Count > 0)
                            {
                                undoActions.Add(new MidiNotesDeleteUndo(myClip.UndoClipID, deleteNotes, deleteIndexes));
                                foreach (QDMidiNote qmnote in deleteNotes)
                                    myClip.ClipMidiNotes.Remove(qmnote);
                            }
                        }
                    }

                    if (MidiEventsIC.ItemsSource == myClip.ClipSustainEvents)
                    {
                        List<int> deleteIndexes = myClip.ClipSustainEvents.Where(cmn => cmn.Selected).ToList().ConvertAll(sus=>myClip.ClipSustainEvents.IndexOf(sus));
                        List<QDSustain> deleteSustains = myClip.ClipSustainEvents.Where(cmn => cmn.Selected).ToList();
                        undoActions.Add(new MidiSustainsDeleteUndo(myClip.UndoClipID, deleteSustains, deleteIndexes));

                        for (int i = myClip.ClipSustainEvents.Count - 1; i > -1; i -= 1)
                            if (myClip.ClipSustainEvents[i].Selected)
                                myClip.ClipSustainEvents.RemoveAt(i);
                    }

                    if (MidiEventsIC.ItemsSource == myClip.ClipPitchChangeEvents)
                    {
                        List<int> deleteIndexes = myClip.ClipPitchChangeEvents.Where(cmn => cmn.Selected).ToList().ConvertAll(pch => myClip.ClipPitchChangeEvents.IndexOf(pch));
                        List<QDPitchChange> deletePitchChanges = myClip.ClipPitchChangeEvents.Where(cmn => cmn.Selected).ToList();
                        undoActions.Add(new MidiPitchChangesDeleteUndo(myClip.UndoClipID, deletePitchChanges, deleteIndexes));

                        for (int i = myClip.ClipPitchChangeEvents.Count - 1; i > -1; i -= 1)
                            if (myClip.ClipPitchChangeEvents[i].Selected)
                                myClip.ClipPitchChangeEvents.RemoveAt(i);
                    }

                    if (MidiEventsIC.ItemsSource == myClip.ClipModulationEvents)
                    {
                        List<int> deleteIndexes = myClip.ClipModulationEvents.Where(cmn => cmn.Selected).ToList().ConvertAll(mod => myClip.ClipModulationEvents.IndexOf(mod));
                        List<QDModulation> deleteModulations = myClip.ClipModulationEvents.Where(cmn => cmn.Selected).ToList();
                        undoActions.Add(new MidiModulationsDeleteUndo(myClip.UndoClipID, deleteModulations, deleteIndexes));

                        for (int i = myClip.ClipModulationEvents.Count - 1; i > -1; i -= 1)
                            if (myClip.ClipModulationEvents[i].Selected)
                                myClip.ClipModulationEvents.RemoveAt(i);
                    }
                        

                    myClip.UpdateMidiImageSource();
                    thisPianoRoll.UpdateMidiNotesDisplay();

                    editingProject.NeedsSaving = true;
                    break;

                case Key.A:

                    if (Keyboard.Modifiers == ModifierKeys.Control)
                    {
                        IEnumerable<QDMidiEvent> shownEvents = (IEnumerable<QDMidiEvent>)MidiEventsIC.ItemsSource;
                        foreach (QDMidiEvent shownEvent in shownEvents)
                            shownEvent.Selected = true;
                    }
                    break;


            }

            this.Focus();
        }

        private void Quantize_Execute()
        {
            QuantizeWindow QWin = new QuantizeWindow() { Owner = App.Current.MainWindow, ShowInTaskbar = false };
            QWin.ApplyToSelection = thisPianoRoll.SelectedMidiNotes.Count > 0;

            QWin.ShowDialog();
            if (QWin.Result == "Ok")
            {
                switch (QWin.ApplyToSelection)
                {
                    case true:
                        QuantizeMidiNotes(myClip, thisPianoRoll.SelectedMidiNotes, QWin.snapTo, (bool)QWin.QuantizeNoteStartsCB.IsChecked, (bool)QWin.QuantizeNoteLengthsCB.IsChecked, (bool)QWin.ApplySwingCB.IsChecked);
                        break;

                    case false:
                        QuantizeMidiNotes(myClip, thisPianoRoll.MidiNotes, QWin.snapTo, (bool)QWin.QuantizeNoteStartsCB.IsChecked, (bool)QWin.QuantizeNoteLengthsCB.IsChecked, (bool)QWin.ApplySwingCB.IsChecked);
                        break;
                }
            }
            this.Focus();

        }

        private void TransposeMidiUp_Execute()
        {
            foreach (QDMidiNote mnote in thisPianoRoll.MidiNotes)
                mnote.Note += 1;

        }

        private void TransposeMidiDown_Execute()
        {
            foreach (QDMidiNote mnote in thisPianoRoll.MidiNotes)
                mnote.Note -= 1;

        }

    }
   
}