#include "TlmRecorder.h"
#include "protocol.h"
#include "dramExtension.h"
#include "xmlAddressdecoder.h"
#include "../controller/core/configuration/Configuration.h"
#include <iostream>
#include <algorithm>
#include <boost/filesystem.hpp>

using namespace std;

string TlmRecorder::dbName = "";
string TlmRecorder::sqlScriptURI = "";
string TlmRecorder::senderName = "TlmRecorder";
bool   TlmRecorder::recordingEnabled = true;

// ------------- public -----------------------

TlmRecorder::TlmRecorder() :
    totalNumTransactions(1), simulationTimeCoveredByRecording(SC_ZERO_TIME)
{
    if(recordingEnabled)
    {
        recordedData.reserve(transactionCommitRate);
        setUpTransactionTerminatingPhases();
        openDB(TlmRecorder::dbName.c_str());
        char * sErrMsg;
        sqlite3_exec(db, "PRAGMA main.page_size = 4096", NULL, NULL, &sErrMsg);
        sqlite3_exec(db, "PRAGMA main.cache_size=10000", NULL, NULL, &sErrMsg);
        sqlite3_exec(db, "PRAGMA main.locking_mode=EXCLUSIVE", NULL, NULL, &sErrMsg);
        sqlite3_exec(db, "PRAGMA main.synchronous=OFF", NULL, NULL, &sErrMsg);
        sqlite3_exec(db, "PRAGMA journal_mode = OFF", NULL, NULL, &sErrMsg);

        createTables(TlmRecorder::sqlScriptURI);
        prepareSqlStatements();

        printDebugMessage("Starting new database transaction");
    }
}

TlmRecorder::~TlmRecorder()
{
    if (db)
        closeConnection();
}

void TlmRecorder::recordPhase(tlm::tlm_generic_payload& trans, tlm::tlm_phase phase, sc_time time)
{
    if(TlmRecorder::recordingEnabled)
    {
        if (currentTransactionsInSystem.count(&trans) == 0)
            introduceTransactionSystem(trans);

        string phaseName = phaseNameToString(phase);
        string phaseBeginPrefix = "BEGIN_";
        string phaseEndPrefix = "END_";

        if (phaseName.find(phaseBeginPrefix) != string::npos)
        {
            phaseName.erase(0, phaseBeginPrefix.length());
            assert(currentTransactionsInSystem.count(&trans) != 0);
            currentTransactionsInSystem[&trans].insertPhase(phaseName,time);
        }
        else
        {
            phaseName.erase(0, phaseEndPrefix.length());
            assert(currentTransactionsInSystem.count(&trans) != 0);
            currentTransactionsInSystem[&trans].setPhaseEnd(phaseName,time);
        }

        bool phaseTerminatesTransaction = count(transactionTerminatingPhases.begin(),
                                                transactionTerminatingPhases.end(), phase) == 1;
        if (phaseTerminatesTransaction)
            removeTransactionFromSystem(trans);

        simulationTimeCoveredByRecording = time;
    }
}


void TlmRecorder::updateDataStrobe(const sc_time& begin,const sc_time& end, tlm::tlm_generic_payload& trans)
{
    if(TlmRecorder::recordingEnabled)
    {
        assert(currentTransactionsInSystem.count(&trans) != 0);
        currentTransactionsInSystem[&trans].timeOnDataStrobe.start = begin;
        currentTransactionsInSystem[&trans].timeOnDataStrobe.end = end;
    }
}


void TlmRecorder::recordDebugMessage(std::string message, sc_time time)
{
    if(TlmRecorder::recordingEnabled)
        insertDebugMessageInDB(message, time);
}


// ------------- internal -----------------------

void TlmRecorder::introduceTransactionSystem(tlm::tlm_generic_payload& trans)
{
    unsigned int id = totalNumTransactions++;
    currentTransactionsInSystem[&trans].id = id;
    currentTransactionsInSystem[&trans].address = trans.get_address();
    currentTransactionsInSystem[&trans].burstlength = trans.get_streaming_width();
    currentTransactionsInSystem[&trans].dramExtension = DramExtension::getExtension(trans);

    if(DramExtension::getExtension(trans).getThread().ID() == 0)
        currentTransactionsInSystem[&trans].timeOfGeneration = SC_ZERO_TIME;
    else
        currentTransactionsInSystem[&trans].timeOfGeneration = GenerationExtension::getExtension(&trans).TimeOfGeneration();

    if (id % transactionCommitRate == 0)
    {
        printDebugMessage(
                    "Committing transactions " + to_string(id - transactionCommitRate + 1) + " - "
                    + to_string(id));
        commitRecordedDataToDB();
    }
}

void TlmRecorder::removeTransactionFromSystem(tlm::tlm_generic_payload& trans)
{
    assert(currentTransactionsInSystem.count(&trans) != 0);

    Transaction& recordingData = currentTransactionsInSystem[&trans];
    recordedData.push_back(recordingData);
    currentTransactionsInSystem.erase(&trans);
}

void TlmRecorder::commitRecordedDataToDB()
{
    sqlite3_exec(db, "BEGIN;", 0, 0, 0);
    for(Transaction& recordingData: recordedData)
    {
        assert(recordingData.recordedPhases.size() > 0);
        insertTransactionInDB(recordingData);
        for(Transaction::Phase& phaseData: recordingData.recordedPhases)
        {
            insertPhaseInDB(phaseData.name,phaseData.interval.start,phaseData.interval.end,recordingData.id);
        }

        sc_time rangeBegin = recordingData.recordedPhases.front().interval.start;
        sc_time rangeEnd = recordingData.recordedPhases.back().interval.end;
        insertRangeInDB(recordingData.id,rangeBegin,rangeEnd);
    }

    sqlite3_exec(db, "COMMIT;", 0, 0, 0);
    recordedData.clear();
}


void TlmRecorder::Transaction::insertPhase(string name, sc_time begin)
{
    recordedPhases.push_back(Phase(name,begin));
}

void TlmRecorder::Transaction::setPhaseEnd(string name, sc_time end)
{
    for(Phase& data: recordedPhases)
    {
        if(data.name == name)
        {
            data.interval.end = end;
            return;
        }
    }
    SC_REPORT_FATAL("Recording Error", "While trying to set phase end: phaseBegin has not been recorded");
}

void TlmRecorder::openDB(std::string name)
{
    boost::filesystem::wpath file(name);
    if(boost::filesystem::exists(file))
        boost::filesystem::remove(file);
    if (sqlite3_open(name.c_str(), &db))
    {
        SC_REPORT_FATAL("Error in TraceRecorder", "Error cannot open database");
        sqlite3_close(db);
    }
}


void TlmRecorder::createTables(string pathToURI)
{
    string initial = loadTextFileContents(pathToURI);
    executeSqlCommand(initial);
}

void TlmRecorder::setUpTransactionTerminatingPhases()
{
    transactionTerminatingPhases.push_back(tlm::END_RESP);
    transactionTerminatingPhases.push_back(static_cast<const tlm::tlm_phase>(END_REFA));
    transactionTerminatingPhases.push_back(static_cast<const tlm::tlm_phase>(END_REFB));
    transactionTerminatingPhases.push_back(static_cast<const tlm::tlm_phase>(END_PDNP));
    transactionTerminatingPhases.push_back(static_cast<const tlm::tlm_phase>(END_PDNA));
    transactionTerminatingPhases.push_back(static_cast<const tlm::tlm_phase>(END_SREF));
    transactionTerminatingPhases.push_back(static_cast<const tlm::tlm_phase>(END_PDNPB));
    transactionTerminatingPhases.push_back(static_cast<const tlm::tlm_phase>(END_PDNAB));
    transactionTerminatingPhases.push_back(static_cast<const tlm::tlm_phase>(END_SREFB));
}

void TlmRecorder::prepareSqlStatements()
{
    insertTransactionString =
            "INSERT INTO Transactions VALUES (:id,:rangeID,:address,:burstlength,:thread,:channel,:bank,:bankgroup,:row,:column,:dataStrobeBegin,:dataStrobeEnd, :timeOfGeneration,:command)";
    insertRangeString = "INSERT INTO Ranges VALUES (:id,:begin,:end)";
    updateRangeString = "UPDATE Ranges SET  End = :end WHERE ID = :id";
    updateDataStrobeString = "UPDATE Transactions SET DataStrobeBegin = :begin, DataStrobeEnd = :end WHERE ID = :id";

    insertPhaseString =
            "INSERT INTO Phases (PhaseName,PhaseBegin,PhaseEnd,Transact) VALUES (:name,:begin,:end,:transaction)";
    updatePhaseString =
            "UPDATE Phases SET PhaseEnd = :end WHERE Transact = :trans AND PhaseName = :name";
    insertGeneralInfoString =
            "INSERT INTO GeneralInfo (NumberOfTransactions,TraceEnd,NumberOfBanks,clk,UnitOfTime,Memconfig,Memspec,Traces) Values "
            "(:numberOfTransactions,:end,:numberOfBanks,:clk,:unitOfTime,:memconfig,:memspec,:traces)";
    insertDebugMessageString = "INSERT INTO DebugMessages (Time,Message) Values (:time,:message)";

    sqlite3_prepare_v2(db, insertTransactionString.c_str(), -1, &insertTransactionStatement, 0);
    sqlite3_prepare_v2(db, insertRangeString.c_str(), -1, &insertRangeStatement, 0);
    sqlite3_prepare_v2(db, updateRangeString.c_str(), -1, &updateRangeStatement, 0);
    sqlite3_prepare_v2(db, insertPhaseString.c_str(), -1, &insertPhaseStatement, 0);
    sqlite3_prepare_v2(db, updatePhaseString.c_str(), -1, &updatePhaseStatement, 0);
    sqlite3_prepare_v2(db, updateDataStrobeString.c_str(), -1, &updateDataStrobeStatement, 0);
    sqlite3_prepare_v2(db, insertGeneralInfoString.c_str(), -1, &insertGeneralInfoStatement, 0);
    sqlite3_prepare_v2(db, insertDebugMessageString.c_str(), -1, &insertDebugMessageStatement, 0);
}

void TlmRecorder::insertDebugMessageInDB(string message, const sc_time& time)
{
    sqlite3_bind_int64(insertDebugMessageStatement, 1, time.value());
    sqlite3_bind_text(insertDebugMessageStatement, 2, message.c_str(), message.length(), 0);
    executeSqlStatement(insertDebugMessageStatement);
}

void TlmRecorder::insertGeneralInfo()
{
    sqlite3_bind_int64(insertGeneralInfoStatement, 1, totalNumTransactions - 1);
    sqlite3_bind_int64(insertGeneralInfoStatement, 2, simulationTimeCoveredByRecording.value());
    sqlite3_bind_int(insertGeneralInfoStatement, 3,
                     core::Configuration::getInstance().NumberOfBanks);
    sqlite3_bind_int(insertGeneralInfoStatement, 4, core::Configuration::getInstance().Timings.clk.value());
    sqlite3_bind_text(insertGeneralInfoStatement, 5, "PS", 2, NULL);
    sqlite3_bind_text(insertGeneralInfoStatement, 6, memconfig.c_str(), memconfig.length(), NULL);
    sqlite3_bind_text(insertGeneralInfoStatement, 7, memspec.c_str(), memspec.length(), NULL);
    sqlite3_bind_text(insertGeneralInfoStatement, 8, traces.c_str(), traces.length(), NULL);
    executeSqlStatement(insertGeneralInfoStatement);
}

void TlmRecorder::insertTransactionInDB(Transaction& recordingData)
{
    sqlite3_bind_int(insertTransactionStatement, 1, recordingData.id);
    sqlite3_bind_int(insertTransactionStatement, 2, recordingData.id);
    sqlite3_bind_int(insertTransactionStatement, 3, recordingData.address);
    sqlite3_bind_int(insertTransactionStatement, 4, recordingData.burstlength);
    sqlite3_bind_int(insertTransactionStatement, 5, recordingData.dramExtension.getThread().ID());
    sqlite3_bind_int(insertTransactionStatement, 6, recordingData.dramExtension.getChannel().ID());
    sqlite3_bind_int(insertTransactionStatement, 7, recordingData.dramExtension.getBank().ID());
    sqlite3_bind_int(insertTransactionStatement, 8, recordingData.dramExtension.getBankGroup().ID());
    sqlite3_bind_int(insertTransactionStatement, 9, recordingData.dramExtension.getRow().ID());
    sqlite3_bind_int(insertTransactionStatement, 10, recordingData.dramExtension.getColumn().ID());
    sqlite3_bind_int64(insertTransactionStatement, 11, recordingData.timeOnDataStrobe.start.value());
    sqlite3_bind_int64(insertTransactionStatement, 12, recordingData.timeOnDataStrobe.end.value());
    sqlite3_bind_int64(insertTransactionStatement, 13, recordingData.timeOfGeneration.value());

    executeSqlStatement(insertTransactionStatement);
}

void TlmRecorder::insertRangeInDB(unsigned int id, const sc_time& begin, const sc_time& end)
{
    sqlite3_bind_int(insertRangeStatement, 1, id);
    sqlite3_bind_int64(insertRangeStatement, 2, begin.value());
    sqlite3_bind_int64(insertRangeStatement, 3, end.value());
    executeSqlStatement(insertRangeStatement);
}
void TlmRecorder::insertPhaseInDB(string phaseName, const sc_time& begin, const sc_time& end,
                                  unsigned int transactionID)
{
    sqlite3_bind_text(insertPhaseStatement, 1, phaseName.c_str(), phaseName.length(), 0);
    sqlite3_bind_int64(insertPhaseStatement, 2, begin.value());
    sqlite3_bind_int64(insertPhaseStatement, 3, end.value());
    sqlite3_bind_int(insertPhaseStatement, 4, transactionID);
    executeSqlStatement(insertPhaseStatement);
}


void TlmRecorder::executeSqlStatement(sqlite3_stmt* statement)
{
    int errorCode = sqlite3_step(statement);
    if (errorCode != SQLITE_DONE)
    {
        reportFatal("Error in TraceRecorder", string("Could not execute statement. Error code: ") + to_string(errorCode));
    }
    sqlite3_reset(statement);
}

void TlmRecorder::executeSqlCommand(string command)
{
    printDebugMessage("Creating database by running provided sql script");

    char * errMsg = 0;
    int rc = sqlite3_exec(db, command.c_str(), NULL, 0, &errMsg);
    if (rc != SQLITE_OK)
    {
        SC_REPORT_FATAL("SQLITE Error", errMsg);
        sqlite3_free(errMsg);
    }

    printDebugMessage("Database created successfully");
}

void TlmRecorder::printDebugMessage(std::string message)
{
    DebugManager::getInstance().printDebugMessage(TlmRecorder::senderName, message);
}

void TlmRecorder::closeConnection()
{
    if(TlmRecorder::recordingEnabled)
    {
        commitRecordedDataToDB();
        insertGeneralInfo();
        printDebugMessage(
                    "Number of transactions written to DB: " + std::to_string(totalNumTransactions - 1));
        printDebugMessage("tlmPhaseRecorder:\tEnd Recording");
        sqlite3_close(db);
        db = NULL;
    }
}