/***

  Olive - Non-Linear Video Editor
  Copyright (C) 2019  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/>.

***/

#include "sequence.h"

#include <QCoreApplication>

#include "panels/panels.h"
#include "global/debug.h"

Sequence::Sequence() :
  playhead(0),
  using_workarea(false),
  workarea_in(0),
  workarea_out(0),
  wrapper_sequence(false)
{
  // Set up tracks
  track_lists_.resize(Track::kTypeCount);

  for (int i=0;i<track_lists_.size();i++) {
    track_lists_[i] = new TrackList(this, static_cast<Track::Type>(i));
  }
}

SequencePtr Sequence::copy() {
  SequencePtr s = std::make_shared<Sequence>();
  s->name = QCoreApplication::translate("Sequence", "%1 (copy)").arg(name);
  s->width = width;
  s->height = height;
  s->frame_rate = frame_rate;
  s->audio_frequency = audio_frequency;
  s->audio_layout = audio_layout;

  // deep copy all of the sequence's clips
  for (int i=0;i<track_lists_.size();i++) {
    s->track_lists_[i] = track_lists_.at(i)->copy(s.get());
  }

  // copy all of the sequence's markers
  s->markers = markers;

  return s;
}

void Sequence::Save(QXmlStreamWriter &stream)
{
  // Provide unique IDs for each Clip
  QVector<Clip*> all_clips = GetAllClips();
  for (int i=0;i<all_clips.size();i++) {
    all_clips.at(i)->load_id = i;
  }

  stream.writeStartElement("sequence");
  stream.writeAttribute("id", QString::number(save_id));
  stream.writeAttribute("name", name);
  stream.writeAttribute("width", QString::number(width));
  stream.writeAttribute("height", QString::number(height));
  stream.writeAttribute("framerate", QString::number(frame_rate, 'f', 10));
  stream.writeAttribute("afreq", QString::number(audio_frequency));
  stream.writeAttribute("alayout", QString::number(audio_layout));
  if (this == olive::ActiveSequence.get()) {
    stream.writeAttribute("open", "1");
  }
  stream.writeAttribute("workarea", QString::number(using_workarea));
  stream.writeAttribute("workareaIn", QString::number(workarea_in));
  stream.writeAttribute("workareaOut", QString::number(workarea_out));

  QVector<TransitionPtr> transition_save_cache;
  QVector<int> transition_clip_save_cache;

  for (int j=0;j<track_lists_.size();j++) {
    track_lists_.at(j)->Save(stream);
  }

  for (int j=0;j<markers.size();j++) {
    markers.at(j).Save(stream);
  }

  stream.writeEndElement();
}

long Sequence::GetEndFrame() {
  long end_frame = 0;

  for (int j=0;j<track_lists_.size();j++) {

    TrackList* track_list = track_lists_.at(j);

    for (int i=0;i<track_list->TrackCount();i++) {
      end_frame = qMax(track_list->TrackAt(i)->GetEndFrame(), end_frame);
    }

  }

  return end_frame;
}

QVector<Clip *> Sequence::GetAllClips()
{
  QVector<Clip*> all_clips;

  for (int j=0;j<track_lists_.size();j++) {

    TrackList* track_list = track_lists_.at(j);

    for (int i=0;i<track_list->TrackCount();i++) {
      all_clips.append(track_list->TrackAt(i)->GetAllClips());
    }

  }

  return all_clips;
}

TrackList *Sequence::GetTrackList(Track::Type type)
{
  return track_lists_.at(type);
}

void Sequence::Close()
{
  QVector<Clip*> all_clips = GetAllClips();

  for (int i=0;i<all_clips.size();i++) {
    all_clips.at(i)->Close(true);
  }
}

void Sequence::RefreshClipsUsingMedia(Media *m) {

  QVector<Clip*> all_clips = GetAllClips();

  for (int i=0;i<all_clips.size();i++) {
    Clip* c = all_clips.at(i);

    if (m == nullptr || c->media() == m) {
      c->Close(true);
      c->refresh();
    }
  }

}

QVector<Clip *> Sequence::SelectedClips(bool containing)
{
  QVector<Clip*> selected_clips;

  for (int i=0;i<track_lists_.size();i++) {
    TrackList* tl = track_lists_.at(i);

    for (int j=0;j<tl->TrackCount();j++) {
      Track* t = tl->TrackAt(j);

      selected_clips.append(t->GetAllClips());
    }
  }

  return selected_clips;
}

void Sequence::DeleteAreas(ComboAction* ca, QVector<Selection>& areas, bool deselect_areas)
{
  clean_up_selections(areas);

  panel_graph_editor->set_row(nullptr);
  panel_effect_controls->Clear(true);

  QVector<int> pre_clips;
  QVector<ClipPtr> post_clips;

  QVector<Clip*> all_clips = GetAllClips();

  for (int i=0;i<areas.size();i++) {
    const Selection& s = areas.at(i);
    for (int j=0;j<all_clips.size();j++) {
      Clip* c = all_clips.at(j);
      if (c != nullptr && c->track() == s.track && !c->undeletable) {
        if (selection_contains_transition(s, c, kTransitionOpening)) {
          // delete opening transition
          ca->append(new DeleteTransitionCommand(c->opening_transition));
        } else if (selection_contains_transition(s, c, kTransitionClosing)) {
          // delete closing transition
          ca->append(new DeleteTransitionCommand(c->closing_transition));
        } else if (c->timeline_in() >= s.in && c->timeline_out() <= s.out) {
          // clips falls entirely within deletion area
          ca->append(new DeleteClipAction(c));
        } else if (c->timeline_in() < s.in && c->timeline_out() > s.out) {
          // middle of clip is within deletion area

          // duplicate clip
          ClipPtr post = SplitClip(ca, true, c, s.in, s.out);

          pre_clips.append(j);
          post_clips.append(post);
        } else if (c->timeline_in() < s.in && c->timeline_out() > s.in) {
          // only out point is in deletion area
          c->move(ca, c->timeline_in(), s.in, c->clip_in(), c->track());

          if (c->closing_transition != nullptr) {
            if (s.in < c->timeline_out() - c->closing_transition->get_true_length()) {
              ca->append(new DeleteTransitionCommand(c->closing_transition));
            } else {
              ca->append(new ModifyTransitionCommand(c->closing_transition, c->closing_transition->get_true_length() - (c->timeline_out() - s.in)));
            }
          }
        } else if (c->timeline_in() < s.out && c->timeline_out() > s.out) {
          // only in point is in deletion area
          c->move(ca, s.out, c->timeline_out(), c->clip_in() + (s.out - c->timeline_in()), c->track());

          if (c->opening_transition != nullptr) {
            if (s.out > c->timeline_in() + c->opening_transition->get_true_length()) {
              ca->append(new DeleteTransitionCommand(c->opening_transition));
            } else {
              ca->append(new ModifyTransitionCommand(c->opening_transition, c->opening_transition->get_true_length() - (s.out - c->timeline_in())));
            }
          }
        }
      }
    }
  }

  // deselect selected clip areas
  if (deselect_areas) {
    QVector<Selection> area_copy = areas;
    for (int i=0;i<area_copy.size();i++) {
      const Selection& s = area_copy.at(i);
      deselect_area(s.in, s.out, s.track);
    }
  }

  relink_clips_using_ids(pre_clips, post_clips);
  ca->append(new AddClipCommand(olive::ActiveSequence.get(), post_clips));
}

bool Sequence::SplitAllClipsAtPoint(ComboAction *ca, long point)
{
  bool split = false;

  QVector<Clip*> all_clips = GetAllClips();

  for (int j=0;j<all_clips.size();j++) {
    Clip* c = all_clips.at(j);

    if (c->IsActiveAt(point)) {
      SplitClipAtPositions(ca, c, {point}, true);
      split = true;
    }
  }

  return split;
}

void Sequence::SplitClipAtPositions(ComboAction *ca, Clip* clip, QVector<long> positions, bool relink)
{
  // Add the clip and each of its links to the pre_splits array

  QVector<Clip*> pre_splits;
  pre_splits.append(clip);

  if (relink) {
    for (int i=0;i<clip->linked.size();i++)   {
      pre_splits.append(clip->linked.at(i));
    }
  }

  std::sort(positions.begin(), positions.end());

  // Remove any duplicate positions
  for (int i=1;i<positions.size();i++) {
    if (positions.at(i-1) == positions.at(i)) {
      positions.removeAt(i);
      i--;
    }
  }

  QVector< QVector<ClipPtr> > post_splits(positions.size());

  for (int i=positions.size()-1;i>=0;i--) {

    post_splits[i].resize(pre_splits.size());

    for (int j=0;j<pre_splits.size();j++) {
      post_splits[i][j] = SplitClip(ca, true, pre_splits.at(j), positions.at(i));

      if (post_splits[i][j] != nullptr && i + 1 < positions.size()) {
        post_splits[i][j]->set_timeline_out(positions.at(i+1));
      }
    }
  }

  for (int i=0;i<post_splits.size();i++) {
    olive::timeline::RelinkClips(pre_splits, post_splits[i]);
    ca->append(new AddClipCommand(olive::ActiveSequence.get(), post_splits[i]));
  }
}

/*
QVector<int> Sequence::SelectedClipIndexes()
{
  QVector<int> selected_clips;

  for (int i=0;i<clips.size();i++) {
    Clip* c = clips.at(i).get();
    if (c != nullptr && IsClipSelected(c, true)) {
      selected_clips.append(i);
    }
  }

  return selected_clips;
}
*/

Effect *Sequence::GetSelectedGizmo()
{
  Effect* gizmo_ptr = nullptr;

  QVector<Clip*> clips = GetAllClips();

  for (int i=0;i<clips.size();i++) {
    Clip* c = clips.at(i);
    if (c->IsActiveAt(playhead)
        && IsClipSelected(c, true)) {
      // This clip is selected and currently active - we'll use this for gizmos

      if (!c->effects.isEmpty()) {

        // find which effect has gizmos selected, or default to the first gizmo effect we find if there is
        // none selected

        for (int j=0;j<c->effects.size();j++) {
          Effect* e = c->effects.at(j).get();

          // retrieve gizmo data from effect
          if (e->are_gizmos_enabled()) {
            if (gizmo_ptr == nullptr) {
              gizmo_ptr = e;
            }
            if (panel_effect_controls->IsEffectSelected(e)) {
              gizmo_ptr = e;
              break;
            }
          }
        }
      }

      if (gizmo_ptr != nullptr) {
        break;
      }
    }
  }

  return gizmo_ptr;
}

void Sequence::ClearSelections()
{
  for (int j=0;j<track_lists_.size();j++) {
    TrackList* tl = track_lists_.at(j);

    for (int i=0;i<tl->TrackCount();i++) {
      tl->TrackAt(i)->ClearSelections();
    }
  }
}

ClipPtr Sequence::SplitClip(ComboAction *ca, bool transitions, Clip* pre, long frame)
{
  return SplitClip(ca, transitions, pre, frame, frame);
}

ClipPtr Sequence::SplitClip(ComboAction *ca, bool transitions, Clip* pre, long frame, long post_in)
{
  if (pre == nullptr) {
    return nullptr;
  }

  if (pre->timeline_in() < frame && pre->timeline_out() > frame) {
    // duplicate clip without duplicating its transitions, we'll restore them later

    ClipPtr post = pre->copy(pre->track());

    long new_clip_length = frame - pre->timeline_in();

    post->set_timeline_in(post_in);
    post->set_clip_in(pre->clip_in() + (post->timeline_in() - pre->timeline_in()));

    pre->move(ca, pre->timeline_in(), frame, pre->clip_in(), pre->track(), false);

    if (transitions) {

      // check if this clip has a closing transition
      if (pre->closing_transition != nullptr) {

        // if so, move closing transition to the post clip
        post->closing_transition = pre->closing_transition;

        // and set the original clip's closing transition to nothing
        ca->append(new SetPointer(reinterpret_cast<void**>(&pre->closing_transition), nullptr));

        // and set the transition's reference to the post clip
        if (post->closing_transition->parent_clip == pre) {
          ca->append(new SetPointer(reinterpret_cast<void**>(&post->closing_transition->parent_clip), post.get()));
        }
        if (post->closing_transition->secondary_clip == pre) {
          ca->append(new SetPointer(reinterpret_cast<void**>(&post->closing_transition->secondary_clip), post.get()));
        }

        // and make sure it's at the correct size to the closing clip
        if (post->closing_transition != nullptr && post->closing_transition->get_true_length() > post->length()) {
          ca->append(new ModifyTransitionCommand(post->closing_transition, post->length()));
          post->closing_transition->set_length(post->length());
        }

      }

      // we're keeping the opening clip, so ensure that's a correct size too
      if (pre->opening_transition != nullptr && pre->opening_transition->get_true_length() > new_clip_length) {
        ca->append(new ModifyTransitionCommand(pre->opening_transition, new_clip_length));
      }
    }

    return post;

  } else if (frame == pre->timeline_in()
             && pre->opening_transition != nullptr
             && pre->opening_transition->secondary_clip != nullptr) {
    // special case for shared transitions to split it into two

    // set transition to single-clip mode
    ca->append(new SetPointer(reinterpret_cast<void**>(&pre->opening_transition->secondary_clip), nullptr));

    // clone transition for other clip
    ca->append(new AddTransitionCommand(nullptr,
                                        pre->opening_transition->secondary_clip,
                                        pre->opening_transition,
                                        nullptr,
                                        0)
               );

  }

  return nullptr;
}

// static variable for the currently active sequence
SequencePtr olive::ActiveSequence = nullptr;