using QuikDawEditor.MiscClasses;
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.ComponentModel;
using System.Linq;
using System.Runtime.CompilerServices;
using System.Windows;
using static QuikDawEditor.EDITING.MiscMethods;
using static QuikDawEditor.EDITING.StaticProperties;

namespace QuikDawEditor.EditingClasses;

public partial class RecordingClipMidi : INotifyPropertyChanged
{

    public string RelRes() { ReleaseResources(); return "Resources released"; }

    public event PropertyChangedEventHandler PropertyChanged;
    private void NotifyPropertyChanged([CallerMemberName] String propertyName = "") { if (PropertyChanged != null) { PropertyChanged(this, new PropertyChangedEventArgs(propertyName)); } }


    public RecordingClipMidi() { recordingMidiEvents.CollectionChanged += RecordingMidiEvents_CollectionChanged; ReverseTransformFactorX = 1 / editingProject.ViewXZoomFac; }

    private void RecordingMidiEvents_CollectionChanged(object sender, System.Collections.Specialized.NotifyCollectionChangedEventArgs e)
    {
        NotifyPropertyChanged(nameof(recordingMidiNotes));
    }

    public string ClipTimeString { get { return _ClipWidthMs < 1000 ? "0" : TimeSpan.FromMilliseconds(_ClipWidthMs).ToString().Substring(0, 8); } }

    private double _ClipVirtualStartMs;
    public double ClipVirtualStartMs { get { return Math.Truncate(_ClipVirtualStartMs); } set { _ClipVirtualStartMs = Math.Truncate(value); NotifyPropertyChanged(nameof(ClipMarginPix)); } }
    public Thickness ClipMarginPix { get { return new Thickness(MsecToPixels(ClipVirtualStartMs), 0, 0, 0); } }
    string lastClipTimeString = "";

    private double _ClipWidthMs = 0;
    public double ClipWidthMs
    {
        get { return _ClipWidthMs; }
        set
        {
            _ClipWidthMs = Math.Truncate(value);
            
            NotifyPropertyChanged(nameof(PixelWidth));
  
            if (lastClipTimeString != ClipTimeString)
            {
                NotifyPropertyChanged(nameof(ClipTimeString));
                NotifyPropertyChanged(nameof(recordingMidiNotes));
                lastClipTimeString = ClipTimeString;
            }
    
        }
    }

    public double PixelWidth { get { return MsecToPixels(_ClipWidthMs); } }

    private bool _IsVisible = false;
    public bool IsVisible { get { return _IsVisible; } set { _IsVisible = value; NotifyPropertyChanged(nameof(ClipVisibility)); } }
    public Visibility ClipVisibility { get { return IsVisible ? Visibility.Visible : Visibility.Hidden; } }

    public void UpdateRecordingClipTransform()
    {
        ReverseTransformFactorX = 1 / editingProject.ViewXZoomFac;
        NotifyPropertyChanged(nameof(ReverseTransformFactorX));
        NotifyPropertyChanged(nameof(RecClipBorderWidth));

    }
    public double ReverseTransformFactorX { get; set; }

    private double myTrackYScale = 1;

    public double RecClipBorderWidth { get { return 0.5 * ReverseTransformFactorX; } }

    public ObservableCollection<QDMidiEvent> recordingMidiEvents { get; set; } = new ObservableCollection<QDMidiEvent>();
    public List<QDMidiNote> recordingMidiNotes { get { return recordingMidiEvents.Where(rme => rme is QDMidiNote).Cast<QDMidiNote>().ToList(); } }

    public void UpdateMidiNoteWidths()
    {
        List<QDMidiNote> recordingMidiNotes = recordingMidiEvents.Where(rme => rme is QDMidiNote).Cast<QDMidiNote>().ToList();
        for (int mno = 0; mno < recordingMidiNotes.Count; mno ++)
        {
            if (!recordingMidiNotes[mno].Released)
            {
                recordingMidiNotes[mno].ClipRelNoteOffTimeMs = _ClipWidthMs;
                recordingMidiNotes[mno].UpdateNoteMsWidthMidiClip();
            }
            
        }
      
    }

}