#include "gtl_gui_player_resampling_dialog.h"
#include "ui_gtl_gui_player_resampling_dialog.h"

#include "hw/gtl_hw_recorder_wav.h"

#include <QFileDialog>

namespace gtl
{
    namespace gui
    {
        namespace player
        {
            resampling_dialog::resampling_dialog(QString path, QWidget *parent)
                : QDialog(parent, Qt::Dialog)
                , ui(new Ui::player_resampling_dialog)
                , _player{ new gtl::hw::player(this)}
            {
                ui->setupUi(this);

                _time = new QLabel(ui->progress);
                _time->setAlignment(Qt::AlignHCenter | Qt::AlignVCenter);

                QHBoxLayout* progress_layout = new QHBoxLayout(ui->progress);
                progress_layout->setContentsMargins(0, 0, 0, 0);
                progress_layout->addWidget(_time);
                ui->progress->setLayout(progress_layout);

                _player->start(path, -1);
                ui->path->setText(path);
                for(int i = 0; i < _player->count_ai(); i++)
                {
                    ui->channels->addItem(_player->ai(i)->name());
                    ui->channels->item(i)->setCheckState(Qt::Checked);
                }

                QVariant data;
                _player->get_parameter(4, data);
                ui->comment->setText(data.toJsonObject()["comment"].toString());

                ui->rate->setRange(0.001, _player->rate());
                ui->rate->setValue(_player->rate());


                connect(ui->select_path, &QAbstractButton::clicked, this, &resampling_dialog::select_path);
                connect(ui->rate, &QDoubleSpinBox::editingFinished, this, &resampling_dialog::rate_changed);
                connect(ui->save, &QAbstractButton::clicked, this, &resampling_dialog::save);
                connect(_player, &gtl::hw::player::finished, this, &resampling_dialog::playing_finished);
            }

            resampling_dialog::~resampling_dialog()
            {
                delete ui;
            }

            void resampling_dialog::select_path()
            {
                QString path = QFileDialog::getSaveFileName(this, tr("Select file"), /*QFileInfo(*/ui->path->text()/*).dir().absolutePath()*/, "*.wav");
                if(!path.isEmpty())
                    ui->path->setText(path);
            }

            void resampling_dialog::rate_changed()
            {
                QVariant playing_rate = ui->rate->value();
                _player->set_parameter(5, playing_rate);
                _player->get_parameter(5, playing_rate);
                ui->rate->setValue(playing_rate.toDouble());
            }

            void resampling_dialog::save(bool value)
            {
                if(value)
                {
                    _player->set_parameter(3, QVariant(100/*0*/));

                    QVariant total_time;
                    _player->get_parameter(0, total_time);
                    ui->progress->setMaximum(qRound(total_time.toDouble()*1000));
                    ui->progress->setValue(0);
                    qreal total = total_time.toDouble();


                    _player->start(_player->id(), -1);

                    std::vector<gtl::analog_data*> ad;
                    for(int i = 0; i < _player->count_ai(); i++)
                    {
                        if(ui->channels->item(i)->checkState() == Qt::Checked)
                            ad.push_back(_player->ai(i));
                    }

                    QFileInfo info(ui->path->text());
                    gtl::hw::recorder_wav recorder(ad, 0, ui->comment->toPlainText(), info.dir().absolutePath(), info.completeBaseName());
                    recorder.start();


                    _player->start(_player->id(), 0);

                    _is_playing = true;

                    while(_is_playing)
                    {
                        QVariant time;
                        _player->get_parameter(1, time);
                        ui->progress->setValue(qRound(time.toDouble()*1000));
                        _time->setText(QString::asprintf("%0.3f/%0.3f", time.toDouble(), total));

                        if(!ui->save->isChecked())
                            break;

                        QApplication::processEvents();
                        QThread::msleep(10);
                    }

                    _time->setText(tr("Complete"));

                    recorder.stop();
                    _player->stop();
                }
            }

            void resampling_dialog::playing_finished()
            {
                _is_playing = false;
                ui->save->setChecked(false);
            }
        }
    }
}