//=-------------------------------------------------------------------------=//
//  Model management module                                                  //
//                                                                           //
//  Copyright © 2021 The Gem-graph Project                                   //
//                                                                           //
//  This file is part of gem-graph.                                          //
//                                                                           //
//  This program is free software: you can redistribute it and/or modify     //
//  it under the terms of the GNU Affero General Public License as           //
//  published by the Free Software Foundation, either version 3 of the       //
//  License, or (at your option) any later version.                          //
//                                                                           //
//  This program is distributed in the hope that it will be useful,          //
//  but WITHOUT ANY WARRANTY; without even the implied warranty of           //
//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the            //
//  GNU Affero General Public License for more details.                      //
//                                                                           //
//  You should have received a copy of the GNU Affero General Public License //
//  along with this program.  If not, see <https://www.gnu.org/licenses/>.   //
//=-------------------------------------------------------------------------=//

#include "../include/base.h"
#include "../include/xml.h"
#include "../include/arrows.h"
#include "../include/scheduler.h"

#include <dirent.h>
#include <signal.h>

#define MAX_MODEL_NUMBER 1
#define MAX_MODEL_NAME_SIZE 255
#define ARROW_NUMBER 6
#define SITE_NUMBER 2
#define MAX_CYCLES 10
#define MAX_THREAD 0
#define XMAX 39
#define YMAX 0
#define ZMAX 0
#define SPACE_SIZE (XMAX+1) * (YMAX+1) * (ZMAX+1)

static Model_t **loadedModel;
static int loadedModelSize;    // begins to 1

static Model_t **knownModel;
static int knownModelSize;     // begins to 1

Model_t *lastModel;
Model_t **lastModelAddr;


static int ModelParseFile(Model_t *model);


void ModelSystemDestroy(void);

/* -------------------------------------------------------------------------- */
void ModelCreate(Model_t **newModel) // TODO manage deletion and empty slots
{
    // increment index
    knownModelSize++;
    // create socket
    knownModel =
        (Model_t**) realloc(knownModel, knownModelSize * sizeof(Model_t*));
    // populate socket
    knownModel[knownModelSize-1] = (Model_t*) calloc(1, sizeof(Model_t));
    // populate model
    knownModel[knownModelSize-1]->id = knownModelSize;
    // return value
    *newModel = knownModel[knownModelSize-1];
    lastModel = knownModel[knownModelSize-1];
    lastModelAddr = &knownModel[knownModelSize-1];

    // cont. model population
    knownModel[knownModelSize-1]->name =
        (char *) calloc(1, sizeof(char) * MAX_MODEL_NAME_SIZE);
    knownModel[knownModelSize-1]->filename =
        (char *) calloc(1, sizeof(char) * MAX_MODEL_NAME_SIZE);
    knownModel[knownModelSize-1]->space_xMax = XMAX;
    knownModel[knownModelSize-1]->space_yMax = YMAX;
    knownModel[knownModelSize-1]->space_zMax = ZMAX;
    knownModel[knownModelSize-1]->nmaxThread = MAX_THREAD;
    knownModel[knownModelSize-1]->nmaxCycles = MAX_CYCLES;
    knownModel[knownModelSize-1]->siteNumber = 0;
}

void printModels(char *buf)
{
    sprintf(buf + strlen(buf),"Known models\n");
    for (int i = 0; i <= knownModelSize-1; i++) {
        sprintf(buf + strlen(buf), "id: %d, addr: %p, name: %s\n",
                knownModel[i]->id, knownModel[i], knownModel[i]->name);
    }

    sprintf(buf + strlen(buf), "\nLoaded models\n");
    for (int i = 0; i <= loadedModelSize-1; i++) {
        sprintf(buf + strlen(buf), "id: %d, addr: %p, name: %s\n",
                loadedModel[i]->id, loadedModel[i], loadedModel[i]->name);
    }
}

int ModelLoad(int id) // TODO unload !
{
    if (id <= 0 || id > knownModelSize) {
        return -1;
    }

    printLog("Loading model id %d (/%d models)...\n", id, knownModelSize);

    // Creating structure for the Scheduler
    knownModel[id-1]->scheduler = (Scheduler_t*) calloc(1, sizeof(Scheduler_t));

    loadedModel =
        (Model_t**) realloc(loadedModel, ++loadedModelSize * sizeof(Model_t*));

    loadedModel =
        (Model_t**) realloc(loadedModel, loadedModelSize * sizeof(Model_t*));
    loadedModel[loadedModelSize-1] = knownModel[id-1];
    return loadedModelSize;
}

int ModelRun(int id)
{
    if (id <= 0 || id > loadedModelSize)
        return 0;

    if (!loadedModel[id-1]->scheduler)
        return 0;

    if (loadedModel[id-1]->isRunning)
        return 0;

    loadedModel[id-1]->scheduler->globalDrawingSpace =
        (Space_t*) calloc(1, sizeof(Space_t)); // TODO free this

    loadedModel[id-1]->scheduler->nMaxThread = knownModel[id-1]->nmaxThread;
    loadedModel[id-1]->scheduler->nMaxCycles = knownModel[id-1]->nmaxCycles;

    // Preparing global drawing space
    // TODO Load space

    loadedModel[id-1]->scheduler->arrowArray =
        (ArrowArray_t*) calloc(1, sizeof(ArrowArray_t)); // TODO free this

    // TODO Load arrows

    loadedModel[id-1]->scheduler->pleaseStop = false;
    loadedModel[id-1]->isRunning = true;

    SchedInit(loadedModel[id-1]->scheduler);

    printLog("Model %d launched\n", id);
    return 1;
}

int ModelStop(int id)
{
    if (id <= 0 || id > loadedModelSize) {
        return 0;
    }
    if (!loadedModel[id-1]->scheduler) {
        return 0;
    }

    loadedModel[id-1]->scheduler->pleaseStop = true;
    printLog("Model %d stop bit set\n", id);

    SchedWait(loadedModel[id-1]->scheduler);
    SchedDestroy(loadedModel[id-1]->scheduler);

    loadedModel[id-1]->isRunning = false;
    return 1;
}

void ModelDelete(int id) //XXX
{
    free(knownModel[id-1]->name);
    knownModel[id-1]->name = NULL;
    free(knownModel[id-1]->filename);
    knownModel[id-1]->name = NULL;
    free(knownModel[id-1]);
    knownModel[id-1] = NULL;
    knownModelSize--;
}

void ModelShutdown(void)
{
    for (int i = 0; i < loadedModelSize; i++) {
        ModelStop(i);
    }
}

void ModelSystemInit(Parameters_t *parameters)
{
    struct dirent *modelDirEntry = NULL;
    DIR *modelDir = NULL;
    Model_t *newModel;
    char *extensionPosition;

    loadedModel = (Model_t**) calloc(1, sizeof(Model_t*));

    knownModel = (Model_t**) calloc(1, sizeof(Model_t*));

    knownModelSize = 0;
    loadedModelSize = 0;

    printLog("Model system initiated with folder : %s\n", parameters->modelDir);

    if ((modelDir = opendir(parameters->modelDir)) <= 0) {
        printLog("Could not open %s\n", parameters->modelDir);
        ModelSystemDestroy();
        kill(getpid(), SIGTERM);
        return;
    }

    while ((modelDirEntry = readdir(modelDir)) != NULL) {
        if ((extensionPosition = strstr(modelDirEntry->d_name, ".xml"))) {

            // Creating model
            ModelCreate(&newModel);

            // Write filename
            /* strncpy(newModel->filename, modelDirEntry->d_name, */
            /*         strlen(modelDirEntry->d_name)); // XXX get full path */
            strncpy(newModel->filename, parameters->modelDir,
                    strlen(parameters->modelDir));
            strcat(newModel->filename
                        + strlen(parameters->modelDir),
                    "/");
            strncpy(newModel->filename
                        + strlen(parameters->modelDir)
                        + 1,
                    modelDirEntry->d_name,
                    strlen(modelDirEntry->d_name));

            // Write name
            strncpy(newModel->name, modelDirEntry->d_name,
                    extensionPosition - modelDirEntry->d_name);

            if (ModelParseFile(newModel) != 0) {
                ModelDelete(newModel->id);
                continue;
            };

            // Check model is valid and/or parsed
            if (newModel->validated == false) {
                ModelDelete(newModel->id);
                continue;
            }

            printLog("Loaded model %s\n", newModel->name);
        }
    }
}

void ModelSystemDestroy(void)
{
    for (int i = 0; i < loadedModelSize; i++) {
        ModelDelete(i);
    }
    free(loadedModel);
    loadedModel = NULL;
    free(knownModel);
    knownModel = NULL;
}

/* -------------------------------------------------------------------------- */

static int ModelParseFile(Model_t *model)
{
    ModelField_t identityField;
    ModelField_t authorField;
    ModelField_t nameField;
    ModelField_t dateField;
    ModelField_t versionField;

    strcpy(identityField.id, "identity");
    identityField.value = NULL;
    identityField.son = &nameField;
    identityField.next = NULL;

    strcpy(nameField.id, "name");
    nameField.value = model->name;
    nameField.son = NULL;
    nameField.next = &authorField;

    strcpy(authorField.id, "author");
    authorField.value = NULL;
    authorField.son = NULL;
    authorField.next = &dateField;

    strcpy(dateField.id, "date");
    dateField.value = NULL;
    dateField.son = NULL;
    dateField.next = &versionField;

    strcpy(versionField.id, "version");
    versionField.value = NULL;
    versionField.son = NULL;
    versionField.next = NULL;

    // TODO modify model according to things in file

    printLog("Parsing model %s\n", model->name);
    openCurrentDocument(model->filename);

    resetDocumentRoot();
    if (parseTree(&identityField) != 0) {
        printLog("Invalid document, parsing can't succeed!\n");
        closeCurrentDocument();
        return EBADF;
    }

    closeCurrentDocument();
    model->validated = true;
    return 0;
}