/******************************************************************************
 *
 *  $Id: $
 *
 * -- Copyright Notice --
 *
 * Copyright (c) 2004 Asahi Kasei Microdevices Corporation, Japan
 * All Rights Reserved.
 *
 * This software program is the proprietary program of Asahi Kasei Microdevices
 * Corporation("AKM") licensed to authorized Licensee under the respective
 * agreement between the Licensee and AKM only for use with AKM's electronic
 * compass IC.
 *
 * THIS SOFTWARE IS PROVIDED TO YOU "AS IS", WITHOUT WARRANTY OF ANY KIND,
 * EXPRESS OR IMPLIED INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 * MERCHANTABLITY, FITNESS FOR A PARTICULAR PURPOSE AND NON INFRINGEMENT OF
 * THIRD PARTY RIGHTS, AND WE SHALL NOT BE LIABLE FOR ANY LOSSES AND DAMAGES
 * WHICH MAY OCCUR THROUGH USE OF THIS SOFTWARE.
 *
 * -- End Asahi Kasei Microdevices Copyright Notice --
 *
 ******************************************************************************/
#include "FileIO.h"
#include <sys/stat.h>

#define AKM_PERM (S_IRUSR|S_IWUSR|S_IRGRP|S_IWGRP)

/*!
 Load parameters from file which is specified with #CSPEC_SETTING_FILE.
 This function reads data from a beginning of the file line by line, and
 check parameter name sequentially. In otherword, this function depends on
 the order of eache parameter described in the file.
 @return If function fails, the return value is 0. When function fails, the
 output is undefined. Therefore, parameters which are possibly overwritten
 by this function should be initialized again. If function succeeds, the
 return value is 1.
 @param[out] prms A pointer to #AKSCPRMS structure. Loaded parameter is
 stored to the member of this structure.
 */
int16 LoadParameters(AKSCPRMS * prms)
{
	int16	i, j, ret;
	int		tmp;
	double	dtmp;
	FILE	*fp = NULL;
	char	keyName[KEYNAME_SIZE];

	//Open setting file for read.
	if ((fp = fopen(CSPEC_SETTING_FILE, "r")) == NULL) {
		AKMERROR_STR("fopen");
		return 0;
	}

	ret = 1;

	// Load data to HDST, HO, HREF, THRE
	for (i = 0; i < CSPEC_NUM_FORMATION; i++) {
		snprintf(keyName, sizeof(keyName), "HSUC_HDST_FORM%d", i);
		tmp = 0;
		ret = ret && LoadInt(fp, keyName, &tmp);
		prms->HSUC_HDST[i] = (AKSC_HDST)tmp;

		snprintf(keyName, sizeof(keyName), "HSUC_HO_FORM%d", i);
		ret = ret && LoadInt16vec(fp, keyName, &prms->HSUC_HO[i]);

		snprintf(keyName, sizeof(keyName), "HFLUCV_HREF_FORM%d", i);
		ret = ret && LoadInt16vec(fp, keyName, &prms->HFLUCV_HREF[i]);

		snprintf(keyName, sizeof(keyName), "HSUC_HBASE_FORM%d", i);
		ret = ret && LoadInt32vec(fp, keyName, &prms->HSUC_HBASE[i]);

		for (j = 0; j < AKSC_DOEP_SIZE; j++) {
			snprintf(keyName, sizeof(keyName), "DOEP_PRMS_FORM%d[%d]", i, j);
			ret = ret && LoadDouble(fp, keyName, &dtmp);
			prms->DOEP_PRMS[i][j] = (AKSC_FLOAT)dtmp;
		}
	}

	// Offset of other sensors.
	ret = ret && LoadInt16vec(fp, "AO", &prms->m_AO);

	if (fclose(fp) != 0) {
		AKMERROR_STR("fclose");
		ret = 0;
	}

	if (ret == 0) {
		AKMERROR;
	}
	return ret;
}

/*! Load PDC from file named with #SETTING_PDC_FILE_NAME.
  This function reads parameters from a beginning of the file line by line,
  and check parameter name sequentially.

  @return When function fails, the return value is 0. In that case, all
  related parameters, i.e. m_pdc and m_pdcptr, are initialized with 0.
*/
int16 LoadPDC(AKSCPRMS* prms)
{
	int16   ret, i;
	FILE*   fp;
	char    keyName[KEYNAME_SIZE];
	char    header[HEADER_SIZE];
	int		tmp;

	ret = 1;

	//Open setting file for read.
	if((fp = fopen(CSPEC_PDC_FILE, "r")) == NULL){
		//AKMERROR_STR("fopen");
		goto PDCREAD_FAILED;
	}

	//Read file header
	if(fgets(header, sizeof(header), fp) == NULL){
		//AKMERROR_STR("fgets");
		fclose(fp);
		goto PDCREAD_FAILED;
	}

	//Set loaded data to pdc.
	for (i = 0; i<PDC_SIZE; i++) {
		snprintf(keyName, sizeof(keyName), "HPRMS%d", i);
		tmp = 0;
		ret = ret && LoadInt(fp, keyName, &tmp);
		prms->m_pdc[i] = (uint8)tmp;
	}

	if (fclose(fp) != 0) {
		AKMERROR_STR("fclose");
		goto PDCREAD_FAILED;
	}

	if(ret != 1){
		AKMERROR;
		goto PDCREAD_FAILED;
	}

	// Set parameter's pointer.
	prms->m_pdcptr = prms->m_pdc;

	
	ALOGE("AK09911 pdc.txt Parameter loaded: %s\n", header);

	return  1;

PDCREAD_FAILED:
	memset(prms->m_pdc, 0, sizeof(prms->m_pdc));
	prms->m_pdcptr = 0;

	return 0;
}

/*!
 Load \c int type value from file. The name of parameter is specified with
 \a lpKeyName. If the name matches the beginning of read line, the string
 after #DELIMITER will converted to \c int type value.
 @return If function fails, the return value is 0. When function fails, the
 value @ val is not overwritten. If function succeeds, the return value is 1.
 @param[in] fp Pointer to \c FILE structure.
 @param[in] lpKeyName The name of parameter.
 @param[out] val Pointer to \c int type value. Upon successful completion
 of this function, read value is copied to this variable.
 */
int16 LoadInt(FILE * fp, const char *lpKeyName, int *val)
{
	char buf[KEYNAME_SIZE] = { '\0' };

	// ATTENTION! %ns should be modified according to the size of buf.
	if (fscanf(fp, "%63s" DELIMITER "%11d", buf, val) != 2) {
		AKMERROR;
		return 0;
	}
	// Compare the read parameter name with given name.
	if (strncmp(buf, lpKeyName, sizeof(buf)) != 0) {
		ALOGE("%s: strncmp (%s) error.", __FUNCTION__, lpKeyName);
		return 0;
	}

	return 1;
}

/*!
 Load \c int type value from file. The name of parameter is specified with
 \a lpKeyName. If the name matches the beginning of read line, the string
 after #DELIMITER will converted to \c int type value.
 @return If function fails, the return value is 0. When function fails, the
 value @ val is not overwritten. If function succeeds, the return value is 1.
 @param[in] fp Pointer to \c FILE structure.
 @param[in] lpKeyName The name of parameter.
 @param[out] val Pointer to \c double type value. Upon successful completion
 of this function, read value is copied to this variable.
 */
int16 LoadDouble(FILE * fp, const char *lpKeyName, double *val)
{
	char buf[KEYNAME_SIZE] = { '\0' };

	// ATTENTION! %ns should be modified according to the size of buf.
	if (fscanf(fp, "%63s" DELIMITER "%20lf", buf, val) != 2) {
		AKMERROR;
		return 0;
	}
	// Compare the read parameter name with given name.
	if (strncmp(buf, lpKeyName, sizeof(buf)) != 0) {
		ALOGE("%s: strncmp (%s) error.", __FUNCTION__, lpKeyName);
		return 0;
	}

	return 1;
}

/*!
 Load \c int16vec type value from file and convert it to int16vec type
 structure. This function adds ".x", ".y" and ".z" to the last of parameter
 name and try to read value with combined name.
 @return If function fails, the return value is 0. When function fails, the
 output is undefined. If function succeeds, the return value is 1.
 @param[in] fp A opened \c FILE pointer.
 @param[in] lpKeyName The parameter name.
 @param[out] vec A pointer to int16vec structure. Upon successful completion
 of this function, read values are copied to this variable.
 */
int16 LoadInt16vec(FILE * fp, const char *lpKeyName, int16vec * vec)
{
	char	keyName[KEYNAME_SIZE];
	int16	ret = 1;
	int		tmp;

	snprintf(keyName, sizeof(keyName), "%s.x", lpKeyName);
	ret = ret && LoadInt(fp, keyName, &tmp);
	vec->u.x = (int16)tmp;

	snprintf(keyName, sizeof(keyName), "%s.y", lpKeyName);
	ret = ret && LoadInt(fp, keyName, &tmp);
	vec->u.y = (int16)tmp;

	snprintf(keyName, sizeof(keyName), "%s.z", lpKeyName);
	ret = ret && LoadInt(fp, keyName, &tmp);
	vec->u.z = (int16)tmp;

	return ret;
}

/*!
 Load \c int32vec type value from file and convert it to int32vec type
 structure. This function adds ".x", ".y" and ".z" to the last of parameter
 name and try to read value with combined name.
 @return If function fails, the return value is 0. When function fails, the
 output is undefined. If function succeeds, the return value is 1.
 @param[in] fp A opened \c FILE pointer.
 @param[in] lpKeyName The parameter name.
 @param[out] vec A pointer to int32vec structure. Upon successful completion
 of this function, read values are copied to this variable.
 */
int16 LoadInt32vec(FILE * fp, const char *lpKeyName, int32vec * vec)
{
	char	keyName[KEYNAME_SIZE];
	int16	ret = 1;
	int		tmp;

	snprintf(keyName, sizeof(keyName), "%s.x", lpKeyName);
	ret = ret && LoadInt(fp, keyName, &tmp);
	vec->u.x = (int32)tmp;

	snprintf(keyName, sizeof(keyName), "%s.y", lpKeyName);
	ret = ret && LoadInt(fp, keyName, &tmp);
	vec->u.y = (int32)tmp;

	snprintf(keyName, sizeof(keyName), "%s.z", lpKeyName);
	ret = ret && LoadInt(fp, keyName, &tmp);
	vec->u.z = (int32)tmp;

	return ret;
}


/*!
 Save parameters to file which is specified with #CSPEC_SETTING_FILE. This
 function saves variables when the offsets of magnetic sensor estimated
 successfully.
 @return If function fails, the return value is 0. When function fails, the
 parameter file may collapsed. Therefore, the parameters file should be
 discarded. If function succeeds, the return value is 1.
 @param[out] prms A pointer to #AKSCPRMS structure. Member variables are
 saved to the parameter file.
 */
int16 SaveParameters(AKSCPRMS * prms)
{
	int16	ret = 1;
	int16	i, j;
	FILE	*fp;
	char	keyName[KEYNAME_SIZE];

	//Open setting file for write.
	if ((fp = fopen(CSPEC_SETTING_FILE, "w")) == NULL) {
		AKMERROR_STR("fopen");
		return 0;
	}

	for (i = 0; i < CSPEC_NUM_FORMATION; i++) {
		snprintf(keyName, sizeof(keyName), "HSUC_HDST_FORM%d", i);
		ret = ret && SaveInt(fp, keyName, (int)prms->HSUC_HDST[i]);

		snprintf(keyName, sizeof(keyName), "HSUC_HO_FORM%d", i);
		ret = ret && SaveInt16vec(fp, keyName, &prms->HSUC_HO[i]);

		snprintf(keyName, sizeof(keyName), "HFLUCV_HREF_FORM%d", i);
		ret = ret && SaveInt16vec(fp, keyName, &prms->HFLUCV_HREF[i]);

		snprintf(keyName, sizeof(keyName), "HSUC_HBASE_FORM%d", i);
		ret = ret && SaveInt32vec(fp, keyName, &prms->HSUC_HBASE[i]);

		for (j = 0; j < AKSC_DOEP_SIZE; j++) {
			snprintf(keyName, sizeof(keyName), "DOEP_PRMS_FORM%d[%d]", i, j);
			ret = ret && SaveDouble(fp, keyName, (double)prms->DOEP_PRMS[i][j]);
		}
	}

	// Offset of other sensors.
	ret = ret && SaveInt16vec(fp, "AO", &prms->m_AO);

	if (fclose(fp) != 0) {
		AKMERROR_STR("fclose");
		ret = 0;
	}
    if (chmod(CSPEC_SETTING_FILE, AKM_PERM) != 0) {
		AKMERROR_STR("chmod");
		ret = 0;
	}

	if (ret == 0) {
		AKMERROR;
	}

	return ret;
}

/*!
 Save parameters of int16 type structure to file. This function adds
 @return If function fails, the return value is 0. When function fails,
 parameter is not saved to file. If function succeeds, the return value is 1.
 @param[in] fp Pointer to \c FILE structure.
 @param[in] lpKeyName The name of paraemter.
 @param[in] val Pointer to \c int16 type value.
 */
int16 SaveInt(FILE * fp, const char *lpKeyName, const int val)
{
	if (fprintf(fp, "%s" DELIMITER "%d\n", lpKeyName, val) < 0) {
		ALOGE("%s: printf (%s) error.", __FUNCTION__, lpKeyName);
		return 0;
	} else {
		return 1;
	}
}

/*!
 Save parameters of AKSC_FLOAT type structure to file. This function adds
 @return If function fails, the return value is 0. When function fails,
 parameter is not saved to file. If function succeeds, the return value is 1.
 @param[in] fp Pointer to \c FILE structure.
 @param[in] lpKeyName The name of paraemter.
 @param[in] val Pointer to \c AKSC_FLOAT type value.
 */
int16 SaveDouble(FILE * fp, const char *lpKeyName, const double val)
{
	if (fprintf(fp, "%s" DELIMITER "%20.12lf\n", lpKeyName, val) < 0) {
		ALOGE("%s: printf (%s) error.", __FUNCTION__, lpKeyName);
		return 0;
	} else {
		return 1;
	}
}

/*!
 Save parameters of int16vec type structure to file. This function adds
 ".x", ".y" and ".z" to the last of parameter name and save value with
 the combined name.
 @return If function fails, the return value is 0. When function fails, not
 all parameters are saved to file, i.e. parameters file may collapsed.
 If function succeeds, the return value is 1.
 @param[in] fp Pointer to \c FILE structure.
 @param[in] lpKeyName The name of paraemter.
 @param[in] vec Pointer to \c int16vec type structure.
 */
int16 SaveInt16vec(FILE * fp, const char *lpKeyName,
				   const int16vec * vec)
{
	int16 ret = 0;
	char keyName[KEYNAME_SIZE];

	ret = 1;
	snprintf(keyName, sizeof(keyName), "%s.x", lpKeyName);
	ret = ret && SaveInt(fp, keyName, vec->u.x);

	snprintf(keyName, sizeof(keyName), "%s.y", lpKeyName);
	ret = ret && SaveInt(fp, keyName, vec->u.y);

	snprintf(keyName, sizeof(keyName), "%s.z", lpKeyName);
	ret = ret && SaveInt(fp, keyName, vec->u.z);

	return ret;
}

/*!
 Save parameters of int32vec type structure to file. This function adds
 ".x", ".y" and ".z" to the last of parameter name and save value with
 the combined name.
 @return If function fails, the return value is 0. When function fails, not
 all parameters are saved to file, i.e. parameters file may collapsed.
 If function succeeds, the return value is 1.
 @param[in] fp Pointer to \c FILE structure.
 @param[in] lpKeyName The name of paraemter.
 @param[in] vec Pointer to \c int32vec type structure.
 */
int16 SaveInt32vec(FILE * fp, const char *lpKeyName,
				   const int32vec * vec)
{
	int16 ret = 0;
	char keyName[KEYNAME_SIZE];

	ret = 1;
	snprintf(keyName, sizeof(keyName), "%s.x", lpKeyName);
	ret = ret && SaveInt(fp, keyName, vec->u.x);

	snprintf(keyName, sizeof(keyName), "%s.y", lpKeyName);
	ret = ret && SaveInt(fp, keyName, vec->u.y);

	snprintf(keyName, sizeof(keyName), "%s.z", lpKeyName);
	ret = ret && SaveInt(fp, keyName, vec->u.z);

	return ret;
}