/***

  Olive - Non-Linear Video Editor
  Copyright (C) 2020 Olive Team

  This program is free software: you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
  the Free Software Foundation, either version 3 of the License, or
  (at your option) any later version.

  This program is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU General Public License for more details.

  You should have received a copy of the GNU General Public License
  along with this program.  If not, see <http://www.gnu.org/licenses/>.

***/

#ifndef TIMELINEUNDOABLE_H
#define TIMELINEUNDOABLE_H

#include <QUndoCommand>

#include "node/block/block.h"
#include "node/block/gap/gap.h"
#include "node/block/transition/transition.h"
#include "node/output/track/track.h"
#include "node/output/track/tracklist.h"
#include "timeline/timelinepoints.h"
#include "undo/undocommand.h"
#include "widget/timelinewidget/timelinewidgetselections.h"

namespace olive {

class BlockResizeCommand : public UndoCommand {
public:
  BlockResizeCommand(Block* block, rational new_length, QUndoCommand* parent = nullptr) :
    UndoCommand(parent),
    block_(block),
    new_length_(new_length)
  {
  }

  virtual Project* GetRelevantProject() const override
  {
    return block_->parent()->project();
  }

protected:
  virtual void redo_internal() override
  {
    old_length_ = block_->length();
    block_->set_length_and_media_out(new_length_);
  }

  virtual void undo_internal() override
  {
    block_->set_length_and_media_out(old_length_);
  }

private:
  Block* block_;
  rational old_length_;
  rational new_length_;

};

class BlockResizeWithMediaInCommand : public UndoCommand {
public:
  BlockResizeWithMediaInCommand(Block* block, rational new_length, QUndoCommand* parent = nullptr) :
    UndoCommand(parent),
    block_(block),
    new_length_(new_length)
  {
  }

  virtual Project* GetRelevantProject() const override
  {
    return block_->parent()->project();
  }

protected:
  virtual void redo_internal() override
  {
    old_length_ = block_->length();
    block_->set_length_and_media_in(new_length_);
  }

  virtual void undo_internal() override
  {
    block_->set_length_and_media_in(old_length_);
  }

private:
  Block* block_;
  rational old_length_;
  rational new_length_;
};

class BlockTrimCommand : public UndoCommand {
public:
  BlockTrimCommand(Track *track, Block* block, rational new_length, Timeline::MovementMode mode, QUndoCommand* command = nullptr);

  virtual Project* GetRelevantProject() const override;

  void SetTrimIsARollEdit(bool e)
  {
    trim_is_a_roll_edit_ = e;
  }

protected:
  virtual void redo_internal() override;
  virtual void undo_internal() override;

private:
  Track* track_;
  Block* block_;
  rational old_length_;
  rational new_length_;
  Timeline::MovementMode mode_;

  Block* adjacent_;
  bool we_created_adjacent_;
  bool we_deleted_adjacent_;

  bool trim_is_a_roll_edit_;

  QObject memory_manager_;

};

class BlockSetMediaInCommand : public UndoCommand {
public:
  BlockSetMediaInCommand(Block* block, rational new_media_in, QUndoCommand* parent = nullptr) :
    UndoCommand(parent),
    block_(block),
    new_media_in_(new_media_in)
  {
  }

  virtual Project* GetRelevantProject() const override
  {
    return block_->parent()->project();
  }

protected:
  virtual void redo_internal() override
  {
    old_media_in_ = block_->media_in();
    block_->set_media_in(new_media_in_);
  }

  virtual void undo_internal() override
  {
    block_->set_media_in(old_media_in_);
  }

private:
  Block* block_;
  rational old_media_in_;
  rational new_media_in_;
};

class TrackRippleRemoveBlockCommand : public UndoCommand {
public:
  TrackRippleRemoveBlockCommand(Track* track, Block* block, QUndoCommand* parent = nullptr) :
    UndoCommand(parent),
    track_(track),
    block_(block)
  {
  }

  virtual Project* GetRelevantProject() const override
  {
    return track_->parent()->project();
  }

protected:
  virtual void redo_internal() override
  {
    before_ = block_->previous();
    track_->RippleRemoveBlock(block_);
  }

  virtual void undo_internal() override
  {
    if (before_) {
      track_->InsertBlockAfter(block_, before_);
    } else {
      track_->PrependBlock(block_);
    }
  }

private:
  Track* track_;

  Block* block_;

  Block* before_;

};

class TrackPrependBlockCommand : public UndoCommand {
public:
  TrackPrependBlockCommand(Track* track, Block* block, QUndoCommand* parent = nullptr);

  virtual Project* GetRelevantProject() const override;

protected:
  virtual void redo_internal() override;
  virtual void undo_internal() override;

private:
  Track* track_;
  Block* block_;
};

class TrackInsertBlockAfterCommand : public UndoCommand {
public:
  TrackInsertBlockAfterCommand(Track* track, Block* block, Block* before, QUndoCommand* parent = nullptr) :
    UndoCommand(parent),
    track_(track),
    block_(block),
    before_(before)
  {
  }

  virtual Project* GetRelevantProject() const override
  {
    return block_->parent()->project();
  }

protected:
  virtual void redo_internal() override
  {
    track_->InsertBlockAfter(block_, before_);
  }

  virtual void undo_internal() override
  {
    track_->RippleRemoveBlock(block_);
  }

private:
  Track* track_;

  Block* block_;

  Block* before_;
};

/**
 * @brief Clears the area between in and out
 *
 * The area between `in` and `out` is guaranteed to be freed. BLocks are trimmed and removed to free this space.
 * By default, nothing takes this area meaning all subsequent clips are pushed backward, however you can specify
 * a block to insert at the `in` point. No checking is done to ensure `insert` is the same length as `in` to `out`.
 */
class TrackRippleRemoveAreaCommand : public UndoCommand {
public:
  TrackRippleRemoveAreaCommand(Track* track, rational in, rational out, QUndoCommand* parent = nullptr);

  virtual Project* GetRelevantProject() const override;

  void SetInsert(Block* insert);

protected:
  virtual void redo_internal() override;
  virtual void undo_internal() override;

protected:
  Project* project_;

  Track* track_;
  rational in_;
  rational out_;

  bool splice_;
  QUndoCommand* splice_split_command_;

  Block* trim_out_;
  Block* trim_in_;
  QVector<Block*> removed_blocks_;

  rational trim_in_old_length_;
  rational trim_out_old_length_;

  rational trim_in_new_length_;
  rational trim_out_new_length_;

  Block* insert_;

  QObject memory_manager_;

  QVector<QUndoCommand*> remove_block_commands_;

};

class TrackListRippleRemoveAreaCommand : public UndoCommand {
public:
  TrackListRippleRemoveAreaCommand(TrackList* list, rational in, rational out, QUndoCommand* parent = nullptr);

  virtual ~TrackListRippleRemoveAreaCommand() override;

  virtual Project* GetRelevantProject() const override;

protected:
  virtual void redo_internal() override;
  virtual void undo_internal() override;

private:
  TrackList* list_;

  QList<Track*> working_tracks_;

  rational in_;

  rational out_;

  bool all_tracks_unlocked_;

  QVector<TrackRippleRemoveAreaCommand*> commands_;

};

class TimelineRippleRemoveAreaCommand : public UndoCommand {
public:
  TimelineRippleRemoveAreaCommand(ViewerOutput* timeline, rational in, rational out, QUndoCommand* parent = nullptr);

  virtual Project* GetRelevantProject() const override;

private:
  ViewerOutput* timeline_;

};

class TrackListRippleToolCommand : public UndoCommand {
public:
  struct RippleInfo {
    Block* block;
    Block* ref_block;
    Track* track;
    rational new_length;
    rational old_length;
  };

  TrackListRippleToolCommand(TrackList* track_list,
                             const QList<RippleInfo>& info,
                             const Timeline::MovementMode& movement_mode,
                             QUndoCommand* parent = nullptr);

  virtual Project* GetRelevantProject() const override;

protected:
  virtual void redo_internal() override;
  virtual void undo_internal() override;

private:
  TrackList* track_list_;

  QList<RippleInfo> info_;
  Timeline::MovementMode movement_mode_;

  struct WorkingData {
    GapBlock* created_gap;
    Block* removed_gap_after;
  };

  QVector<WorkingData> working_data_;

  QObject memory_manager_;

  bool all_tracks_unlocked_;

};

/**
 * @brief Destructively places `block` at the in point `start`
 *
 * The Block is guaranteed to be placed at the starting point specified. If there are Blocks in this area, they are
 * either trimmed or removed to make space for this Block. Additionally, if the Block is placed beyond the end of
 * the Sequence, a GapBlock is inserted to compensate.
 */
class TrackPlaceBlockCommand : public TrackRippleRemoveAreaCommand {
public:
  TrackPlaceBlockCommand(TrackList *timeline, int track, Block* block, rational in, QUndoCommand* parent = nullptr);

  virtual Project* GetRelevantProject() const override;

protected:
  virtual void redo_internal() override;
  virtual void undo_internal() override;

private:
  TrackList* timeline_;
  int track_index_;
  bool append_;
  GapBlock* gap_;
  QVector<Track*> added_tracks_;

};

class BlockSplitCommand : public UndoCommand {
public:
  BlockSplitCommand(Track* track, Block* block, rational point, QUndoCommand* parent = nullptr);

  virtual Project* GetRelevantProject() const override;

  Block* new_block();

protected:
  virtual void redo_internal() override;
  virtual void undo_internal() override;

private:
  Track* track_;
  Block* block_;
  Block* new_block_;

  rational new_length_;
  rational old_length_;
  rational point_;

  QList<NodeInput*> transitions_to_move_;

  QObject memory_manager_;

  QUndoCommand* add_command_;

};

class TrackSplitAtTimeCommand : public UndoCommand {
public:
  TrackSplitAtTimeCommand(Track* track, rational point, QUndoCommand* parent = nullptr);

  virtual Project* GetRelevantProject() const override;

private:
  Track* track_;

};

class BlockSplitPreservingLinksCommand : public UndoCommand {
public:
  BlockSplitPreservingLinksCommand(const QVector<Block *> &blocks, const QList<rational>& times, QUndoCommand* parent = nullptr);

  virtual Project* GetRelevantProject() const override;

private:
  QVector<Block *> blocks_;

  QList<rational> times_;
};

/**
 * @brief Replaces Block `old` with Block `replace`
 *
 * Both blocks must have equal lengths.
 */
class TrackReplaceBlockCommand : public UndoCommand {
public:
  TrackReplaceBlockCommand(Track* track, Block* old, Block* replace, QUndoCommand* parent = nullptr);

  virtual Project* GetRelevantProject() const override;

protected:
  virtual void redo_internal() override;
  virtual void undo_internal() override;

private:
  Track* track_;
  Block* old_;
  Block* replace_;
};

class TrackReplaceBlockWithGapCommand : public UndoCommand {
public:
  TrackReplaceBlockWithGapCommand(Track* track, Block* block, QUndoCommand* command = nullptr);

  virtual Project* GetRelevantProject() const override;

protected:
  virtual void redo_internal() override;
  virtual void undo_internal() override;

private:
  Track* track_;
  Block* block_;

  GapBlock* existing_gap_;
  GapBlock* existing_merged_gap_;
  bool existing_gap_precedes_;
  GapBlock* our_gap_;

  QObject memory_manager_;

};

class TimelineRippleDeleteGapsAtRegionsCommand : public UndoCommand {
public:
  TimelineRippleDeleteGapsAtRegionsCommand(ViewerOutput* vo, const TimeRangeList& regions, QUndoCommand* parent = nullptr);

  virtual Project* GetRelevantProject() const override;

protected:
  virtual void redo_internal() override;
  virtual void undo_internal() override;

private:
  ViewerOutput* timeline_;
  TimeRangeList regions_;

  QList<UndoCommand*> commands_;

};

class WorkareaSetEnabledCommand : public UndoCommand {
public:
  WorkareaSetEnabledCommand(Project *project, TimelinePoints* points, bool enabled, QUndoCommand* parent = nullptr);

  virtual Project* GetRelevantProject() const override;

protected:
  virtual void redo_internal() override;
  virtual void undo_internal() override;

private:
  Project* project_;

  TimelinePoints* points_;

  bool old_enabled_;

  bool new_enabled_;

};

class WorkareaSetRangeCommand : public UndoCommand {
public:
  WorkareaSetRangeCommand(Project *project, TimelinePoints* points, const TimeRange& range, QUndoCommand* parent = nullptr);

  virtual Project* GetRelevantProject() const override;

protected:
  virtual void redo_internal() override;
  virtual void undo_internal() override;

private:
  Project* project_;

  TimelinePoints* points_;

  TimeRange old_range_;

  TimeRange new_range_;

};

class BlockLinkManyCommand : public UndoCommand {
public:
  BlockLinkManyCommand(const QVector<Block*> blocks, bool link, QUndoCommand* parent = nullptr);

  virtual Project* GetRelevantProject() const override;

private:
  QVector<Block*> blocks_;

};

class BlockLinkCommand : public UndoCommand {
public:
  BlockLinkCommand(Block* a, Block* b, bool link, QUndoCommand* parent = nullptr);

  virtual Project* GetRelevantProject() const override;

protected:
  virtual void redo_internal() override;
  virtual void undo_internal() override;

private:
  Block* a_;

  Block* b_;

  bool link_;

  bool done_;

};

class BlockUnlinkAllCommand : public UndoCommand {
public:
  BlockUnlinkAllCommand(Block* block, QUndoCommand* parent = nullptr);

  virtual Project* GetRelevantProject() const override;

protected:
  virtual void redo_internal() override;
  virtual void undo_internal() override;

private:
  Block* block_;

  QVector<Block*> unlinked_;

};

class BlockEnableDisableCommand : public UndoCommand {
public:
  BlockEnableDisableCommand(Block* block, bool enabled, QUndoCommand* parent = nullptr);

  virtual Project* GetRelevantProject() const override;

protected:
  virtual void redo_internal() override;
  virtual void undo_internal() override;

private:
  Block* block_;

  bool old_enabled_;

  bool new_enabled_;

};

class TrackSlideCommand : public UndoCommand {
public:
  TrackSlideCommand(Track* track, const QList<Block*>& moving_blocks, Block* in_adjacent, Block* out_adjacent, const rational& movement, QUndoCommand* parent = nullptr);

  virtual Project* GetRelevantProject() const override;

protected:
  virtual void redo_internal() override;
  virtual void undo_internal() override;

private:
  void slide_internal(bool undo);

  Track* track_;
  QList<Block*> blocks_;
  rational movement_;

  bool we_created_in_adjacent_;
  Block* in_adjacent_;
  bool we_created_out_adjacent_;
  Block* out_adjacent_;

  QObject memory_manager_;

};

class TrackListInsertGaps : public UndoCommand {
public:
  TrackListInsertGaps(TrackList* track_list, const rational& point, const rational& length, QUndoCommand* parent = nullptr);

  virtual Project* GetRelevantProject() const override;

protected:
  virtual void redo_internal() override;
  virtual void undo_internal() override;

private:
  TrackList* track_list_;

  rational point_;

  rational length_;

  QList<Track*> working_tracks_;

  bool all_tracks_unlocked_;

  QList<Block*> gaps_to_extend_;

  QList<GapBlock*> gaps_added_;

  BlockSplitPreservingLinksCommand* split_command_;

  QObject memory_manager_;

};

class TransitionRemoveCommand : public UndoCommand {
public:
  TransitionRemoveCommand(Track *track, TransitionBlock* block, QUndoCommand *parent = nullptr);

  virtual Project* GetRelevantProject() const override;

protected:
  virtual void redo_internal() override;
  virtual void undo_internal() override;

private:
  Track* track_;

  TransitionBlock* block_;

  Block* out_block_;
  Block* in_block_;

};

class TimelineWidget;

class TimelineSetSelectionsCommand : public QUndoCommand {
public:
  TimelineSetSelectionsCommand(TimelineWidget* timeline, const TimelineWidgetSelections& now, const TimelineWidgetSelections& old, QUndoCommand* parent = nullptr);

protected:
  virtual void redo() override;
  virtual void undo() override;

private:
  TimelineWidget* timeline_;
  TimelineWidgetSelections old_;
  TimelineWidgetSelections now_;

};

}

#endif // TIMELINEUNDOABLE_H