interface.cpp

#include "interface.hpp"
#include "ui_interface.h"

#include "savingdialog.hpp"
#include "structurewriter.hpp"
#include "factory.hpp"
#include "transitionrule.hpp"
#include "neighborhoodrule.hpp"
#include "propertyvisitors.hpp"
#include "modelloadingdialog.hpp"

#include <QJsonArray>

MainWindow::MainWindow(QWidget *parent)
    : QMainWindow(parent)
      , ui(new Ui::MainWindow)
      , simulation()
{
    ui->setupUi(this);

    init_transition_neighborhood_list();
    update_transition_settings();
    update_neighborhood_settings();

    connect(ui->action_save_struct, &QAction::triggered, this, &MainWindow::afficher_interface_sauvegarde_structure);
    connect(ui->struct_library, &StructureLibraryView::structure_copied, this, &MainWindow::copy_structure_clicked);
    connect(ui->grid_view, &GridView::zoom_changed, ui->struct_library, &StructureLibraryView::update_cell_pixel_size);
    connect(ui->transition_list, QOverload<int>::of(&QComboBox::currentIndexChanged), this, [this](int)
            { update_transition_settings(); });

    ui->struct_library->update_cell_pixel_size(ui->grid_view->cell_pixel_size());

    load_model(default_model());
}

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

/// Connections

void MainWindow::on_simSpeedSpinbox_valueChanged(int arg1)
{
    ui->simSpeedSlider->setValue(arg1);
}

void MainWindow::on_simSpeedSlider_valueChanged(int value)
{
    ui->simSpeedSpinbox->setValue(value);
}

void MainWindow::on_openPatternButton_clicked()
{
    QString fileName = QFileDialog::getOpenFileName(this, tr("Open File"),"",tr("Pattern file (*.json)"));
    if(fileName == ""){
        // L'utilisateur a annulé la recherche
        return;
    }
    // Indiquer qu'un nouveau pattern vient d'être ouvert
}

void MainWindow::on_openRuleButton_clicked()
{
    // Indiquer qu'une nouvelle règle vient d'être ouverte. La règle est sauvegardé, donc on peut lancer la simulation

    ModelLoadingDialog dialog(this);
    if (!dialog.exec())
        return;

    load_model(dialog.model());
}

void MainWindow::on_neighborhood_list_currentTextChanged(const QString &)
{
    update_neighborhood_settings();
}

void MainWindow::on_widthSpinBox_valueChanged(int)
{
    ui->validateGridDim->setEnabled(true);
}

void MainWindow::on_heightSpinBox_valueChanged(int)
{
    ui->validateGridDim->setEnabled(true);
}

void MainWindow::afficher_interface_sauvegarde_structure(bool)
{
    SavingDialog dialog(this);
    if (!dialog.exec())
        return;

    QString filename = QFileDialog::getSaveFileName(this, "Choisir un nom de fichier", QString(), "Format Cellulut (*.json);;Format Golly RLE (*.rle)");
    QFileInfo info(filename);
    //printf("%s\n", info.suffix().toStdString().c_str());
    // on pourrait utiliser un Factory ici, mais c'est possiblement overkill, les possibilités d'évolution de format de fichier sont faibles et ne justifient pas l'effort

    Structure s = ui->grid_view->selected_cells();
    s.author = dialog.auteur().toStdString();
    s.title = dialog.titre().toStdString();
    s.desc = dialog.desc().toStdString();
    s.date = dialog.date().toString().toStdString();

    std::string save_data;
    if (info.suffix() == "json")
    {
        JSONStructureWriter writer;
        save_data = writer.save_structure(s);
    }
    else if (info.suffix() == "rle")
    {
        RLEStructureWriter writer;
        save_data = writer.save_structure(s);
    }

    QFile file(filename);
    if (!file.open(QIODevice::WriteOnly))
    {
        QMessageBox::information(this, "Impossible de créer le fichier",
                                 file.errorString());
        return;
    }

    QTextStream stream(&file);
    stream << QString::fromStdString(save_data);
}


void MainWindow::on_validateGridDim_clicked()
{
    Grid oldGrid = ui->grid_view->get_grid();


    unsigned int nbrRow = ui->heightSpinBox->value(); // nbr de lignes => axe y
    unsigned int nbrCol = ui->widthSpinBox->value(); // nbr de colonne => axe x
    Grid newGrid(nbrRow, nbrCol);

    unsigned oldNbrRow = oldGrid.get_rows(); // rows = nbr de lignes => axe y
    unsigned oldNbrCol = oldGrid.get_col(); // col = nbr de colonne => axe x

    if(oldNbrRow <= nbrRow && oldNbrCol <= nbrCol) {
        //std::cout << "superieur\n";
        fflush(stdout);
        for (unsigned y = 0; y < oldNbrRow ; y++) {
            for (unsigned x = 0; x < oldNbrCol ; x++) {
                Coord pos = {static_cast<int>(x), static_cast<int>(y)};
                newGrid.set_cell(pos, oldGrid.get_state(pos));
                //std::cout << "oldState : " << oldGrid.get_state(pos) << endl;
            }
        }
    }
    else
    {
        //std::cout << "superieur\n";
        fflush(stdout);
        for (unsigned y = 0; y < nbrRow ; y++) {
            for (unsigned x = 0; x < nbrCol ; x++) {
                Coord pos = {static_cast<int>(x), static_cast<int>(y)};
                newGrid.set_cell(pos, oldGrid.get_state(pos));
                //std::cout << "oldState : " << oldGrid.get_state(pos) << endl;
            }
        }
    }

    ui->grid_view->copy_grid(newGrid);

    ui->validateGridDim->setEnabled(false);
}

void MainWindow::on_nbrStateComboBox_currentTextChanged(const QString &arg1)
{
    unsigned val = arg1.toInt();

    ui->grid_view->set_current_pen(val);
}

void MainWindow::on_randomPatternButton_clicked()
{
    // TODO Prendre en compte l'alphabet !
    // int nbr = rand() % nbr de states différents;

    Grid oldGrid = ui->grid_view->get_grid();
    unsigned nbrRow = oldGrid.get_rows(); // rows = nbr de lignes => axe y
    unsigned nbrCol = oldGrid.get_col(); // col = nbr de colonne => axe x
    Grid newGrid(nbrRow, nbrCol);

    for (unsigned y = 0; y < nbrRow; ++y)
    {
        for (unsigned x = 0; x < nbrCol; ++x)
        {
            // TODO Remplacer 2 par le nbr d'états différents
            // TODO comprendre pourquoi il faut inverser x et y (???)
            unsigned state = rand() % 2;
            Coord pos = {static_cast<int>(x), static_cast<int>(y)};
            //std::cout << "position x= "<< pos.x << " y= "<< pos.y << endl;
            newGrid.set_cell(pos, state);
        }
    }

    ui->grid_view->copy_grid(newGrid);
}

void MainWindow::on_nbrStatesComboBox_currentTextChanged(const QString &arg1)
{
    // Nombre d'états possibles
    int val = arg1.toInt();
    // Nombre de valeurs dans le comboxBox (en partant de 0)
    int currentNbrValue = ui->nbrStateComboBox->count();
    // Si on change le nbr d'états
    if (val != currentNbrValue) {
        // Si on ajoute des états
        if (val > currentNbrValue) {
            for(int i = currentNbrValue; i < val; i++ ) {
                ui->nbrStateComboBox->addItem(QString::number(i));
            }
        }
        // Si on retire des états
        else {
            for(int i = currentNbrValue - 1; i >= val; i-- ) {
                ui->nbrStateComboBox->removeItem(i);
            }
        }
    }

}

void MainWindow::on_drawCellButton_clicked()
{
    ui->grid_view->fill_selection(ui->nbrStateComboBox->currentIndex());
}

void MainWindow::copy_structure_clicked(const Structure &s)
{
    ui->grid_view->set_clipboard(s);
    statusBar()->showMessage("Structure copied.", 5000);
}

void MainWindow::init_transition_neighborhood_list()
{
    for (const auto& transition : Factory<TransitionRule>::list_choices())
    {
        ui->transition_list->addItem(QString::fromStdString(transition));
    }

    for (const auto& rule : Factory<NeighborhoodRule>::list_choices())
    {
        ui->neighborhood_list->addItem(QString::fromStdString(rule));
    }
}

// TODO FIXME quand on aura une classe simulation commune
static std::unique_ptr<TransitionRule> transition_rule;
static std::unique_ptr<NeighborhoodRule> neighborhood_rule;
void MainWindow::update_transition_settings()
{
    std::string selected = ui->transition_list->currentText().toStdString();
    transition_rule = Factory<TransitionRule>::make(selected);
    if (!transition_rule)
        return;

    if (transition_rule->get_properties().size() == 0)
        ui->rule_settings_area->hide();
    else
    {
        ui->rule_settings_area->show();

        UIBuilderVisitor visit(ui->rule_settings_area);
        for (auto& prop : transition_rule->get_properties())
            prop->accept(visit);
    }
}
void MainWindow::update_neighborhood_settings()
{
    std::string selected = ui->neighborhood_list->currentText().toStdString();
    neighborhood_rule = Factory<NeighborhoodRule>::make(selected);
    if (!neighborhood_rule)
        return;

    if (neighborhood_rule->get_properties().size() == 0)
        ui->neighborhood_settings_area->hide();
    else
    {
        ui->neighborhood_settings_area->show();

        UIBuilderVisitor visit(ui->neighborhood_settings_area);
        for (auto& prop : neighborhood_rule->get_properties())
            prop->accept(visit);
    }
}

void MainWindow::enable_rule_customization()
{
    ui->simulation_tab->setEnabled(false);
    ui->customize_button->setEnabled(false);
    ui->rule_settings->setEnabled(true);
}

void MainWindow::disable_rule_customization()
{
    ui->simulation_tab->setEnabled(true);
    ui->customize_button->setEnabled(true);
    ui->rule_settings->setEnabled(false);
}

void MainWindow::load_model(const QJsonObject &obj)
{
    ui->rule_name->setText(obj.value("title").toString());
    // TODO : load alphabet
    ui->transition_list->setCurrentText(obj.value("transition_name").toString());
    ui->neighborhood_list->setCurrentText(obj.value("neighborhood_name").toString());

    update_transition_settings();
    update_neighborhood_settings();
    disable_rule_customization();

    {
        PropertyLoaderVisitor loader(obj.value("transition_data").toObject());
        for (auto& prop : transition_rule->get_properties())
            prop->accept(loader);
        UIBuilderVisitor visit(ui->rule_settings_area);
        for (auto& prop : transition_rule->get_properties())
            prop->accept(visit);
    }

    {
        PropertyLoaderVisitor loader(obj.value("neighborhood_data").toObject());
        for (auto& prop : neighborhood_rule->get_properties())
            prop->accept(loader);
        UIBuilderVisitor visit(ui->neighborhood_settings_area);
        for (auto& prop : neighborhood_rule->get_properties())
            prop->accept(visit);
    }
}

void MainWindow::save_model()
{
    SavingDialog dialog(this);
    if (!dialog.exec())
        return;

    QString filename = QFileDialog::getSaveFileName(this, "Choisir un nom de fichier", QString(), "Modèle d'automate (*.json)");

    PropertySaverVisitor trans_saver;
    for (auto& prop : transition_rule->get_properties())
        prop->accept(trans_saver);

    PropertySaverVisitor neighborhood_saver;
    for (auto& prop : neighborhood_rule->get_properties())
        prop->accept(neighborhood_saver);

    QJsonObject root;
    root["title"] = dialog.titre();
    root["author"] = dialog.auteur();
    root["desc"] = dialog.desc();
    root["date"] = dialog.date().toString();

    root["transition_name"] = ui->transition_list->currentText();
    root["transition_data"] = trans_saver.save();

    root["neighborhood_name"] = ui->neighborhood_list->currentText();
    root["neighborhood_data"] = neighborhood_saver.save();

    // TODO : sauvegarder l'alphabet quand on pourra y accéder avec Simulation
    QJsonArray alphabet;

    root["alphabet"] = alphabet;

    QJsonDocument doc(root);
    QFile file(filename);
    file.open(QFile::WriteOnly | QFile::Text | QFile::Truncate);
    file.write(doc.toJson());
    file.close();

    ui->rule_name->setText(dialog.titre());
    disable_rule_customization();
}

QJsonObject MainWindow::default_model() const
{
    QJsonObject obj;
    obj["title"] = "Game of Life";
    obj["transition_name"] = "Game of Life";
    obj["transition_data"] = QJsonObject();

    return obj;
}

void MainWindow::on_saveRuleButton_clicked()
{
    save_model();
}

void MainWindow::on_customize_button_clicked()
{
    enable_rule_customization();
}