#pragma once

#include <QFile>
#include "JDefines.h"
#include "JTerminal.h"
#include "JSys.h"

namespace Incart::Common
{

class JFile
{
public:
    static QByteArray& readFile(QString fname)
    {
        static QByteArray data;
        QFile file(fname);
        if ( file.open(QIODevice::ReadOnly))
        {
            data = file.readAll();
            file.close();
        }
        else
        {
            data.clear();
            JTerminal(JCL_RED) << __FUNCTION__ << "file read error" << fname;
        }
        return data;
    }

    static void writeFile(QString fname,QByteArray& data)
    {
        QFile file(fname);
        if ( file.open(QIODevice::WriteOnly))
        {
            qint64 len = file.write(data);
            file.close();
            if (len != data.size())
            {
                JTerminal(JCL_YELLOW) << __FUNCTION__ << "writing to file is incorrect" << fname;
            }
        }
        else
        {
            JTerminal(JCL_YELLOW) << __FUNCTION__ << "file not found" << fname;
        }
    }

    static QVariantMap readJsonMapFromFile(QString fileName)
    {
        QVariantMap jsonMap;

        QByteArray& data = readFile(fileName);
        QJsonDocument jdoc = QJsonDocument::fromJson(data);
        if( jdoc.isObject() )
        {
            QJsonObject jobj = jdoc.object();
            jsonMap = jobj.toVariantMap();
        }
        else
        {
            JTerminal(JCL_YELLOW) << __FUNCTION__ << "json object interpretation error";
        }

        return jsonMap;
    }

    static void writeJsonMapToFile(QString fname,const QVariantMap& jmap)
    {
        QJsonObject jobj = QJsonObject::fromVariantMap(jmap);
        QJsonDocument jdoc(jobj);
        QByteArray data = jdoc.toJson(QJsonDocument::Indented); // QJsonDocument::Compact
        writeFile(fname,data);
    }

    // чтение записи из файла (при условии что файл это последовательность записей типа T)
    static bool isFile(QString fname)
    {
        QFile file(fname);
        return file.exists();
    }

    template<class T>
    static T getRecord(QFile& file)
    {
        T record;
        int record_size = static_cast<int>(sizeof(T));
        qint64 len = file.read( reinterpret_cast<char*>(&record),record_size );
        if ( len != record_size )
        {
            JTerminal(JCL_RED) << __FUNCTION__ << "file read error" << file.fileName();
            JSys::abort();
        }
        return record;
    }

    template<class T>
    static T getRecord(QFile& file, int number)
    {
        int record_size = static_cast<int>(sizeof(T));
        file.seek(number * record_size);
        return getRecord<T>(file);
    }

    template<class T>
    static T readRecord(QString fileName, int recordNumber)
    {
        QFile file(fileName);
        if ( !file.open(QIODevice::ReadOnly))
        {
            JTerminal(JCL_RED) << __PRETTY_FUNCTION__ << "file not open" << file.fileName();
            JSys::abort();
        }
        T record = getRecord<T>(file, recordNumber);
        file.close();
        return record;
    }

    template<class T>
    static void saveRecord(QFile& file, T& record)
    {
        qint64 len = file.write( reinterpret_cast<char*>(&record), sizeof(T) );
        if(len != sizeof(T))
        {
            JTerminal(JCL_RED) << __PRETTY_FUNCTION__ << "writing to file is incorrect" << file.fileName();
            JSys::abort();
        }
    }
};

} // namespace Incart::Common