/*
    Copyright (C) 2012 Modelon AB

    This program is free software: you can redistribute it and/or modify
    it under the terms of the BSD style license.

     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
    FMILIB_License.txt file for more details.

    You should have received a copy of the FMILIB_License.txt file
    along with this program. If not, contact Modelon AB <http://www.modelon.com>.
*/
#include <assert.h>
#include <stdio.h>

#include <FMI2/fmi2_functions.h>
#include <FMI2/fmi2_enums.h>

const char* fmi2_naming_convention_to_string(fmi2_variable_naming_convension_enu_t convention) {
    if(convention == fmi2_naming_enu_flat) return "flat";
    if(convention == fmi2_naming_enu_structured) return "structured";
    return "Unknown";
}

const char* fmi2_fmu_kind_to_string(fmi2_fmu_kind_enu_t kind) {
    switch (kind) {
    case fmi2_fmu_kind_me: return "ModelExchange";
    case fmi2_fmu_kind_cs: return "CoSimulation";
    case fmi2_fmu_kind_me_and_cs: return "ModelExchange and CoSimulation";
	default: break;
    }
    return "Unknown";
}

const char* fmi2_dependency_factor_kind_to_string(fmi2_dependency_factor_kind_enu_t fc) {
	switch(fc) {
	case fmi2_dependency_factor_kind_dependent: return "dependent";
	case fmi2_dependency_factor_kind_constant: return "constant";
	case fmi2_dependency_factor_kind_fixed: return "fixed";
	case fmi2_dependency_factor_kind_tunable: return "tunable";
	case fmi2_dependency_factor_kind_discrete: return "discrete";
	default:break;
	}
	return "illegal factor kind";
}

const char* fmi2_variability_to_string(fmi2_variability_enu_t v) {
    switch(v) {
    case fmi2_variability_enu_constant: return "constant";
    case fmi2_variability_enu_fixed: return "fixed";
    case fmi2_variability_enu_tunable: return "tunable";
    case fmi2_variability_enu_discrete: return "discrete";
    case fmi2_variability_enu_continuous: return "continuous";
	default: break;
    }
    return "Unknown";
}

const char* fmi2_causality_to_string(fmi2_causality_enu_t c) {
    switch(c) {
    case fmi2_causality_enu_input: return "input";
    case fmi2_causality_enu_output: return "output";
    case fmi2_causality_enu_parameter: return "parameter";
    case fmi2_causality_enu_calculated_parameter: return "calculatedParameter";
    case fmi2_causality_enu_local: return "local";
    case fmi2_causality_enu_independent: return "independent";
	default: break;
    };
    return "Unknown";
}

const char* fmi2_status_to_string(fmi2_status_t status) {
	switch(status) {
	case fmi2_status_ok:
		return "OK";
	case fmi2_status_warning:
		return "Warning";
	case fmi2_status_discard:
		return "Discard";
	case fmi2_status_error:
		return "Error";
	case fmi2_status_fatal:
		return "Fatal";
	case fmi2_status_pending:
		return "Pending";
	default: break;
	}
	return "Undefined";
}

const char* fmi2_base_type_to_string(fmi2_base_type_enu_t bt) {
    switch(bt) {
    case fmi2_base_type_real: return "Real";
    case fmi2_base_type_int: return "Integer";
    case fmi2_base_type_bool: return "Boolean";
    case fmi2_base_type_str: return "String";
    case fmi2_base_type_enum: return "Enumeration";
	default: break;
    }
    return "Error";
}

const char* fmi2_initial_to_string(fmi2_initial_enu_t ini) {
	switch (ini) {
	case fmi2_initial_enu_exact: return "exact";
	case fmi2_initial_enu_approx: return "approx";
	case fmi2_initial_enu_calculated: return "calculated";
		default: break;
	}
	return "Undefined";
}

fmi2_initial_enu_t initialDefaultsTable[fmi2_variability_enu_unknown][fmi2_causality_enu_unknown] = {
	/*              parameter                  calculated parameter,        input                     output                       local                        independent */
	/* constant */  {fmi2_initial_enu_unknown, fmi2_initial_enu_unknown,    fmi2_initial_enu_unknown, fmi2_initial_enu_exact,      fmi2_initial_enu_exact,      fmi2_initial_enu_unknown},
	/* fixed   */   {fmi2_initial_enu_exact,   fmi2_initial_enu_calculated, fmi2_initial_enu_approx,  fmi2_initial_enu_calculated, fmi2_initial_enu_calculated, fmi2_initial_enu_unknown},
	/* tunable */   {fmi2_initial_enu_exact,   fmi2_initial_enu_calculated, fmi2_initial_enu_approx,  fmi2_initial_enu_calculated, fmi2_initial_enu_calculated, fmi2_initial_enu_unknown},
	/* discrete */  {fmi2_initial_enu_unknown, fmi2_initial_enu_unknown,    fmi2_initial_enu_approx,  fmi2_initial_enu_calculated, fmi2_initial_enu_calculated, fmi2_initial_enu_unknown},
	/* continuous */{fmi2_initial_enu_unknown, fmi2_initial_enu_unknown,    fmi2_initial_enu_approx,  fmi2_initial_enu_calculated, fmi2_initial_enu_calculated, fmi2_initial_enu_calculated}
};

fmi2_initial_enu_t fmi2_get_default_initial(fmi2_variability_enu_t v, fmi2_causality_enu_t c) {
	if((unsigned)v >= (unsigned)fmi2_variability_enu_unknown) return fmi2_initial_enu_unknown;
	if((unsigned)c >= (unsigned)fmi2_causality_enu_unknown) return fmi2_initial_enu_unknown;
	return initialDefaultsTable[v][c];
}

FMILIB_EXPORT fmi2_initial_enu_t fmi2_get_valid_initial(fmi2_variability_enu_t v, fmi2_causality_enu_t c, fmi2_initial_enu_t i) {
	fmi2_initial_enu_t defaultInitial = fmi2_get_default_initial(v, c);
	if( (defaultInitial == i) ||
		((unsigned)i >= (unsigned)fmi2_initial_enu_unknown) ||
		(defaultInitial == fmi2_initial_enu_unknown))
		return defaultInitial;
	/*  At this point we know that v, c & i are fine and that (defaultInitial != i) 
		Check the other allowed combinations: */
	if(defaultInitial == fmi2_initial_enu_calculated) {
		if(v >= fmi2_variability_enu_discrete) {
			return i;
		}
		else if(i != fmi2_initial_enu_exact)
			return i;
	}
	/* in all other cases the combination is not valid and default should be used */
	return defaultInitial;
}


const char * fmi2_capability_to_string(fmi2_capabilities_enu_t id) {
#define FMI2_ME_CAPABILITIES_ENU_TO_STR(c) case fmi2_me_ ## c: return "me_"#c;
#define FMI2_CS_CAPABILITIES_ENU_TO_STR(c) case fmi2_cs_ ## c: return "cs_"#c;
	switch (id) {
	FMI2_ME_CAPABILITIES(FMI2_ME_CAPABILITIES_ENU_TO_STR)
	FMI2_CS_CAPABILITIES(FMI2_CS_CAPABILITIES_ENU_TO_STR)
	default: break;
	}
	return "Unknown";
}

const char * fmi2_SI_base_unit_to_string(fmi2_SI_base_units_enu_t id) {
#define FMI2_SI_BASE_UNIT_ENU_TO_STR(c) case fmi2_SI_base_unit_ ## c: return #c;
	switch(id) {
		FMI2_SI_BASE_UNITS(FMI2_SI_BASE_UNIT_ENU_TO_STR)
	default: break;
	}
	return "unknown";
}

/** \brief Convert a list of SI base unit exponents (corresponding to the IDs from  fmi2_SI_base_units_enu_t)
	to a string of the form kg*m^2/s^2.

	\param exp An array of SI base units exponents.
	\param bufSize Size of the buffer to store the string. 
	\param buf Buffer to store the string
	\return Required size of the buffer to store the string including the terminating zero.
		This most likely be under [8*fmi2_SI_base_units_Num]. If the return value is larger or equal 
		than bufSize than the string could not be fitted in the buffer. 
*/
size_t fmi2_SI_base_unit_exp_to_string(const int exp[fmi2_SI_base_units_Num], size_t bufSize, char buf[]){
	int i = 0;
	int num_pos_exp = 0, num_neg_exp = 0; /* number of exponents */
	size_t len = 0;
	char tmp[fmi2_SI_base_units_Num * 20]; /* tmp is always enough size */
	if(bufSize) buf[0] = 0; /* just to prevent errors */

	/* count the exponents */
	for(i = 0; i < fmi2_SI_base_units_Num; i++) {
		if(exp[i] == 0) continue;
		if(exp[i] < 0) 
			num_neg_exp ++;
		else
			num_pos_exp ++;
	}
	if((num_neg_exp + num_pos_exp) == 0) { /* return "-" */ 
		 if (bufSize < 2) return 2;
		 buf[0] = '-';
		 buf[1] = 0;
		 return 2;
	}
	if(num_pos_exp == 0) {
		/* we start with "one over", i.e., 1 */
		tmp[0] = '1';
		len = 1;
	}
	else {
		len = 0;
		/* print positive exp */
		for(i = 0; i < fmi2_SI_base_units_Num; i++) {
			char* curp = tmp + len;
			int expi = exp[i];
			if(expi <= 0)  continue;
			if(len) {
				*curp = '*';
				curp++; len++;
			}

			strcpy(curp, fmi2_SI_base_unit_to_string((fmi2_SI_base_units_enu_t)i)) ;
			len += strlen(curp);
			curp = tmp + len;

			if(expi > 1) {
				*curp = '^';
				curp++; len++;

				sprintf(curp, "%d", expi); /*safe */
				len += strlen(curp);
			}
		}
	}
	/* print negative exp */
	if(num_neg_exp > 0) {
		tmp[len++] = '/';
		if(num_neg_exp > 1)
			tmp[len++] = '(';
		num_neg_exp = 0;

		for(i = 0; i < fmi2_SI_base_units_Num; i++) {
			char* curp = tmp + len;
			int expi = exp[i];
			if(expi >= 0)  continue;
			expi = -expi;
			if(num_neg_exp > 0) {
				*curp = '*';
				curp++; len++;
			}
			num_neg_exp++;
			strcpy(curp, fmi2_SI_base_unit_to_string((fmi2_SI_base_units_enu_t)i)) ;
			len += strlen(curp);
			curp = tmp + len;

			if(expi > 1) {
				*curp = '^';
				curp++; len++;

				sprintf(curp, "%d", expi); /*safe */
				len += strlen(curp);
			}
		}
		if(num_neg_exp > 1)
			tmp[len++] = ')';
	}
	strncpy(buf, tmp, bufSize);
    if(len < bufSize) buf[len] = 0;
	return len + 1;
}