using QuikDawEditor.Properties;
using QuikDawEditor.EditingClasses;
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Text;
using System.Text.Json;
using System.Threading.Tasks;
using System.Windows;
using static QuikDawEditor.EDITING.StaticProperties;
using static QuikDawEditor.EDITING.MiscMethods;

namespace QuikDawEditor.Undo;

public class ClipAddUndo : UndoClass
{
    public string UndoMainValue { get { return "Delete clip: " + GetClipFromID(AddedClipID).ClipName; } }
    string AddedClipID;
    public ClipAddUndo(string addedClipID) { AddedClipID = addedClipID; PreventWhilePlaying = true; }
    public override void Undo() { Clip undoClip = GetClipFromID(AddedClipID); undoClip.myTrack.Clips.Remove(undoClip); }

}

public class ClipDeleteUndo : UndoClass
{
    public string UndoMainValue { get { return "Restore clip idx: " + ClipIndex.ToString(); } }
    string ClipJson;
    string UndoTrackID;
    int ClipIndex;

    public ClipDeleteUndo(string undoTrackID, int clipIndex, string clipJson) 
        { UndoTrackID = undoTrackID; ClipIndex = clipIndex; ClipJson = clipJson; IsLongUndoAction = true; PreventWhilePlaying = true; }

    public override void Undo()
    {
        Clip restoreClip = (Clip)JsonSerializer.Deserialize(ClipJson, typeof(Clip));
        Track undoTrack = GetTrackFromID(UndoTrackID);

        restoreClip.myTrack = undoTrack;
        try
        {
            if (restoreClip.IsAudioClip)
            {  //Create clipsampleprovider for clip
                undoTrack.AddClipSampleProviderToClip(restoreClip);
                restoreClip.ApplyWaveBitmapSourcesToImage();
            }
        }
        catch (Exception ex) { MessageBox.Show("error undoing clip:\n" + ex.Message); }

        undoTrack.Clips.Insert(ClipIndex, restoreClip);
    }
}

public class ClipMoveUndo : UndoClass
{
    public string UndoMainValue { get { return "Return clip idx to: " + PreMoveClipIndex.ToString(); } }
    Clip MovedClip;
    int PreMoveClipIndex;
    Track PreMoveTrack;
    double PreMoveVirtualStartMs;

    public ClipMoveUndo(Track premoveTrack, int preMoveClipIndex, Clip movedClip, double preMoveVirtualStartMs)
    { PreMoveTrack = premoveTrack; PreMoveClipIndex = preMoveClipIndex; MovedClip = movedClip; PreMoveVirtualStartMs = preMoveVirtualStartMs; PreventWhilePlaying = true; }

    public override void Undo()
    {
        MovedClip.myTrack.Clips.Remove(MovedClip);
        MovedClip.myTrack.UpdateMyClipsToOwner();
        MovedClip.ClipVirtualStartMs = PreMoveVirtualStartMs;
        PreMoveTrack.Clips.Insert(PreMoveClipIndex, MovedClip);
        PreMoveTrack.UpdateMyClipsToOwner();
    }
}

public class ClipVirtualStartChangedUndoClass : UndoClass
{
    public string UndoMainValue { get { return "Return clip virtualstart: " + RestoreVirtualStartMs.ToString(); } }
    string UndoClipID;
    double RestoreVirtualStartMs;

    public ClipVirtualStartChangedUndoClass(string undoClipID, double restoreVirtualStartMs) { UndoClipID = undoClipID; RestoreVirtualStartMs = restoreVirtualStartMs; }

    public override void Undo() { GetClipFromID(UndoClipID).ClipVirtualStartMs = RestoreVirtualStartMs; }

}

public class ClipsVirtualStartsChangedUndoClass : UndoClass
{
    public string UndoMainValue { get { return "Return clip virtualstarts by: " + MSChanged.ToString(); } }
    List<string> UndoClipIDs;
    double MSChanged;

    public ClipsVirtualStartsChangedUndoClass(List<string> undoClipIDs, double msChanged) { UndoClipIDs = undoClipIDs; MSChanged = msChanged; }

    public override void Undo() { foreach (Clip c in UndoClipIDs.ConvertAll(uci => GetClipFromID(uci))) c.ClipVirtualStartMs -= MSChanged; }

}

public class ClipRelativeStartChangedUndoClass : UndoClass
{
    public string UndoMainValue { get { return "Return clip relative start: " + RestoreRelativeStartMs.ToString(); } }
    string UndoClipID;
    double RestoreRelativeStartMs;
    double RestoreWidthMs;
    float RestoreLeftEdgeGainVal;
    public ClipRelativeStartChangedUndoClass(string undoClipID, double restoreRSMs, double restoreWidthMs, float restoreLeftEdgeGainVal)
    { UndoClipID = undoClipID; RestoreRelativeStartMs = restoreRSMs; RestoreWidthMs = restoreWidthMs; RestoreLeftEdgeGainVal = restoreLeftEdgeGainVal; }
    
    public override void Undo() 
    { 
        Clip undoClip = GetClipFromID(UndoClipID); 
        undoClip.ClipRelativeLoopStartMs = RestoreRelativeStartMs; undoClip.ClipWidthMs = RestoreWidthMs; undoClip.ClipStartGainPoint.GainValue = RestoreLeftEdgeGainVal; 
    }
}

public class ClipWidthChangedUndoClass : UndoClass
{
    public string UndoMainValue { get { return "Return clip width: " + RestoreWidthMs.ToString(); } }
    string UndoClipID;
    double RestoreWidthMs;
    float RestoreRightEdgeGainVal;
    public ClipWidthChangedUndoClass(string undoClipID, double restoreWidthMs, float restoreRightEdgeGainVal)
    { UndoClipID = undoClipID; RestoreWidthMs = restoreWidthMs; RestoreRightEdgeGainVal = restoreRightEdgeGainVal; }
    public override void Undo() { Clip undoClip = GetClipFromID(UndoClipID); undoClip.ClipWidthMs = RestoreWidthMs; undoClip.ClipEndGainPoint.GainValue = RestoreRightEdgeGainVal; }
}

public class ClipReverseUndoClass : UndoClass
{
    public string UndoMainValue { get { return "Undo clip reverse to: " + (!GetClipFromID(UndoClipID).IsReversed).ToString(); } }
    string UndoClipID;
    public ClipReverseUndoClass(string undoClipID) { UndoClipID = undoClipID; }
    public override void Undo() { Clip undoClip = GetClipFromID(UndoClipID); undoClip.IsReversed = !undoClip.IsReversed; PreventWhilePlaying = true; }
}

public class ClipMuteUndoClass : UndoClass
{
    public string UndoMainValue { get { return "Undo clip muted to: " + (!GetClipFromID(UndoClipID).IsMuted).ToString(); } }
    string UndoClipID;
    public ClipMuteUndoClass(string undoClipID) { UndoClipID = undoClipID; }
    public override void Undo() { Clip undoClip = GetClipFromID(UndoClipID); undoClip.IsMuted = !undoClip.IsMuted;  if (!undoClip.IsMuted) undoClip.ResetMe(projPlayer.CurrentPlayingPosMS); }
    
}

public class ClipLoopUndoClass : UndoClass
{
    public string UndoMainValue { get { return "Undo clip looped to: " + (!GetClipFromID(UndoClipID).IsLooped).ToString(); } }
    string UndoClipID;
    double PreChangeWidthMs;
    float PreClipEndGPVal;
    public ClipLoopUndoClass(string undoClipID, double preChangeWidthMs, float preClipEndGPVal) 
        { UndoClipID = undoClipID; PreChangeWidthMs = preChangeWidthMs; PreClipEndGPVal = preClipEndGPVal; }
    
    public override void Undo() 
    { Clip undoClip = GetClipFromID(UndoClipID); undoClip.IsLooped = !undoClip.IsLooped; undoClip.ClipWidthMs = PreChangeWidthMs; undoClip.ClipEndGainPoint.GainValue = PreClipEndGPVal; }
    
}
  
public class ClipGainChangeUndoClass : UndoClass
{
    public string UndoMainValue { get { return "Undo clip gain to: " + UndoGainFactor.ToString(); } }
    string UndoClipID;
    float UndoGainFactor;
    public ClipGainChangeUndoClass(string undoClipID, float undoGainFactor) { UndoClipID = undoClipID; UndoGainFactor = undoGainFactor; }
    public override void Undo() { GetClipFromID(UndoClipID).ClipGainFactor = UndoGainFactor; }
    
}

public class ClipPitchChangeUndoClass : UndoClass
{
    public string UndoMainValue { get { return "Undo clip pitch to: " + UndoPitchValue.ToString(); } }
    string UndoClipID;
    double UndoPitchValue;
    public ClipPitchChangeUndoClass(string undoClipID, double undoPitchValue) { UndoClipID = undoClipID; UndoPitchValue = undoPitchValue; }
    public override void Undo() { Clip undoClip = GetClipFromID(UndoClipID); undoClip.PitchChangeValue = UndoPitchValue; undoClip.floatPitchValue = undoClip.GetPitchFloatFromHalfStepValue((int)undoClip.PitchChangeValue); }
    
}

public class ClipSplitUndoClass : UndoClass
{
    public string UndoMainValue { get { return "Undo clip split " + GetClipFromID(UndoClipID).ClipName; } }
    string UndoTrackID;
    string AddedClipID;
    string UndoClipID;
    double RestoreWidthMs;
    float RestoreLastGainPointVal;

    public ClipSplitUndoClass(string undoTrackID, string addedClipID, string undoClipID, double restoreWidthMs, float lastGainPointVal)
        { UndoTrackID = undoTrackID; AddedClipID = addedClipID; UndoClipID = undoClipID; RestoreWidthMs = restoreWidthMs; RestoreLastGainPointVal = lastGainPointVal; }

    public override void Undo() 
    {
        Clip addedClip = GetClipFromID(AddedClipID);
        Clip undoClip = GetClipFromID(UndoClipID);
        for (int gpno = 1; gpno < addedClip.GainPoints.Count - 1; gpno++)
            undoClip.GainPoints.Insert(undoClip.GainPoints.Count-1, addedClip.GainPoints[gpno]);

        GetTrackFromID(UndoTrackID).RemoveAndDisposeClip(addedClip);
        undoClip.ClipWidthMs = RestoreWidthMs;
        undoClip.ClipEndGainPoint.GainValue = RestoreLastGainPointVal;
    }
}

public class ClipFuseUndoClass : UndoClass
{
    public string UndoMainValue { get { return "Undo clip fusion at idx: " + PreviousClipIndex.ToString(); } }
    int PreviousClipIndex;
    string PreviousClipJson;
    string UndoTrackID;
    public ClipFuseUndoClass(string undoTrackID, string previousClipJson, int previousClipIdx)
    { UndoTrackID = undoTrackID; PreviousClipJson = previousClipJson; PreviousClipIndex = previousClipIdx; IsLongUndoAction = true; PreventWhilePlaying = true; }

    public override void Undo()
    {
        Clip restoreClip = (Clip)JsonSerializer.Deserialize(PreviousClipJson, typeof(Clip));
        Track undoTrack = GetTrackFromID(UndoTrackID);
        undoTrack.RemoveAndDisposeClip(undoTrack.Clips[PreviousClipIndex]);

        undoTrack.InsertClip(PreviousClipIndex, restoreClip);

    }
}

public class ClipChangeMidiBaseLengthUndoClass : UndoClass
{
    public string UndoMainValue { get { return "Undo extend midi clip: " + GetClipFromID(UndoClipID).ClipName; } }
    string UndoClipID;
    double RestoreMidiBaseWidthMs;
    public ClipChangeMidiBaseLengthUndoClass(string undoClipID, double restoreMidiBaseWidthMs)
        { UndoClipID = undoClipID; RestoreMidiBaseWidthMs = restoreMidiBaseWidthMs; }
    
    public override void Undo() 
    {
        Clip undoClip = GetClipFromID(UndoClipID);
        undoClip.ClipSourceLenMilliseconds = RestoreMidiBaseWidthMs;
        undoClip.UpdateMidiImageSource();
        undoClip.UpdateClipSourceSizeChanged();

        if (editingProject.pianoRoll.IsVisible)
            editingProject.pianoRoll.myClip = editingProject.pianoRoll.myClip; //to trigger redraw of pianoroll
    }

}

public class ClipExtendMidiClipUndoClass : UndoClass
{
    public string UndoMainValue { get { return "Undo extend midi clip: " + GetClipFromID(UndoClipID).ClipName; } }
    string UndoClipID;
    double RestoreMidiBaseWidthMs;
    double RestoreClipWidthMs;
    public ClipExtendMidiClipUndoClass(string undoClipID, double restoreMidiBaseWidthMs, double restoreClipWidthMs)
        { UndoClipID = undoClipID; RestoreMidiBaseWidthMs = restoreMidiBaseWidthMs; RestoreClipWidthMs = restoreClipWidthMs; }
    
    public override void Undo() 
    {
        Clip undoClip = GetClipFromID(UndoClipID);
        undoClip.ClipSourceLenMilliseconds = RestoreMidiBaseWidthMs;
        undoClip.ClipWidthMs = RestoreClipWidthMs;
        undoClip.UpdateMidiImageSource();
        undoClip.UpdateClipSourceSizeChanged();

        if (editingProject.pianoRoll.IsVisible)
            editingProject.pianoRoll.myClip = editingProject.pianoRoll.myClip; //to trigger redraw of pianoroll
    }

}

public class ClipNameChangedUndoClass : UndoClass
{
    public string UndoMainValue { get { return "Return clip name to: " + PreviousClipName; } }
    string UndoClipID;
    string PreviousClipName;
    public ClipNameChangedUndoClass(string undoClipID, string previousClipName)
    { UndoClipID = undoClipID; PreviousClipName = previousClipName; }
    public override void Undo() { GetClipFromID(UndoClipID).ClipName = PreviousClipName; }
}

public class ClipNormalizeUndoClass : UndoClass
{
    public string UndoMainValue { get { return "Undo clip normalization at idx: " + PreviousClipIndex.ToString(); } }
    int PreviousClipIndex;
    string PreviousClipJson;
    string UndoTrackID;

    public ClipNormalizeUndoClass(string undoTrackID, string previousClipJson, int previousClipIdx)
        { UndoTrackID = undoTrackID; PreviousClipJson = previousClipJson; PreviousClipIndex = previousClipIdx; IsLongUndoAction = true; PreventWhilePlaying = true; }

    public override void Undo()
    {
        Clip restoreClip = (Clip)JsonSerializer.Deserialize(PreviousClipJson, typeof(Clip));
        Track undoTrack = GetTrackFromID(UndoTrackID);
        undoTrack.Clips.RemoveAt(PreviousClipIndex);

        undoTrack.InsertClip(PreviousClipIndex, restoreClip);

    }

}