/*!
 * devices_manager_internal.c
 *
 * Copyright (c) 2015-2020, NADAL Jean-Baptiste. All rights reserved.
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library 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
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
 * MA 02110-1301 USA
 * 
 * @Author:  NADAL Jean-Baptiste
 * @Date: 07/01/2020
 *
 */

// This is an independent project of an individual developer. Dear PVS-Studio, please check it.
// PVS-Studio Static Code Analyzer for C, C++, C#, and Java: http://www.viva64.com

/*-------------------------------- INCLUDES ---------------------------------*/

#include <strings.h>
#include <string.h>

#include <json.h>
#include <json_util.h>

#include "macro.h"
#include "domo.h"

#include "outlet_dio.h"
#include "shutter.h"
#include "sprinkler.h"

#include "devices_manager_internal.h"

/*!  ----------------------------------------------------------------------------
 *  @fn load_outlets
 *
 *  @brief Load outlets Object From a Json Node.
 */
int load_outlets(devices_manager_t *dm, struct json_object *node)
{
    DEBUG("devicesManager-load_outlets\n");

    /* Get Outlets */
    if (json_object_get_type(node) == json_type_array)
    {
        int length;
        struct json_object *outlet_node;

        length = json_object_array_length(node);
        for (int i = 0; i < length; i++)
        {
            outlet_dio_t *outlet = outlet_dio_new();
            outlet_node = json_object_array_get_idx(node, i);
            if (outlet_dio_from_json(outlet, outlet_node) == 0)
            {
                qlist_addlast(dm->outlets, outlet, sizeof(outlet_dio_t));
            }
        }
    }

    return 0;
}

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

struct json_object *save_outlets(devices_manager_t *dm)
{
    struct json_object *root_node;
    outlet_dio_t *outlet;
    qlist_obj_t obj;

    memset((void *)&obj, 0, sizeof(obj));
    root_node = json_object_new_array();

    while (qlist_getnext(dm->outlets, &obj, true))
    {
        outlet = obj.data;
        json_object_array_add(root_node, outlet_dio_to_json_object(outlet));
    }

    return root_node;
}

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

int create_outlet(devices_manager_t *dm, struct json_object *node)
{
    outlet_dio_t *outlet = outlet_dio_new();

    if (outlet_dio_from_json(outlet, node) != 0)
    {
        outlet_dio_free(outlet);
        return -1;
    }

    device_set_id(outlet->device, ++dm->outlets_max_id);
    qlist_addlast(dm->outlets, outlet, sizeof(outlet_dio_t));
    free(outlet); // duplicated by qlist

    return 0;
}

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

int remove_outlet(devices_manager_t *dm, uint16_t id)
{
#warning "TODO"
    return 0;
}

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

int update_outlet(devices_manager_t *dm, uint16_t id, struct json_object *node)
{
#warning "TODO"
    return 0;
}

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

int set_outlet_state(devices_manager_t *dm, uint16_t id, bool state)
{
#warning "TODO"
    return 0;
}

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

outlet_dio_t *get_outlet_by_id(devices_manager_t *dm, uint16_t id)
{
    qlist_obj_t obj;
    outlet_dio_t *outlet;

    memset((void *)&obj, 0, sizeof(obj));

    while (qlist_getnext(dm->outlets, &obj, false))
    {
        outlet = obj.data;
        if (outlet->device->id == id)
        {
            return outlet;
        }
    }

    return NULL;
}

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

int load_shutters(devices_manager_t *dm, struct json_object *node)
{
    DEBUG("devicesManager-load_shutters\n");

    /* Get Shutters */
    if (json_object_get_type(node) == json_type_array)
    {
        int length;
        struct json_object *shutter_node;

        length = json_object_array_length(node);
        for (int i = 0; i < length; i++)
        {
            shutter_t *shutter = shutter_new();
            shutter_node = json_object_array_get_idx(node, i);
            if (shutter_from_json(shutter, shutter_node) == 0)
            {
                qlist_addlast(dm->shutters, shutter, sizeof(shutter_t));
            }
        }
    }

    return 0;
}

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

struct json_object *save_shutters(devices_manager_t *dm)
{
    struct json_object *root_node;
    shutter_t *shutter;
    qlist_obj_t obj;

    memset((void *)&obj, 0, sizeof(obj));
    root_node = json_object_new_array();

    while (qlist_getnext(dm->shutters, &obj, true))
    {
        shutter = obj.data;
        json_object_array_add(root_node, shutter_to_json_object(shutter));
    }

    return root_node;
}

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

int create_shutter(devices_manager_t *dm, struct json_object *node)
{
    shutter_t *shutter = shutter_new();

    if (shutter_from_json(shutter, node) != 0)
    {
        shutter_free(shutter);
        return -1;
    }

    device_set_id(shutter->outlet_dio->device, ++dm->shutters_max_id);
    qlist_addlast(dm->shutters, shutter, sizeof(shutter_t));
    free(shutter); // duplicated by qlist

    return 0;
}

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

int remove_shutter(devices_manager_t *dm, uint16_t id)
{
    qlist_obj_t obj;
    shutter_t *shutter;
    int position = 0;

    memset((void *)&obj, 0, sizeof(obj));

    while (qlist_getnext(dm->shutters, &obj, true))
    {
        shutter = obj.data;
        if (shutter->outlet_dio->device->id == id)
        {
            qlist_removeat(dm->shutters, position);
            return 0;
        }
        position++;
    }

    return -1;
}

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

int update_shutter(devices_manager_t *dm, uint16_t id, struct json_object *node)
{
    qlist_obj_t obj;
    shutter_t *shutter;

    memset((void *)&obj, 0, sizeof(obj));

    while (qlist_getnext(dm->shutters, &obj, false))
    {
        shutter = obj.data;
        if (shutter->outlet_dio->device->id == id)
        {
            return shutter_from_json(shutter, node);
        }
    }

    return -1;
}

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

int set_shutter_state(devices_manager_t *dm, uint16_t id, bool state)
{
#warning "TODO"
    return 0;
}

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

shutter_t *get_shutter_by_id(devices_manager_t *dm, uint16_t id)
{
    qlist_obj_t obj;
    shutter_t *shutter;

    memset((void *)&obj, 0, sizeof(obj));

    while (qlist_getnext(dm->shutters, &obj, false))
    {
        shutter = obj.data;
        if (shutter->outlet_dio->device->id == id)
        {
            return shutter;
        }
    }

    return NULL;
}

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

int load_sprinklers(devices_manager_t *dm, struct json_object *node)
{
    DEBUG("devicesManager-load_sprinkler\n");

    /* Get Shutters */
    if (json_object_get_type(node) == json_type_array)
    {
        int length;
        struct json_object *sprinkler_node;

        length = json_object_array_length(node);
        for (int i = 0; i < length; i++)
        {
            sprinkler_t *sprinkler = sprinkler_new();
            sprinkler_node = json_object_array_get_idx(node, i);
            if (sprinkler_from_json(sprinkler, sprinkler_node) == 0)
            {
                qlist_addlast(dm->sprinklers, sprinkler, sizeof(sprinkler_t));
            }
        }
    }

    return 0;
}

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

struct json_object *save_sprinklers(devices_manager_t *dm)
{
    struct json_object *root_node;
    sprinkler_t *sprinkler;
    qlist_obj_t obj;

    memset((void *)&obj, 0, sizeof(obj));
    root_node = json_object_new_array();

    while (qlist_getnext(dm->sprinklers, &obj, true))
    {
        sprinkler = obj.data;
        json_object_array_add(root_node, sprinkler_to_json_object(sprinkler));
    }

    return root_node;
}

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

int create_sprinkler(devices_manager_t *dm, struct json_object *node)
{
    sprinkler_t *sprinkler = sprinkler_new();

    if (sprinkler_from_json(sprinkler, node) != 0)
    {
        sprinkler_free(sprinkler);
        return -1;
    }

    device_set_id(sprinkler->device, ++dm->sprinklers_max_id);
    qlist_addlast(dm->sprinklers, sprinkler, sizeof(sprinkler_t));
    free(sprinkler); // duplicated by qlist

    return 0;
}

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

int remove_sprinkler(devices_manager_t *dm, uint16_t id)
{
    qlist_obj_t obj;
    sprinkler_t *sprinkler;
    int position = 0;

    memset((void *)&obj, 0, sizeof(obj));

    while (qlist_getnext(dm->sprinklers, &obj, true))
    {
        sprinkler = obj.data;
        if (sprinkler->device->id == id)
        {
            qlist_removeat(dm->sprinklers, position);
            return 0;
        }
        position++;
    }

    return -1;
}

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

int update_sprinkler(devices_manager_t *dm, uint16_t id, struct json_object *node)
{
    qlist_obj_t obj;
    sprinkler_t *sprinkler;

    memset((void *)&obj, 0, sizeof(obj));

    while (qlist_getnext(dm->sprinklers, &obj, false))
    {
        sprinkler = obj.data;
        if (sprinkler->device->id == id)
        {
            return sprinkler_from_json(sprinkler, node);
        }
    }

    return -1;
}

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

int set_sprinkler_state(devices_manager_t *dm, uint16_t id, bool state)
{
    qlist_obj_t obj;
    sprinkler_t *sprinkler;

    memset((void *)&obj, 0, sizeof(obj));

    while (qlist_getnext(dm->sprinklers, &obj, true))
    {
        sprinkler = obj.data;
        if (sprinkler->device->id == id)
        {
            sprinkler->device->state = state;
            return 0;
        }
    }

    return -1;
}

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

sprinkler_t *get_sprinkler_by_id(devices_manager_t *dm, uint16_t id)
{
    qlist_obj_t obj;
    sprinkler_t *sprinkler;

    memset((void *)&obj, 0, sizeof(obj));

    while (qlist_getnext(dm->sprinklers, &obj, false))
    {
        sprinkler = obj.data;
        if (sprinkler->device->id == id)
        {
            return sprinkler;
        }
    }

    return NULL;
}