/*

 * Hedgewars, a free turn based strategy game

 * Copyright (c) 2004-2012 Andrey Korotaev <unC0Rr@gmail.com>

 *

 * 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; version 2 of the License

 *

 * 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, write to the Free Software

 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA

 */

#include <QGridLayout>

#include <QPushButton>

#include <QGroupBox>

#include <QComboBox>

#include <QCheckBox>

#include <QLabel>

#include <QLineEdit>

#include <QSpinBox>

#include <QTableWidget>

#include <QDir>

#include <QProgressBar>

#include <QStringList>

#include <QDesktopServices>

#include <QUrl>

#include <QList>

#include <QMessageBox>

#include <QHeaderView>

#include <QKeyEvent>

#include <QVBoxLayout>

#include <QHBoxLayout>

#include <QFileSystemWatcher>

#include <QDateTime>

#include <QRegExp>

#include <QNetworkAccessManager>

#include <QNetworkRequest>

#include <QNetworkReply>

#include <QXmlStreamReader>

#include "hwconsts.h"

#include "pagevideos.h"

#include "igbox.h"

#include "libav_iteraction.h"

#include "gameuiconfig.h"

#include "recorder.h"

#include "ask_quit.h"

#include "upload_video.h"

static const QSize ThumbnailSize(350, 350*3/5);

// columns in table with list of video files

enum VideosColumns

{

    vcName,

    vcSize,

    vcProgress, // either encoding or uploading

    vcNumColumns,

};

// this class is used for items in first column in file-table

class VideoItem : public QTableWidgetItem

{

    // note: QTableWidgetItem is not Q_OBJECT

    public:

        VideoItem(const QString& name);

        ~VideoItem();

        QString name;

        QString prefix; // original filename without extension

        QString desc;   // description (duration, resolution, etc...)

        QString uploadUrl; // http://youtu.be/???????

        HWRecorder    * pRecorder; // non NULL if file is being encoded

        QNetworkReply * pUploading; // non NULL if file is being uploaded

        bool seen; // used when updating directory

        float lastSizeUpdate;

        float progress;

        bool ready()

        { return !pRecorder; }

        QString path()

        { return cfgdir->absoluteFilePath("Videos/" + name);  }

};

VideoItem::VideoItem(const QString& name)

    : QTableWidgetItem(name, UserType)

{

    this->name = name;

    pRecorder = NULL;

    pUploading = NULL;

    lastSizeUpdate = 0;

    progress = 0;

}

VideoItem::~VideoItem()

{}

QLayout * PageVideos::bodyLayoutDefinition()

{

    QGridLayout * pPageLayout = new QGridLayout();

    pPageLayout->setColumnStretch(0, 1);

    pPageLayout->setColumnStretch(1, 2);

    pPageLayout->setRowStretch(0, 1);

    pPageLayout->setRowStretch(1, 1);

    // options

    {

        IconedGroupBox* pOptionsGroup = new IconedGroupBox(this);

        pOptionsGroup->setIcon(QIcon(":/res/Settings.png")); // FIXME

        pOptionsGroup->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);

        pOptionsGroup->setTitle(QGroupBox::tr("Video recording options"));

        QGridLayout * pOptLayout = new QGridLayout(pOptionsGroup);

        // label for format

        QLabel *labelFormat = new QLabel(pOptionsGroup);

        labelFormat->setText(QLabel::tr("Format"));

        pOptLayout->addWidget(labelFormat, 0, 0);

        // list of supported formats

        comboAVFormats = new QComboBox(pOptionsGroup);

        pOptLayout->addWidget(comboAVFormats, 0, 1, 1, 4);

        LibavIteraction::instance().fillFormats(comboAVFormats);

        // separator

        QFrame * hr = new QFrame(pOptionsGroup);

        hr->setFrameStyle(QFrame::HLine);

        hr->setLineWidth(3);

        hr->setFixedHeight(10);

        pOptLayout->addWidget(hr, 1, 0, 1, 5);

        // label for audio codec

        QLabel *labelACodec = new QLabel(pOptionsGroup);

        labelACodec->setText(QLabel::tr("Audio codec"));

        pOptLayout->addWidget(labelACodec, 2, 0);

        // list of supported audio codecs

        comboAudioCodecs = new QComboBox(pOptionsGroup);

        pOptLayout->addWidget(comboAudioCodecs, 2, 1, 1, 3);

        // checkbox 'record audio'

        checkRecordAudio = new QCheckBox(pOptionsGroup);

        checkRecordAudio->setText(QCheckBox::tr("Record audio"));

        pOptLayout->addWidget(checkRecordAudio, 2, 4);

        // separator

        hr = new QFrame(pOptionsGroup);

        hr->setFrameStyle(QFrame::HLine);

        hr->setLineWidth(3);

        hr->setFixedHeight(10);

        pOptLayout->addWidget(hr, 3, 0, 1, 5);

        // label for video codec

        QLabel *labelVCodec = new QLabel(pOptionsGroup);

        labelVCodec->setText(QLabel::tr("Video codec"));

        pOptLayout->addWidget(labelVCodec, 4, 0);

        // list of supported video codecs

        comboVideoCodecs = new QComboBox(pOptionsGroup);

        pOptLayout->addWidget(comboVideoCodecs, 4, 1, 1, 4);

        // label for resolution

        QLabel *labelRes = new QLabel(pOptionsGroup);

        labelRes->setText(QLabel::tr("Resolution"));

        pOptLayout->addWidget(labelRes, 5, 0);

        // width

        widthEdit = new QLineEdit(pOptionsGroup);

        widthEdit->setValidator(new QIntValidator(this));

        pOptLayout->addWidget(widthEdit, 5, 1);

        // x

        QLabel *labelX = new QLabel(pOptionsGroup);

        labelX->setText("X");

        pOptLayout->addWidget(labelX, 5, 2);

        // height

        heightEdit = new QLineEdit(pOptionsGroup);

        heightEdit->setValidator(new QIntValidator(pOptionsGroup));

        pOptLayout->addWidget(heightEdit, 5, 3);

        // checkbox 'use game resolution'

        checkUseGameRes = new QCheckBox(pOptionsGroup);

        checkUseGameRes->setText(QCheckBox::tr("Use game resolution"));

        pOptLayout->addWidget(checkUseGameRes, 5, 4);

        // label for framerate

        QLabel *labelFramerate = new QLabel(pOptionsGroup);

        labelFramerate->setText(QLabel::tr("Framerate"));

        pOptLayout->addWidget(labelFramerate, 6, 0);

        // framerate

        framerateBox = new QSpinBox(pOptionsGroup);

        framerateBox->setRange(1, 200);

        framerateBox->setSingleStep(1);

        pOptLayout->addWidget(framerateBox, 6, 1);

        // button 'set default options'

        btnDefaults = new QPushButton(pOptionsGroup);

        btnDefaults->setText(QPushButton::tr("Set default options"));

        pOptLayout->addWidget(btnDefaults, 7, 0, 1, 5);

        pPageLayout->addWidget(pOptionsGroup, 1, 0);

    }

    // list of videos

    {

        IconedGroupBox* pTableGroup = new IconedGroupBox(this);

        pTableGroup->setIcon(QIcon(":/res/graphicsicon.png")); // FIXME

        pTableGroup->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);

        pTableGroup->setTitle(QGroupBox::tr("Videos"));

        QStringList columns;

        columns << tr("Name");

        columns << tr("Size");

        columns << "";

        filesTable = new QTableWidget(pTableGroup);

        filesTable->setColumnCount(vcNumColumns);

        filesTable->setHorizontalHeaderLabels(columns);

        filesTable->setSelectionBehavior(QAbstractItemView::SelectRows);

        filesTable->setSelectionMode(QAbstractItemView::SingleSelection);

        filesTable->setEditTriggers(QAbstractItemView::SelectedClicked);

        filesTable->verticalHeader()->hide();

        filesTable->setMinimumWidth(400);

        QHeaderView * header = filesTable->horizontalHeader();

        header->setResizeMode(vcName, QHeaderView::ResizeToContents);

        header->setResizeMode(vcSize, QHeaderView::Fixed);

        header->resizeSection(vcSize, 100);

        header->setStretchLastSection(true);

        btnOpenDir = new QPushButton(QPushButton::tr("Open videos directory"), pTableGroup);

        QVBoxLayout *box = new QVBoxLayout(pTableGroup);

        box->addWidget(filesTable);

        box->addWidget(btnOpenDir);

        pPageLayout->addWidget(pTableGroup, 0, 1, 2, 1);

    }

    // description

    {

        IconedGroupBox* pDescGroup = new IconedGroupBox(this);

        pDescGroup->setIcon(QIcon(":/res/graphicsicon.png")); // FIXME

        pDescGroup->setTitle(QGroupBox::tr("Description"));

        QVBoxLayout* pDescLayout = new QVBoxLayout(pDescGroup);

        QHBoxLayout* pTopDescLayout = new QHBoxLayout(0);    // picture and text

        QHBoxLayout* pBottomDescLayout = new QHBoxLayout(0); // buttons

        // label with thumbnail picture

        labelThumbnail = new QLabel(pDescGroup);

        labelThumbnail->setAlignment(Qt::AlignHCenter | Qt::AlignVCenter);

        labelThumbnail->setMaximumSize(ThumbnailSize);

        labelThumbnail->setStyleSheet(

                    "QFrame {"

                    "border: solid;"

                    "border-width: 3px;"

                    "border-color: #ffcc00;"

                    "border-radius: 4px;"

                    "}" );

        clearThumbnail();

        pTopDescLayout->addWidget(labelThumbnail, 2);

        // label with file description

        labelDesc = new QLabel(pDescGroup);

        labelDesc->setAlignment(Qt::AlignLeft | Qt::AlignTop);

        labelDesc->setTextInteractionFlags(Qt::TextSelectableByMouse |

                                           Qt::TextSelectableByKeyboard	|

                                           Qt::LinksAccessibleByMouse |

                                           Qt::LinksAccessibleByKeyboard);

        labelDesc->setTextFormat(Qt::RichText);

        labelDesc->setOpenExternalLinks(true);

        pTopDescLayout->addWidget(labelDesc, 1);

        // buttons: play and delete

        btnPlay = new QPushButton(QPushButton::tr("Play"), pDescGroup);

        btnPlay->setEnabled(false);

        pBottomDescLayout->addWidget(btnPlay);

        btnDelete = new QPushButton(QPushButton::tr("Delete"), pDescGroup);

        btnDelete->setEnabled(false);

        pBottomDescLayout->addWidget(btnDelete);

        btnToYouTube = new QPushButton(QPushButton::tr("Upload to YouTube"), pDescGroup);

        btnToYouTube->setEnabled(false);

        pBottomDescLayout->addWidget(btnToYouTube);

        pDescLayout->addStretch(1);

        pDescLayout->addLayout(pTopDescLayout, 0);

        pDescLayout->addStretch(1);

        pDescLayout->addLayout(pBottomDescLayout, 0);

        pPageLayout->addWidget(pDescGroup, 0, 0);

    }

    return pPageLayout;

}

QLayout * PageVideos::footerLayoutDefinition()

{

    return NULL;

}

void PageVideos::connectSignals()

{

    connect(checkUseGameRes, SIGNAL(stateChanged(int)), this, SLOT(changeUseGameRes(int)));

    connect(checkRecordAudio, SIGNAL(stateChanged(int)), this, SLOT(changeRecordAudio(int)));

    connect(comboAVFormats, SIGNAL(currentIndexChanged(int)), this, SLOT(changeAVFormat(int)));

    connect(btnDefaults, SIGNAL(clicked()), this, SLOT(setDefaultOptions()));

    connect(filesTable, SIGNAL(cellDoubleClicked(int, int)), this, SLOT(cellDoubleClicked(int, int)));

    connect(filesTable, SIGNAL(cellChanged(int,int)), this, SLOT(cellChanged(int, int)));

    connect(filesTable, SIGNAL(currentCellChanged(int,int,int,int)), this, SLOT(currentCellChanged(int,int,int,int)));

    connect(btnPlay,   SIGNAL(clicked()), this, SLOT(playSelectedFile()));

    connect(btnDelete, SIGNAL(clicked()), this, SLOT(deleteSelectedFiles()));

    connect(btnToYouTube, SIGNAL(clicked()), this, SLOT(uploadToYouTube()));

    connect(btnOpenDir, SIGNAL(clicked()), this, SLOT(openVideosDirectory()));

}

PageVideos::PageVideos(QWidget* parent) : AbstractPage(parent),

    config(0), netManager(0)

{

    nameChangedFromCode = false;

    numRecorders = 0;

    numUploads = 0;

    initPage();

}

void PageVideos::init(GameUIConfig * config)

{

    this->config = config;

    QString path = cfgdir->absolutePath() + "/Videos";

    QFileSystemWatcher * pWatcher = new QFileSystemWatcher(this);

    pWatcher->addPath(path);

    connect(pWatcher, SIGNAL(directoryChanged(const QString &)), this, SLOT(updateFileList(const QString &)));

    updateFileList(path);

    startEncoding(); // this is for videos recorded from demos which were executed directly (without frontend)

}

// user changed file format, we need to update list of codecs

void PageVideos::changeAVFormat(int index)

{

    // remember selected codecs

    QString prevVCodec = videoCodec();

    QString prevACodec = audioCodec();

    // clear lists of codecs

    comboVideoCodecs->clear();

    comboAudioCodecs->clear();

    // get list of codecs for specified format

    LibavIteraction::instance().fillCodecs(comboAVFormats->itemData(index).toString(), comboVideoCodecs, comboAudioCodecs);

    // disable audio if there is no audio codec

    if (comboAudioCodecs->count() == 0)

    {

        checkRecordAudio->setChecked(false);

        checkRecordAudio->setEnabled(false);

    }

    else

        checkRecordAudio->setEnabled(true);

    // restore selected codecs if possible

    int iVCodec = comboVideoCodecs->findData(prevVCodec);

    if (iVCodec != -1)

        comboVideoCodecs->setCurrentIndex(iVCodec);

    int iACodec = comboAudioCodecs->findData(prevACodec);

    if (iACodec != -1)

        comboAudioCodecs->setCurrentIndex(iACodec);

}

// user switched checkbox 'use game resolution'

void PageVideos::changeUseGameRes(int state)

{

    if (state && config)

    {

        // set resolution to game resolution

        QRect resolution = config->vid_Resolution();

        widthEdit->setText(QString::number(resolution.width()));

        heightEdit->setText(QString::number(resolution.height()));

    }

    widthEdit->setEnabled(!state);

    heightEdit->setEnabled(!state);

}

// user switched checkbox 'record audio'

void PageVideos::changeRecordAudio(int state)

{

    comboAudioCodecs->setEnabled(!!state);

}

void PageVideos::setDefaultCodecs()

{

    if (tryCodecs("mp4", "libx264", "libmp3lame"))

        return;

    if (tryCodecs("mp4", "libx264", "libfaac"))

        return;

    if (tryCodecs("mp4", "libx264", "libvo_aacenc"))

        return;

    if (tryCodecs("mp4", "libx264", "aac"))

        return;

    if (tryCodecs("mp4", "libx264", "mp2"))

        return;

    if (tryCodecs("avi", "libxvid", "libmp3lame"))

        return;

    if (tryCodecs("avi", "libxvid", "ac3_fixed"))

        return;

    if (tryCodecs("avi", "libxvid", "mp2"))

        return;

    if (tryCodecs("avi", "mpeg4", "libmp3lame"))

        return;

    if (tryCodecs("avi", "mpeg4", "ac3_fixed"))

        return;

    if (tryCodecs("avi", "mpeg4", "mp2"))

        return;

    // this shouldn't happen, just in case

    if (tryCodecs("ogg", "libtheora", "libvorbis"))

        return;

    tryCodecs("ogg", "libtheora", "flac");

}

void PageVideos::setDefaultOptions()

{

    framerateBox->setValue(25);

    checkRecordAudio->setChecked(true);

    checkUseGameRes->setChecked(true);

    setDefaultCodecs();

}

bool PageVideos::tryCodecs(const QString & format, const QString & vcodec, const QString & acodec)

{

    // first we should change format

    int iFormat = comboAVFormats->findData(format);

    if (iFormat == -1)

        return false;

    comboAVFormats->setCurrentIndex(iFormat);

    // format was changed, so lists of codecs were automatically updated to codecs supported by this format

    // try to find video codec

    int iVCodec = comboVideoCodecs->findData(vcodec);

    if (iVCodec == -1)

        return false;

    comboVideoCodecs->setCurrentIndex(iVCodec);

    // try to find audio codec

    int iACodec = comboAudioCodecs->findData(acodec);

    if (iACodec == -1 && checkRecordAudio->isChecked())

        return false;

    if (iACodec != -1)

        comboAudioCodecs->setCurrentIndex(iACodec);

    return true;

}

// get file size as string

static QString FileSizeStr(const QString & path)

{

    quint64 size = QFileInfo(path).size();

    quint64 KiB = 1024;

    quint64 MiB = 1024*KiB;

    quint64 GiB = 1024*MiB;

    QString sizeStr;

    if (size >= GiB)

        return QString("%1 GiB").arg(QString::number(float(size)/GiB, 'f', 2));

    if (size >= MiB)

        return QString("%1 MiB").arg(QString::number(float(size)/MiB, 'f', 2));

     if (size >= KiB)

        return QString("%1 KiB").arg(QString::number(float(size)/KiB, 'f', 2));

    return PageVideos::tr("%1 bytes").arg(QString::number(size));

}

// set file size in file list in specified row