#ifndef TOOLS_H
#define TOOLS_H

#include <QString>
#include <QStringList>
#include <QSet>
#include <QStandardItemModel>
#include <QFile>
#include <QTextStream>
#include <QDir>
#include <QFileInfo>

#include "model/step/itemtypes/abstractitemtype.h"
#include "model/step/itemtypes/ct_scene.h"
#include "model/step/itemtypes/ct_pointcluster.h"
#include "model/step/itemtypes/ct_referencepoint.h"
#include "model/step/itemtypes/ct_abstractshape.h"
#include "model/step/itemtypes/ct_circle.h"
#include "model/step/itemtypes/ct_ellipse.h"
#include "model/step/itemtypes/ct_cylinder.h"
#include "model/step/itemtypes/ct_line.h"
#include "model/step/itemtypes/ct_grid2d.h"
#include "model/step/itemtypes/ct_grid3d.h"
#include "model/step/itemtypes/ct_beam.h"
#include "model/step/itemtypes/ct_scanner.h"
#include "model/step/itemtypes/ct_triangulation2d.h"
#include "model/step/itemtypes/ct_abstractitemdrawablewithpointcloud.h"
#include "model/step/itemtypes/ct_abstractitemdrawablewithoutpointcloud.h"
#include "model/step/itemtypes/ct_abstractsingularitemdrawable.h"

class Tools
{
public:
    inline static QString getTitleCase(const QString name)
    {
        QString text = name;
        if (name != "") text = name.at(0).toUpper() + name.mid(1);
        return text;
    }

    inline static QString getQStringListConcat(QSet<QString> &list, bool sort = true)
    {
        QStringList list2(list.cbegin(), list.cend());
        if (sort) list2.sort();
        QString result = "";
        foreach (const QString &value, list2) result += value;
        return result;
    }      

    inline static QString getIndentation(int n)
    {
        QString str = "";
        for (int i = 0 ; i < n ; i++) str.append("    ");
        return str;
    }

    inline static QString getSpaceSequence(int n)
    {
        QString str = "";
        for (int i = 0 ; i < n ; i++) str.append(" ");
        return str;
    }

    inline static QString getBooleanText(bool b) { return (b ? "true" : "false"); }

    inline static QString trs(const QString &str)
    {
        if (str == "") return "\"\"";
        return "tr(\"" + str + "\")";
    }

    static QMap<QString, AbstractItemType*> ITEMTYPE;

    static QMap<QString, AbstractItemType*> initItemTypes()
    {
        QMap<QString, AbstractItemType*> map;
        addItemType(map, new CT_Scene());
        addItemType(map, new CT_PointCluster());
        addItemType(map, new CT_ReferencePoint());

        addItemType(map, new CT_AbstractShape());
        addItemType(map, new CT_Circle());
        addItemType(map, new CT_Ellipse());
        addItemType(map, new CT_Line());
        addItemType(map, new CT_Cylinder());
        addItemType(map, new CT_Grid2D());
        addItemType(map, new CT_Grid3D());
        addItemType(map, new CT_Beam());
        addItemType(map, new CT_Scanner());
        addItemType(map, new CT_Triangulation2D());

        addItemType(map, new CT_AbstractItemDrawableWithPointCloud());
        addItemType(map, new CT_AbstractItemDrawableWithoutPointCloud());
        addItemType(map, new CT_AbstractSingularItemDrawable());

        return map;
    }

    static void addItemType(QMap<QString, AbstractItemType*> &map, AbstractItemType* itemType)
    {
        map.insert(itemType->getTypeName(), itemType);
    }

    static bool parseTemplate(QString input,
                              QString output,
                              QList<QPair<QString,QString> > *tags,
                              bool exampleMode)
    {
        QString buffer = "";

        // Load template into buffer
        QFile inFile(input);
        if (!inFile.open(QIODevice::ReadOnly | QIODevice::Text))
            return false;

        QTextStream inStream(&inFile);
        inStream.setCodec("UTF-8");
        while(!inStream.atEnd())
        {
            QString temp = inStream.readLine();
            QString type = temp.left(2);
            QString line = temp.mid(4) + "\n";

                 if (type == "CM")                 buffer += line;
            else if (type == "EX" &&  exampleMode) buffer += line;
            else if (type == "NC" && !exampleMode) buffer += line;
        }

        inFile.close();

        // Replacement of each tags by given value
        QPair<QString,QString> pair;
        foreach(pair,*tags)
            buffer.replace(pair.first,pair.second);

        // Write buffer
        QFile outFile(output);
        if (!outFile.open(QIODevice::WriteOnly | QIODevice::Text))
            return false;

        QTextStream outStream(&outFile);
        outStream.setCodec("UTF-8");
        outStream << buffer;

        outFile.close();

        return true;
    }

    static bool modifyManager(QString input,
                              QString tag,
                              QString text,
                              int offset)
    {
        QString buffer = "";

        // Load template into buffer
        QFile inFile(input);
        if (!inFile.open(QIODevice::ReadOnly | QIODevice::Text))
            return false;

        QTextStream inStream(&inFile);
        inStream.setCodec("UTF-8");
        while(!inStream.atEnd())
        {
            QString temp = inStream.readLine();
            buffer += temp + "\n";
            if (temp.contains(tag))
            {
                // move x line(s) further
                for (int i=0 ; i<offset && !inStream.atEnd() ; i++)
                {
                    temp = inStream.readLine();
                    buffer += temp + "\n";
                }
                // Insert text
                buffer += text + "\n";
            }
        }

        inFile.close();

        // Write buffer
        QFile outFile(input);
        if (!outFile.open(QIODevice::WriteOnly | QIODevice::Truncate | QIODevice::Text))
            return false;

        QTextStream outStream(&outFile);
        outStream.setCodec("UTF-8");
        outStream << buffer;

        outFile.close();

        return true;
    }
};

#endif // TOOLS_H