schema_editor/mainwindow.cpp

#include "mainwindow.h"
#include "ui_mainwindow.h"

#include <QFileDialog>
#include <QHBoxLayout>

#include <comdel/parser/parsecontext.h>
#include <comdel/parser/parserutil.h>
#include <comdel/domain/schemacreator.h>

#include <iostream>
#include <QPlainTextEdit>
#include <comdel/domain/comdelvalidator.h>
#include <fstream>
#include <comdel/domain/comdel_generator.h>

std::optional<domain::Library> MainWindow::library;
domain::Schema* MainWindow::schema;

MainWindow::MainWindow(QWidget *parent)
    : QMainWindow(parent)
    , ui(new Ui::MainWindow)
{
    schema = nullptr;
    library = std::nullopt;

    ui->setupUi(this);

    setupUi();

    // define allowed methods
    validators = domain::getSupportedValidators();
}

void MainWindow::setupUi()
{
    setWindowTitle("COMDEL schema editor");

    auto layout = new QHBoxLayout();
    ui->centralwidget->setLayout(layout);

    // setup toolbar
    ui->toolBar->addAction("Load library", this, &MainWindow::onLoadLibrary);
    ui->toolBar->addAction("Load schema", this, &MainWindow::onLoadSchema);
    ui->toolBar->addAction("Save schema", this, &MainWindow::onStoreScheme);
    ui->toolBar->addAction("Generate system", this, &MainWindow::onGenerateComdel);

    connect(ui->actionValidate, &QAction::triggered, this, &MainWindow::onValidateSchema);

    // setup central content
    libraryDisplay = new display::Library();

    auto schemaParent = new QWidget();
    auto schemaLayout = new QVBoxLayout();
    schemaParent->setLayout(schemaLayout);

    schemaDisplay = new display::Schema();
    schemaLayout->setMargin(0);
    schemaLayout->addWidget(schemaDisplay, 1);

    layout->setMargin(0);
    layout->addWidget(libraryDisplay);
    layout->addWidget(schemaParent, 1);

    log = new QPlainTextEdit();
    log->setFont(QFont("Courier"));
    log->setReadOnly(false);
    schemaLayout->addWidget(log);
}

void MainWindow::onLoadLibrary() {
    auto filename = QFileDialog::getOpenFileName(this,
             tr("Open library"), "/home", tr("Comdel library (*.csl)"));

    std::ostringstream buffer;

    log->clear();

    if(!filename.isEmpty()) {
        librarySource = filename.toStdString();

        clear();

        ParseContext parseContext;
        auto libraryNode = loadLibraryFromFile(&parseContext, filename.toStdString().c_str(), buffer);
        if(libraryNode) {
            domain::SchemaCreator generator(validators);
            library = generator.loadLibrary(*libraryNode);

            for (auto& error : generator.getErrors()) {
                parseContext.formatError(error, buffer, "ERROR: ");
            }

            if(generator.getErrors().empty()) {
                libraryDisplay->setLibrary(library);

                // on library load we create a new schema
                schema = new domain::Schema();
                schemaDisplay->setSchema(schema, &(*library));
            }

        } else {
            buffer<<"Failed loading library"<<std::endl;
        }
    }

    log->appendPlainText(QString::fromStdString(buffer.str()));
}

void MainWindow::onLoadSchema() {
    auto filename = QFileDialog::getOpenFileName(this,
             tr("Open schema"), "/home", tr("Comdel schema (*.csl)"));

    std::ostringstream buffer;

    log->clear();

    if(!filename.isEmpty()) {
        clear();

        ParseContext parseContext;
        auto schemaNode = loadSchemaFromFile(&parseContext, filename.toStdString().c_str(), buffer);

        if(schemaNode) {
            domain::SchemaCreator generator(validators);
            library = generator.loadLibrary(*schemaNode->library);

            librarySource = schemaNode->source->value;

            for (auto& error : generator.getErrors()) {
                parseContext.formatError(error, buffer, "ERROR: ");
            }

            if(library) {
                schema = generator.loadSchema(*schemaNode, *library);

                for (auto& error : generator.getErrors()) {
                    parseContext.formatError(error, buffer, "ERROR: ");
                    delete schema;
                    schema = nullptr;
                }
            } else {
                library = std::nullopt;
            }

            if(generator.getErrors().empty()) {
                libraryDisplay->setLibrary(library);
                schemaDisplay->setSchema(schema, &(*library));
            }
        }
    }

    log->appendPlainText(QString::fromStdString(buffer.str()));
}

void MainWindow::onStoreScheme() {
    if(schema == nullptr) {
        return;
    }

    auto filename = QFileDialog::getSaveFileName(this,
                                                 tr("Save schema"), "/home", tr("Comdel schema (*.csl)"));

    std::ostringstream buffer;

    domain::generateSchemaFile(librarySource, schema, buffer);

    std::ofstream out(filename.toStdString(), std::ios::out | std::ios::binary);
    out<<buffer.str();
    out.close();
}

void MainWindow::onGenerateComdel() {
    if(schema == nullptr) {
        return;
    }

    auto filename = QFileDialog::getSaveFileName(this,
                                                 tr("Save schema"), "/home", tr("Comdel system (*.system)"));

    std::ostringstream buffer;

    domain::generateComdelFile(schema, library.value(), buffer);

    std::ofstream out(filename.toStdString(), std::ios::out | std::ios::binary);
    out<<buffer.str();
    out.close();
}


void MainWindow::onValidateSchema(bool /*toggled*/) {
    if(schema == nullptr) {
        return;
    }

    log->clear();

    this->validationErrors.clear();

    domain::ComdelValidator validator{validators};

    domain::ValidationContext context;
    context.instance = nullptr;
    context.attribute = nullptr;
    context.addressSpaces = {};

    for(auto &lib: library->getAddressSpaces()) {
        context.addressSpaces.insert(std::make_pair(lib.getName(), lib));
    }
    auto errors = validator.validateSchema(*schema, context);

    auto countValidation = validator.validateInstanceCount(*schema, *library, context);
    errors.insert(errors.end(), countValidation.begin(), countValidation.end());

    auto pinValidation = validator.validatePinConnections(*schema, *library, context);
    errors.insert(errors.end(), pinValidation.begin(), pinValidation.end());

    errors.erase(std::remove_if(
                    errors.begin(), errors.end(), [](const domain::ValidationError& error) { return error.type == domain::Action::WARNING;}),
            errors.end());

    std::ostringstream buff;

    for(auto err: errors) {
        if(err.instance != nullptr) {
            buff << err.instance->name;
        }
        if(err.attribute != nullptr) {
            buff << "::" << err.attribute->name;
        }
        if(err.type == domain::Action::ERROR) {
            buff << " [ERROR] ";
        } else {
            buff << " [WARNING] ";
        }
        buff << err.message << std::endl;
    }

    log->appendPlainText(QString::fromStdString(buff.str()));

    validationErrors = errors;
}


void MainWindow::clear() {
    validationErrors.clear();
    if(schema != nullptr) {
        delete schema;
        schema = nullptr;
    }
    library = std::nullopt;

    libraryDisplay->setLibrary(library);
    schemaDisplay->setSchema(schema, nullptr);
}

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