/***

  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/>.

***/

#include "preferencesgeneraltab.h"

#include <QGridLayout>
#include <QGroupBox>
#include <QLabel>
#include <QPushButton>

#include "common/autoscroll.h"
#include "core.h"
#include "dialog/sequence/sequence.h"
#include "node/project/sequence/sequence.h"

namespace olive {

PreferencesGeneralTab::PreferencesGeneralTab()
{
  QVBoxLayout* layout = new QVBoxLayout(this);

  {
    QGroupBox* global_groupbox = new QGroupBox(tr("Locale"));
    QGridLayout* global_layout = new QGridLayout(global_groupbox);
    layout->addWidget(global_groupbox);

    int row = 0;

    // General -> Language
    global_layout->addWidget(new QLabel(tr("Language:")), row, 0);

    language_combobox_ = new QComboBox();

    // Add default language (en-US)
    QDir language_dir(QStringLiteral(":/ts"));
    QStringList languages = language_dir.entryList();
    foreach (const QString& l, languages) {
      AddLanguage(l);
    }

    QString current_language = Config::Current()[QStringLiteral("Language")].toString();
    if (current_language.isEmpty()) {
      // No configured language, use system language
      current_language = QLocale::system().name();

      // If we don't have a language for this, default to en_US
      if (!languages.contains(current_language)) {
        current_language = QStringLiteral("en_US");
      }
    }
    language_combobox_->setCurrentIndex(languages.indexOf(current_language));

    global_layout->addWidget(language_combobox_, row, 1);
  }

  {
    QGroupBox* timeline_groupbox = new QGroupBox(tr("Timeline"));
    QGridLayout* timeline_layout = new QGridLayout(timeline_groupbox);
    layout->addWidget(timeline_groupbox);

    int row = 0;

    QLabel* autoscroll_lbl = new QLabel(tr("Auto-Scroll Method:"));
    autoscroll_lbl->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
    timeline_layout->addWidget(autoscroll_lbl, row, 0);

    // ComboBox indices match enum indices
    autoscroll_method_ = new QComboBox();
    autoscroll_method_->addItem(tr("None"), AutoScroll::kNone);
    autoscroll_method_->addItem(tr("Page Scrolling"), AutoScroll::kPage);
    autoscroll_method_->addItem(tr("Smooth Scrolling"), AutoScroll::kSmooth);
    autoscroll_method_->setCurrentIndex(Config::Current()["Autoscroll"].toInt());
    timeline_layout->addWidget(autoscroll_method_, row, 1);

    row++;

    timeline_layout->addWidget(new QLabel(tr("Rectified Waveforms:")), row, 0);

    rectified_waveforms_ = new QCheckBox();
    rectified_waveforms_->setChecked(Config::Current()["RectifiedWaveforms"].toBool());
    timeline_layout->addWidget(rectified_waveforms_, row, 1);

    row++;

    timeline_layout->addWidget(new QLabel(tr("Default Still Image Length:")), row, 0);

    default_still_length_ = new FloatSlider();
    default_still_length_->SetMinimum(0.1);
    default_still_length_->SetFormat(tr("%1 seconds"));
    default_still_length_->SetValue(Config::Current()["DefaultStillLength"].value<rational>().toDouble());
    timeline_layout->addWidget(default_still_length_);

    row++;

    timeline_layout->addWidget(new QLabel(tr("Default Sequence Parameters:")), row, 0);

    QPushButton* default_sequence_params_btn = new QPushButton(tr("Edit"));
    connect(default_sequence_params_btn, &QPushButton::clicked, this, &PreferencesGeneralTab::EditDefaultSequenceSettings);
    timeline_layout->addWidget(default_sequence_params_btn, row, 1);
  }

  {
    QGroupBox* autorecovery_groupbox = new QGroupBox(tr("Auto-Recovery"));
    QGridLayout* autorecovery_layout = new QGridLayout(autorecovery_groupbox);
    layout->addWidget(autorecovery_groupbox);

    int row = 0;

    autorecovery_layout->addWidget(new QLabel(tr("Enable Auto-Recovery:")), row, 0);

    autorecovery_enabled_ = new QCheckBox();
    autorecovery_enabled_->setChecked(Config::Current()[QStringLiteral("AutorecoveryEnabled")].toBool());
    autorecovery_layout->addWidget(autorecovery_enabled_, row, 1);

    row++;

    autorecovery_layout->addWidget(new QLabel(tr("Auto-Recovery Interval:")), row, 0);

    autorecovery_interval_ = new IntegerSlider();
    autorecovery_interval_->SetMinimum(1);
    autorecovery_interval_->SetMaximum(60);
    autorecovery_interval_->SetFormat(QT_TRANSLATE_N_NOOP("olive::SliderBase", "%n minute(s)"), true);
    autorecovery_interval_->SetValue(Config::Current()[QStringLiteral("AutorecoveryInterval")].toLongLong());
    autorecovery_layout->addWidget(autorecovery_interval_, row, 1);

    row++;

    autorecovery_layout->addWidget(new QLabel(tr("Maximum Versions Per Project:")), row, 0);

    autorecovery_maximum_ = new IntegerSlider();
    autorecovery_maximum_->SetMinimum(1);
    autorecovery_maximum_->SetMaximum(1000);
    autorecovery_maximum_->SetValue(Config::Current()[QStringLiteral("AutorecoveryMaximum")].toLongLong());
    autorecovery_layout->addWidget(autorecovery_maximum_, row, 1);

    row++;

    QPushButton* browse_autorecoveries = new QPushButton(tr("Browse Auto-Recoveries"));
    connect(browse_autorecoveries, &QPushButton::clicked, Core::instance(), &Core::BrowseAutoRecoveries);
    autorecovery_layout->addWidget(browse_autorecoveries, row, 1);
  }

  layout->addStretch();
}

void PreferencesGeneralTab::Accept(MultiUndoCommand *command)
{
  Q_UNUSED(command)

  Config::Current()[QStringLiteral("RectifiedWaveforms")] = rectified_waveforms_->isChecked();

  Config::Current()[QStringLiteral("Autoscroll")] = autoscroll_method_->currentData();

  Config::Current()[QStringLiteral("DefaultStillLength")] = QVariant::fromValue(rational::fromDouble(default_still_length_->GetValue()));

  QString set_language = language_combobox_->currentData().toString();
  if (QLocale::system().name() == set_language) {
    // Language is set to the system, assume this is effectively "auto"
    set_language = QString();
  }

  // If the language has changed, set it now
  if (Config::Current()[QStringLiteral("Language")].toString() != set_language) {
    Config::Current()[QStringLiteral("Language")] = set_language;
    Core::instance()->SetLanguage(set_language.isEmpty() ? QLocale::system().name() : set_language);
  }

  Config::Current()[QStringLiteral("AutorecoveryEnabled")] = autorecovery_enabled_->isChecked();
  Config::Current()[QStringLiteral("AutorecoveryInterval")] = QVariant::fromValue(autorecovery_interval_->GetValue());
  Config::Current()[QStringLiteral("AutorecoveryMaximum")] = QVariant::fromValue(autorecovery_maximum_->GetValue());
  Core::instance()->SetAutorecoveryInterval(autorecovery_interval_->GetValue());

  // Default sequence parameters
  VideoParams dsvp = default_sequence_.GetVideoParams();
  AudioParams dsap = default_sequence_.GetAudioParams();
  Config::Current()[QStringLiteral("DefaultSequenceWidth")] = dsvp.width();
  Config::Current()[QStringLiteral("DefaultSequenceHeight")] = dsvp.height();
  Config::Current()[QStringLiteral("DefaultSequencePixelAspect")] = QVariant::fromValue(dsvp.pixel_aspect_ratio());
  Config::Current()[QStringLiteral("DefaultSequenceFrameRate")] = QVariant::fromValue(dsvp.frame_rate().flipped());
  Config::Current()[QStringLiteral("DefaultSequenceInterlacing")] = dsvp.interlacing();
  Config::Current()[QStringLiteral("DefaultSequenceAudioFrequency")] = dsap.sample_rate();
  Config::Current()[QStringLiteral("DefaultSequenceAudioLayout")] = QVariant::fromValue(dsap.channel_layout());
}

void PreferencesGeneralTab::AddLanguage(const QString &locale_name)
{
  language_combobox_->addItem(tr("%1 (%2)").arg(QLocale(locale_name).nativeLanguageName(),
                                                locale_name));;
  language_combobox_->setItemData(language_combobox_->count() - 1, locale_name);
}

void PreferencesGeneralTab::EditDefaultSequenceSettings()
{
  SequenceDialog sd(&default_sequence_, SequenceDialog::kExisting, this);
  sd.SetNameIsEditable(false);
  sd.exec();
}

}