#include "gtl_gui_scr_quick_widget.h"

#include <QStandardPaths>
#include <QVBoxLayout>
#include <QRegularExpression>

#include "core/gtl_logger.h"

namespace gtl
{
    namespace gui
    {
        scr_quick_widget::scr_quick_widget(gtl::scr::engine* engine, QWidget *parent)
            : QFrame(parent)
            , _engine(engine)
            , _widget(nullptr)
        {
            setLayout(new QVBoxLayout(this));
            layout()->setContentsMargins(0, 0, 0, 0);

            setFrameStyle(QFrame::Box);
        }

        void scr_quick_widget::run(std::vector<gtl::analog_data*>::iterator begin_ad, std::vector<gtl::analog_data*>::iterator end_ad, QString qml_script)
        {
            _engine->set_ad(begin_ad, end_ad);

            run(qml_script);

        }

        void scr_quick_widget::run(QString qml_script)
        {
            _engine->evaluate("");

            connect(_engine->qml_engine(), &QQmlEngine::warnings, this, &scr_quick_widget::qml_warnings);

            clear_qml_modules();
            copy_qml_modules();

            QString qml_file_path = imports_to_url(qml_script, "script.qml");

            if(_widget)
                delete _widget;

            _widget = new QQuickWidget(_engine->qml_engine(), this);
            _widget->quickWindow()->setGraphicsApi(QSGRendererInterface::OpenGL);
            _widget->setResizeMode(QQuickWidget::SizeRootObjectToView);
            QUrl url = QUrl::fromLocalFile(qml_file_path);
            _string_url = url.toString() + ":";
            _widget->setSource(url);

            QList<QQmlError> errors = _widget->errors();
            for(auto it : errors)
                gtl::logger::error("qml", it.toString().replace(_string_url, ""));

            layout()->addWidget(_widget);

        }

        QUrl scr_quick_widget::get_import_url(QString file_name)
        {
            if(QFileInfo::exists(file_name))
                return QUrl::fromLocalFile(file_name);

            for(auto it : gtl::scr::engine::import_paths)
            {
                QFileInfo file(it + "/" + file_name);
                if(file.exists())
                {
                    return QUrl::fromLocalFile(file.absoluteFilePath());
                }
            }

            gtl::logger::error("qml", tr("can't find module file: ") + file_name);


            return QUrl();
        }

        QString scr_quick_widget::imports_to_url(QString &script, QString file_name)
        {
            QRegularExpression import_re("import\\s+\"\\s*(\\w*(\\.|:|/+|\\\\)*)+\\s*\"\\s+as");
            QRegularExpressionMatchIterator i = import_re.globalMatch(script);
            while(i.hasNext())
            {
                QRegularExpressionMatch import_match = i.next();
                QStringList parts = import_match.captured().split("\"");

                qDebug() << parts[1] << import_match.capturedStart() << import_match.capturedLength() << import_match.capturedEnd();
                QUrl import_url = get_import_url(parts[1]);

                script.replace(script.indexOf(parts[1], import_match.capturedStart()), parts[1].length(), import_url.toString().replace(":///", ":"));
            }

            QString file_path = QStandardPaths::standardLocations(QStandardPaths::TempLocation)[0] + "/" + file_name;
            QFile qml_file(file_path);
            if(qml_file.open(QFile::WriteOnly))
            {
                qml_file.write(script.toUtf8());
                qml_file.close();

            }

            return file_path;
        }

        void scr_quick_widget::clear_qml_modules()
        {
            for(auto qml_file_info: QDir(QStandardPaths::standardLocations(QStandardPaths::TempLocation)[0]).entryInfoList(QStringList() << "*.qml", QDir::Filter::Files))
                QFile::remove(qml_file_info.absoluteFilePath());
        }

        void scr_quick_widget::copy_qml_modules()
        {
            for(auto it : gtl::scr::engine::import_paths)
            {
               for(auto qml_file_info: QDir(it).entryInfoList(QStringList() << "*.qml", QDir::Filter::Files))
               {
                   QFile qml_file(qml_file_info.absoluteFilePath());
                   if(qml_file.open(QFile::ReadOnly))
                   {
                       QString qml_script(qml_file.readAll());
                       imports_to_url(qml_script, qml_file_info.fileName());

                       qml_file.close();
                   }

               }
            }
        }

        void scr_quick_widget::qml_warnings(const QList<QQmlError> &warnings)
        {
            for(auto it : warnings)
                gtl::logger::warning("qml", it.toString().replace(_string_url, ""));
        }
    }
}