#include "modbus_points.h"

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <ctype.h>

/* ---------- local helpers ---------- */

static void trim_whitespace(char *s)
{
    char *start;
    char *end;

    if (s == NULL || *s == '\0')
        return;

    start = s;
    while (*start != '\0' && isspace((unsigned char)*start))
        start++;

    if (start != s)
        memmove(s, start, strlen(start) + 1U);

    if (*s == '\0')
        return;

    end = s + strlen(s) - 1;
    while (end >= s && isspace((unsigned char)*end))
    {
        *end = '\0';
        end--;
    }
}

static bool str_equals(const char *a, const char *b)
{
    if (a == NULL || b == NULL)
        return false;

    return strcmp(a, b) == 0;
}

static modbus_point_type_t parse_point_type(const char *s)
{
    if (str_equals(s, "Coil"))
        return MB_POINT_COIL;
    if (str_equals(s, "Discrete_Input"))
        return MB_POINT_DISCRETE_INPUT;
    if (str_equals(s, "Input_Register"))
        return MB_POINT_INPUT_REGISTER;
    if (str_equals(s, "Holding_Register"))
        return MB_POINT_HOLDING_REGISTER;

    return MB_POINT_INVALID;
}

static modbus_data_type_t parse_data_type(const char *s)
{
    if (str_equals(s, "bool"))
        return MB_DATA_BOOL;
    if (str_equals(s, "uint16"))
        return MB_DATA_UINT16;
    if (str_equals(s, "uint32"))
        return MB_DATA_UINT32;
    if (str_equals(s, "float"))
        return MB_DATA_FLOAT;
    if (str_equals(s, "double"))
        return MB_DATA_DOUBLE;

    return MB_DATA_INVALID;
}

static pics_data_type_t parse_pics_data_type(const char *s)
{
    if (str_equals(s, "Boolean"))
        return PICS_DATA_BOOLEAN;

    if (str_equals(s, "Integer"))
        return PICS_DATA_INTEGER;

    if (str_equals(s, "Float"))
        return PICS_DATA_FLOAT;

    if (str_equals(s, "String"))
        return PICS_DATA_STRING;

    if (s == NULL || *s == '\0')
        return PICS_DATA_NONE;

    return PICS_DATA_INVALID;
}

static bool parse_u32(const char *s, uint32_t *value)
{
    char *endptr;
    unsigned long v;

    if (s == NULL || value == NULL || *s == '\0')
        return false;

    v = strtoul(s, &endptr, 10);
    if (*endptr != '\0')
        return false;

    *value = (uint32_t)v;
    return true;
}

static modbus_point_type_t infer_point_type_from_address(uint32_t raw_address)
{
    uint32_t family_digit;

    if (raw_address == 0U)
        return MB_POINT_INVALID;

    if (raw_address < 10000U)
        return MB_POINT_COIL;

    if (raw_address >= 100000U)
        family_digit = raw_address / 100000U;
    else
        family_digit = raw_address / 10000U;

    switch (family_digit)
    {
        case 1U:
            return MB_POINT_DISCRETE_INPUT;
        case 3U:
            return MB_POINT_INPUT_REGISTER;
        case 4U:
            return MB_POINT_HOLDING_REGISTER;
        default:
            return MB_POINT_INVALID;
    }
}

static bool normalize_address(modbus_point_type_t type, uint32_t raw_address, uint16_t *offset)
{
    uint32_t index_1_based;
    uint32_t off;
    uint32_t family_digit = 0U;

    if (offset == NULL || raw_address == 0U)
        return false;

    if (raw_address >= 100000U)
    {
        family_digit = raw_address / 100000U;
        index_1_based = raw_address % 100000U;
    }
    else if (raw_address >= 10000U)
    {
        family_digit = raw_address / 10000U;
        index_1_based = raw_address % 10000U;
    }
    else
    {
        family_digit = 0U;
        index_1_based = raw_address;
    }

    if (index_1_based == 0U)
        return false;

    switch (type)
    {
        case MB_POINT_COIL:
            if (family_digit != 0U)
                return false;
            off = index_1_based - 1U;
            break;

        case MB_POINT_DISCRETE_INPUT:
            if (family_digit != 1U)
                return false;
            off = index_1_based - 1U;
            break;

        case MB_POINT_INPUT_REGISTER:
            if (family_digit != 3U)
                return false;
            off = index_1_based - 1U;
            break;

        case MB_POINT_HOLDING_REGISTER:
            if (family_digit != 4U)
                return false;
            off = index_1_based - 1U;
            break;

        default:
            return false;
    }

    if (off > 0xFFFFU)
        return false;

    *offset = (uint16_t)off;
    return true;
}

static bool validate_type_and_datatype(modbus_point_type_t type, modbus_data_type_t data_type)
{
    switch (type)
    {
        case MB_POINT_COIL:
        case MB_POINT_DISCRETE_INPUT:
            return data_type == MB_DATA_BOOL;

        case MB_POINT_INPUT_REGISTER:
        case MB_POINT_HOLDING_REGISTER:
            return data_type == MB_DATA_UINT16 ||
                   data_type == MB_DATA_UINT32 ||
                   data_type == MB_DATA_FLOAT ||
                   data_type == MB_DATA_DOUBLE;

        default:
            return false;
    }
}

static uint8_t data_type_reg_span(modbus_data_type_t data_type)
{
    switch (data_type)
    {
        case MB_DATA_BOOL:
        case MB_DATA_UINT16:
            return 1U;

        case MB_DATA_UINT32:
        case MB_DATA_FLOAT:
            return 2U;

        case MB_DATA_DOUBLE:
            return 4U;

        default:
            return 0U;
    }
}

static bool db_has_duplicate_type_offset(const modbus_db_t *db,
                                         modbus_point_type_t type,
                                         uint16_t offset)
{
    size_t i;

    if (db == NULL)
        return false;

    for (i = 0; i < db->count; i++)
    {
        if (db->points[i].type == type && db->points[i].offset == offset)
            return true;
    }

    return false;
}

static bool ranges_overlap(uint16_t start_a, uint8_t span_a,
                           uint16_t start_b, uint8_t span_b)
{
    uint32_t end_a;
    uint32_t end_b;

    if (span_a == 0U || span_b == 0U)
        return false;

    end_a = (uint32_t)start_a + (uint32_t)span_a - 1U;
    end_b = (uint32_t)start_b + (uint32_t)span_b - 1U;

    return !((end_a < start_b) || (end_b < start_a));
}

const modbus_point_t *modbus_points_find_by_pics_offset(const modbus_db_t *db,
                                                        modbus_point_type_t type,
                                                        uint16_t offset)
{
    size_t i;

    if (db == NULL)
        return NULL;

    for (i = 0; i < db->count; i++)
    {
        if (db->points[i].has_pics_address &&
            db->points[i].pics_type == type &&
            db->points[i].pics_offset == offset)
            return &db->points[i];
    }

    return NULL;
}

const modbus_point_t *modbus_points_find_by_pics_range(const modbus_db_t *db,
                                                       modbus_point_type_t type,
                                                       uint16_t offset)
{
    size_t i;

    if (db == NULL)
        return NULL;

    for (i = 0; i < db->count; i++)
    {
        const modbus_point_t *pt = &db->points[i];
        uint32_t end_offset;

        if (!pt->has_pics_address || pt->pics_reg_span == 0U)
            continue;

        if (pt->pics_type != type)
            continue;

        end_offset = (uint32_t)pt->pics_offset + (uint32_t)pt->pics_reg_span - 1U;

        if ((uint32_t)offset >= (uint32_t)pt->pics_offset &&
            (uint32_t)offset <= end_offset)
            return pt;
    }

    return NULL;
}

static bool db_has_duplicate_pics_range(const modbus_db_t *db,
                                        modbus_point_type_t pics_type,
                                        uint16_t pics_offset,
                                        uint8_t pics_reg_span)
{
    size_t i;

    if (db == NULL || pics_reg_span == 0U)
        return false;

    for (i = 0; i < db->count; i++)
    {
        const modbus_point_t *pt = &db->points[i];

        if (!pt->has_pics_address || pt->pics_reg_span == 0U)
            continue;

        if (pt->pics_type != pics_type)
            continue;

        if (ranges_overlap(pt->pics_offset, pt->pics_reg_span,
                           pics_offset, pics_reg_span))
            return true;
    }

    return false;
}

static bool validate_control_mapping(const modbus_point_t *pt)
{
    if (pt == NULL)
        return false;

    if (!pt->has_control_address)
        return true;

    if (!modbus_points_is_writable_type(pt->control_type))
        return false;

    switch (pt->type)
    {
        case MB_POINT_DISCRETE_INPUT:
            return pt->control_type == MB_POINT_COIL;

        case MB_POINT_INPUT_REGISTER:
            return pt->control_type == MB_POINT_HOLDING_REGISTER;

        case MB_POINT_COIL:
        case MB_POINT_HOLDING_REGISTER:
            return false;

        default:
            return false;
    }
}

static bool append_helper_points(modbus_db_t *db, const modbus_point_t *base_pt)
{
    uint8_t i;

    if (db == NULL || base_pt == NULL)
        return false;

    if (base_pt->reg_span <= 1U)
        return true;

    for (i = 1U; i < base_pt->reg_span; i++)
    {
        modbus_point_t helper = *base_pt;

        helper.raw_address = base_pt->raw_address + (uint32_t)i;
        helper.offset = (uint16_t)(base_pt->offset + i);
        helper.data_type = MB_DATA_UINT16;
        helper.reg_span = 1U;
        helper.is_helper = true;
        helper.has_control_address = false;
        helper.control_raw_address = 0U;
        helper.control_type = MB_POINT_INVALID;
        helper.control_offset = 0U;
        helper.has_pics_address = false;
        helper.pics_raw_address = 0U;
        helper.pics_type = MB_POINT_INVALID;
        helper.pics_offset = 0U;
        helper.pics_data_type = PICS_DATA_NONE;
        helper.pics_reg_span = 0U;
        memset(helper.pics_words, 0, sizeof(helper.pics_words));
        helper.bit_value = 0U;
        helper.reg_value = 0U;


        if (db->count >= MODBUS_MAX_POINTS)
            return false;


        if (db_has_duplicate_type_offset(db, helper.type, helper.offset))
            return false;

        db->points[db->count++] = helper;
    }

    return true;
}

static bool parse_csv_line(const char *line_in, modbus_point_t *pt)
{
    char line[MODBUS_MAX_CSV_LINE_LEN];
    char *fields[8];
    size_t field_count = 0;
    char *p;
    uint32_t raw_address;

    if (line_in == NULL || pt == NULL)
        return false;

    strncpy(line, line_in, sizeof(line) - 1U);
    line[sizeof(line) - 1U] = '\0';

    p = line;
    fields[field_count++] = p;

    while (*p != '\0' && field_count < 8U)
    {
        if (*p == ',')
        {
            *p = '\0';
            fields[field_count++] = p + 1;
        }
        p++;
    }

    if (field_count != 8U)
        return false;

    for (size_t i = 0; i < field_count; i++)
        trim_whitespace(fields[i]);

    memset(pt, 0, sizeof(*pt));
    pt->control_type = MB_POINT_INVALID;
    pt->bit_value = 0U;
    pt->reg_value = 0U;

    pt->type = parse_point_type(fields[0]);
    if (pt->type == MB_POINT_INVALID)
        return false;

    if (!parse_u32(fields[1], &raw_address))
        return false;
    pt->raw_address = raw_address;

    if (!normalize_address(pt->type, pt->raw_address, &pt->offset))
        return false;

    pt->data_type = parse_data_type(fields[3]);
    if (pt->data_type == MB_DATA_INVALID)
        return false;

    if (!validate_type_and_datatype(pt->type, pt->data_type))
        return false;

    pt->reg_span = data_type_reg_span(pt->data_type);
    pt->is_helper = false;

    if (pt->reg_span == 0U)
        return false;

    if (fields[4][0] != '\0')
    {
        uint32_t control_raw;

        if (!parse_u32(fields[4], &control_raw))
            return false;

        pt->has_control_address = true;
        pt->control_raw_address = control_raw;
        pt->control_type = infer_point_type_from_address(control_raw);

        if (pt->control_type == MB_POINT_INVALID)
            return false;

        if (!normalize_address(pt->control_type, pt->control_raw_address, &pt->control_offset))
            return false;

        if (!validate_control_mapping(pt))
            return false;
    }
    else
    {
        pt->has_control_address = false;
        pt->control_raw_address = 0U;
        pt->control_type = MB_POINT_INVALID;
        pt->control_offset = 0U;
    }

    if (fields[5][0] != '\0')
    {
        uint32_t pics_raw;

        if (!parse_u32(fields[5], &pics_raw))
            return false;

        pt->has_pics_address = true;
        pt->pics_raw_address = pics_raw;
        pt->pics_type = infer_point_type_from_address(pics_raw);

        if (pt->pics_type == MB_POINT_INVALID)
            return false;

        if (!normalize_address(pt->pics_type, pt->pics_raw_address, &pt->pics_offset))
            return false;
    }
    else
    {
        pt->has_pics_address = false;
        pt->pics_raw_address = 0U;
        pt->pics_type = MB_POINT_INVALID;
        pt->pics_offset = 0U;
    }

    pt->pics_data_type = parse_pics_data_type(fields[6]);

    if (pt->pics_data_type == PICS_DATA_INVALID)
        return false;

    if (pt->pics_data_type == PICS_DATA_STRING)
        return false;

    switch (pt->pics_data_type)
    {
        case PICS_DATA_BOOLEAN:
            pt->pics_reg_span = 1U;
            break;
        case PICS_DATA_INTEGER:
            pt->pics_reg_span = 2U;
            break;
        case PICS_DATA_FLOAT:
            pt->pics_reg_span = 4U;
            break;
        case PICS_DATA_NONE:
            pt->pics_reg_span = 0U;
            break;
        default:
            pt->pics_reg_span = 0U;
            break;
    }

    if (pt->has_pics_address && pt->pics_data_type == PICS_DATA_NONE)
        return false;

    if (!pt->has_pics_address && pt->pics_data_type != PICS_DATA_NONE)
        return false;

    if (pt->has_pics_address)
    {
        switch (pt->pics_data_type)
        {
            case PICS_DATA_INTEGER:
            case PICS_DATA_FLOAT:
                if (pt->pics_type != MB_POINT_HOLDING_REGISTER)
                    return false;
                break;

            case PICS_DATA_BOOLEAN:
                if (pt->pics_type != MB_POINT_COIL &&
                    pt->pics_type != MB_POINT_HOLDING_REGISTER)
                    return false;
                break;

            default:
                break;
        }
    }

    return true;
}

/* ---------- public API ---------- */

void modbus_points_init(modbus_db_t *db)
{
    modbus_points_reset(db);
}

void modbus_points_reset(modbus_db_t *db)
{
    if (db == NULL)
        return;

    memset(db, 0, sizeof(*db));
}

bool modbus_points_load(modbus_db_t *db, const char *filename)
{
    FILE *fp;
    char line[MODBUS_MAX_CSV_LINE_LEN];
    size_t line_num = 0;

    if (db == NULL || filename == NULL)
        return false;

    fp = fopen(filename, "r");
    if (fp == NULL)
    {
        printf("CSV ERROR: failed to open file: %s\n", filename);
        return false;
    }

    modbus_points_reset(db);

    while (fgets(line, sizeof(line), fp) != NULL)
    {
        modbus_point_t pt;
        char *newline;

        line_num++;

        newline = strchr(line, '\n');
        if (newline != NULL)
            *newline = '\0';

        newline = strchr(line, '\r');
        if (newline != NULL)
            *newline = '\0';

        trim_whitespace(line);

        if (line[0] == '\0')
            continue;

        if (line_num == 1U)
            continue;

        {
            char temp_line[MODBUS_MAX_CSV_LINE_LEN];
            char *fields[8];
            size_t field_count = 0;
            char *p;
            bool all_fields_empty = true;
            size_t i;

            strncpy(temp_line, line, sizeof(temp_line) - 1U);
            temp_line[sizeof(temp_line) - 1U] = '\0';

            p = temp_line;
            fields[field_count++] = p;

            while (*p != '\0' && field_count < 8U)
            {
                if (*p == ',')
                {
                    *p = '\0';
                    fields[field_count++] = p + 1;
                }
                p++;
            }

            if (field_count == 8U)
            {
                for (i = 0; i < field_count; i++)
                {
                    trim_whitespace(fields[i]);
                    if (fields[i][0] != '\0')
                    {
                        all_fields_empty = false;
                        break;
                    }
                }

                if (all_fields_empty)
                    continue;
            }
        }

        if (db->count >= MODBUS_MAX_POINTS)
        {
            printf("CSV ERROR line %u: exceeded MODBUS_MAX_POINTS (%u)\n",
                   (unsigned)line_num,
                   (unsigned)MODBUS_MAX_POINTS);
            fclose(fp);
            return false;
        }

        if (!parse_csv_line(line, &pt))
        {
            printf("CSV ERROR line %u: parse failed: %s\n",
                   (unsigned)line_num,
                   line);
            fclose(fp);
            return false;
        }

        if (db_has_duplicate_type_offset(db, pt.type, pt.offset))
        {
            printf("CSV ERROR line %u: duplicate Modbus address raw=%lu offset=%u\n",
                   (unsigned)line_num,
                   (unsigned long)pt.raw_address,
                   (unsigned)pt.offset);

            fclose(fp);
            return false;
        }

        if (pt.has_pics_address &&
            db_has_duplicate_pics_range(db,
                                        pt.pics_type,
                                        pt.pics_offset,
                                        pt.pics_reg_span))
        {
            printf("CSV ERROR line %u: overlapping PICS range pics_raw=%lu pics_offset=%u span=%u\n",
                   (unsigned)line_num,
                   (unsigned long)pt.pics_raw_address,
                   (unsigned)pt.pics_offset,
                   (unsigned)pt.pics_reg_span);
            fclose(fp);
            return false;
        }

        db->points[db->count++] = pt;

        if (!append_helper_points(db, &pt))
        {
            printf("CSV ERROR line %u: failed to append helper points\n",
                   (unsigned)line_num);
            fclose(fp);
            return false;
        }
    }

    fclose(fp);
    return true;
}


const modbus_point_t *modbus_points_find_by_type_offset(const modbus_db_t *db,
                                                        modbus_point_type_t type,
                                                        uint16_t offset)
{
    size_t i;

    if (db == NULL)
        return NULL;

    for (i = 0; i < db->count; i++)
    {
        if (db->points[i].type == type && db->points[i].offset == offset)
            return &db->points[i];
    }

    return NULL;
}

modbus_mem_type_t modbus_points_type_to_mem(modbus_point_type_t type)
{
    switch (type)
    {
        case MB_POINT_COIL:
            return MB_MEM_COIL;
        case MB_POINT_DISCRETE_INPUT:
            return MB_MEM_DISCRETE_INPUT;
        case MB_POINT_INPUT_REGISTER:
            return MB_MEM_INPUT_REGISTER;
        case MB_POINT_HOLDING_REGISTER:
            return MB_MEM_HOLDING_REGISTER;
        default:
            return MB_MEM_COIL;
    }
}

bool modbus_points_is_bit_type(modbus_point_type_t type)
{
    return (type == MB_POINT_COIL || type == MB_POINT_DISCRETE_INPUT);
}

bool modbus_points_is_reg_type(modbus_point_type_t type)
{
    return (type == MB_POINT_INPUT_REGISTER || type == MB_POINT_HOLDING_REGISTER);
}

bool modbus_points_is_writable_type(modbus_point_type_t type)
{
    return (type == MB_POINT_COIL || type == MB_POINT_HOLDING_REGISTER);
}