#include "param_mgr.h"
#include "builtin_typeid_types.h"
#include "param_pre.h"
#include <string.h>
#include <stdint.h>
#include <stdbool.h>

#ifndef PARAM_PROPS_MAXLEN
#define PARAM_PROPS_MAXLEN (350)
#endif

param_prop props[PARAM_PROPS_MAXLEN];
uint16_t param_count = 0u;

param_prop *param_get_by_idx(uint16_t idx)
{
    if (idx < param_count)
    {
        return props + idx;
    }

    return NULL;
}

uint16_t param_get_count(void)
{
    return param_count;
}

static int16_t find_idx_by_name2(uint16_t b, uint16_t e, const char name[16])
{
    if (b + 1u == e)
    {
        return e;
    }

    uint16_t m;
    m = (b + e) >> 1;
    int cmp = strncmp(name, props[m].name, 16);
    if (cmp < 0)
    {
        return find_idx_by_name2(b, m, name);
    }
    else
    {
        return find_idx_by_name2(m, e, name);
    }
}

uint16_t find_idx_by_name(const char name[16])
{
    int cmp;
    if (param_count == 0u)
    {
        return 0u;
    }
    else if (param_count == 1u)
    {
        cmp = strncmp(name, props[0].name, 16);
        if (cmp < 0)
        {
            return 0u;
        }
        else
        {
            return 1u;
        }
    }
    else
    {
        cmp = strncmp(name, props[0].name, 16);
        if (cmp < 0)
        {
            return 0;
        }
        else
        {
            cmp = strncmp(name, props[param_count - 1].name, 16);
            if (cmp < 0)
            {
                return find_idx_by_name2(0, param_count - 1, name);
            }
            else
            {
                return param_count;
            }
        }
    }
}

param_prop *param_get_by_name(const char name[16])
{
    uint16_t idx = find_idx_by_name(name);
    if (idx > 0u && idx <= param_count && strncmp(name, props[idx - 1].name, 16) == 0)
    {
        return props + (idx - 1);
    }
    return NULL;
}

int16_t param_get_idx_by_name(const char name[16])
{
    uint16_t idx = find_idx_by_name(name);
    if (idx > 0u && idx <= param_count && strncmp(name, props[idx - 1].name, 16) == 0)
    {
        return idx - 1;
    }
    return -1;
}

int param_mgr_regist(param_prop *prop)
{
    if (param_count < PARAM_PROPS_MAXLEN)
    {
        uint16_t idx = find_idx_by_name(prop->name);
        for (uint16_t i = param_count; i > idx; --i)
        {
            memcpy(&props[i], &props[i - 1u], sizeof(param_prop));
        }
        memcpy(&props[idx], prop, sizeof(param_prop));
        ++param_count;
        return 0;
    }
    return -1;
}

int param_get_size(param_prop *prop)
{
    switch (prop->typ)
    {
    case PARAM_TYPE_UINT8:
    case PARAM_TYPE_INT8:
        return 1;
    case PARAM_TYPE_UINT16:
    case PARAM_TYPE_INT16:
        return 2;
    default:
        return 4;
    }
}

void param_set_value(param_prop *prop, const uint8_t value[4])
{
    param_value_ptr_t val_ptr;

    val_ptr.B = (uint8_t *)value;

    if (prop->setter_ptr)
    {
        (*props->setter_ptr)(val_ptr);
    }
    else
    {
        memcpy(prop->val_ptr.B, value, param_get_size(prop));
    }
}

void param_get_value(param_prop *prop, uint8_t value[4])
{
    param_value_ptr_t val_ptr;

    if (prop->getter_ptr)
    {
        val_ptr.B = value;
        (*props->getter_ptr)(val_ptr);
    }
    else
    {
        val_ptr = prop->val_ptr;
        memcpy(value, val_ptr.B, param_get_size(prop));
    }
}

#if defined ( __GNUC__ ) && !defined (__CC_ARM) /* GNU Compiler */
  #ifndef __weak
    #define __weak   __attribute__((weak))
  #endif /* __weak */
#else
    #define __weak
#endif /* __GNUC__ */

__weak bool param_NVRAM_write(uint32_t offset, uint8_t *buf, uint32_t size)
{
    return false;
}

__weak bool param_NVRAM_read(uint32_t offset, uint8_t *buf, uint32_t size)
{
    return false;
}

bool save_param(void)
{
	uint16_t n = param_get_count();
	uint8_t param_buff[24];
    uint32_t *chksum;
    chksum = &param_buff[20];
    for (uint16_t i = 0u; i < n; ++i)
    {
		param_prop *p = param_get_by_idx(i);
		if (p)
		{
			memset(param_buff, 0, sizeof(param_buff));
			param_get_value(p, &param_buff[16]);
			strncpy((char *)param_buff, p->name, 16);
            *chksum = 0;
            for (int j = 0; j < 20;++j)
            {
                *chksum += param_buff[j];
            }
            if (!param_NVRAM_write(i * sizeof(param_buff), param_buff, sizeof(param_buff)))
            {
                goto onError;
            }
		}
		else
		{
			goto onError;
		}
	}

	return true;
onError:
	return false;
}

bool param_save(int16_t i, param_prop *p)
{
	uint16_t n = param_get_count();
	uint8_t param_buff[24];
    uint32_t *chksum;
    chksum = &param_buff[20];
	if (i >= 0 && i < n && p)
	{
			memset(param_buff, 0, sizeof(param_buff));
			param_get_value(p, &param_buff[16]);
			strncpy((char *)param_buff, p->name, 16);
            *chksum = 0;
            for (int j = 0; j < 20;++j)
            {
                *chksum += param_buff[j];
            }
			if (!param_NVRAM_write(i * sizeof(param_buff), param_buff, sizeof(param_buff)))
			{
				goto onError;
			}
	}

	return true;
onError:
	return false;

}

bool restore_param(void)
{
	uint16_t n = param_get_count();
	uint8_t param_buff[24];
    uint32_t *chksum;
    chksum = &param_buff[20];
	for (uint16_t i = 0u; i < n; ++i)
	{
		param_prop *p = param_get_by_idx(i);
		if (p)
		{
			if (param_NVRAM_read(i * sizeof(param_buff), param_buff, sizeof(param_buff)))
			{
				if (strncmp(p->name, (char *)param_buff, 16) == 0)
				{
            uint32_t chksum2 = 0;
            for (int j = 0; j < 20;++j)
            {
                chksum2 += param_buff[j];
            }
            if (*chksum == chksum2)
            {
				    if (strncmp(p->name, "ap_ver", 6) == 0)
                    {
                        if (*(p->val_ptr.I) != *((uint32_t *)&param_buff[16]))
                        {
					        goto onError;
                        }
                        else
                        {
                            break;
                        }
                    }

            }
            else
            {
					goto onError;
            }
				}
				else
				{
					goto onError;
				}
			}
			else
			{
				goto onError;
			}
		}
		else
		{
			goto onError;
		}
	}

	for (uint16_t i = 0u; i < n; ++i)
	{
		param_prop *p = param_get_by_idx(i);
		if (p)
		{
			if (param_NVRAM_read(i * sizeof(param_buff), param_buff, sizeof(param_buff)))
			{
				if (strncmp(p->name, (char *)param_buff, 16) == 0)
				{
            uint32_t chksum2 = 0;
            for (int j = 0; j < 20;++j)
            {
                chksum2 += param_buff[j];
            }
            if (*chksum == chksum2)
            {
					param_set_value(p, &param_buff[16]);
            }
            else
            {
					goto onError;
            }
				}
				else
				{
					goto onError;
				}
			}
			else
			{
				goto onError;
			}
		}
		else
		{
			goto onError;
		}
	}

	return true;
onError:
	return false;
}


void scan_params(void)
{
    const rtwCAPI_ModelMappingStaticInfo* sm;
    unsigned int m;
    rtwCAPI_ModelParameters const *prm;
    rtwCAPI_DataTypeMap   const   *dtm;
    rtwCAPI_DimensionMap  const   *dmm;
    uint_T                const   *dam;
    rtwCAPI_ModelMappingInfo *MMI;
    void** da;
    unsigned int i;
    const char * name;
    int idx;
    uint16_t dti;
    uint16_t dmi;
    uint8_t ss;
    uint_T dai;
    uint8_t nd;
    uint_T n;
    uint16_t j;
    size_t s1,s2;
    int k;
    char idx_buff[8];
    param_prop prop;

    static int is_init=0;

    if (is_init)
    {
        return;
    }
    is_init = 1;

    sm =  ap_GetCAPIStaticMap_fcn();
    if (sm)
    {
        prop.getter_ptr = NULL;
        prop.setter_ptr = NULL;
        //n = rtwCAPI_GetNumBlockParametersFromStaticMap(sm);
        m = rtwCAPI_GetNumModelParametersFromStaticMap(sm);
        prm = rtwCAPI_GetModelParametersFromStaticMap(sm);
        dtm = rtwCAPI_GetDataTypeMapFromStaticMap(sm);
        dmm = rtwCAPI_GetDimensionMapFromStaticMap(sm);
        dam = rtwCAPI_GetDimensionArrayFromStaticMap(sm);
        MMI = &(rtmGetDataMapInfo(ap_M_ptr).mmi);
        da = rtwCAPI_GetDataAddressMap(MMI);
        for (i = 0;i<m; ++i)
        {
            name = rtwCAPI_GetModelParameterName(prm, i);
            idx = rtwCAPI_GetModelParameterAddrIdx(prm, i);
            dti = rtwCAPI_GetModelParameterDataTypeIdx(prm, i);
            dmi = rtwCAPI_GetModelParameterDimensionIdx(prm, i);
            ss = rtwCAPI_GetDataTypeSLId(dtm, dti);
            dai = rtwCAPI_GetDimArrayIndex(dmm, dmi);
            nd = rtwCAPI_GetNumDims(dmm, dmi);
            n = 1;
            for (j=0u;j<nd;++j)
            {
                n *= dam[dai+j];
            }
            for (j=0;j<n;++j)
            {
                switch (ss)
                {
                case SS_DOUBLE:
                {
                    prop.val_ptr.d = &((double *)da[idx])[j];
                    prop.typ = PARAM_TYPE_REAL64;
                }
                    break;
                case SS_INT8:
                case SS_BOOLEAN:
                {
                    prop.val_ptr.b = &((int8_t *)da[idx])[j];
                    prop.typ = PARAM_TYPE_INT8;
                }
                    break;
                case SS_INT16:
                {
                    prop.val_ptr.h = &((int16_t *)da[idx])[j];
                    prop.typ = PARAM_TYPE_INT16;
                }
                    break;
                case SS_INT32:
                {
                    prop.val_ptr.i = &((int32_t *)da[idx])[j];
                    prop.typ = PARAM_TYPE_INT32;
                }
                    break;
                case SS_UINT8:
                {
                    prop.val_ptr.B = &((uint8_t *)da[idx])[j];
                    prop.typ = PARAM_TYPE_UINT8;
                }
                    break;
                case SS_UINT16:
                {
                    prop.val_ptr.H = &((uint16_t *)da[idx])[j];
                    prop.typ = PARAM_TYPE_UINT16;
                }
                    break;
                case SS_UINT32:
                {
                    prop.val_ptr.I = &((uint32_t *)da[idx])[j];
                    prop.typ = PARAM_TYPE_UINT32;
                }
                    break;
                default:
                {
                    prop.val_ptr.s = &((float *)da[idx])[j];
                    prop.typ = PARAM_TYPE_REAL32;
                }
                    break;
                }
                strncpy(prop.name, name, 16);
                if (j > 0)
                {
                  sprintf(idx_buff, "(%d)", j);
                  s2 = strlen(idx_buff);
                  s1 = strlen(prop.name);
                  if (s1+s2 >= 16)
                  {
                      for (k=0;k<s2;++k)
                      {
                          prop.name[16-s2+k] = idx_buff[k];
                      }
                  }
                  else
                  {
                      for (k=0;k<s2;++k)
                      {
                          prop.name[s1+k] = idx_buff[k];
                      }
                      prop.name[s1+k] = '\0';
                  }
                }
                if (prop.typ != PARAM_TYPE_REAL64)
                param_mgr_regist(&prop);
            }
        }
    }
}