/**
 * projectM -- Milkdrop-esque visualisation SDK
 * Copyright (C)2003-2004 projectM Team
 *
 * 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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 * See 'LICENSE.txt' included within this release
 *
 */

/* Basic Parameter Functions */

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

#include "fatal.h"
#include "Common.hpp"

#include "CustomShape.hpp"
#include "Eval.hpp"
#include "Expr.hpp"
#include "InitCond.hpp"
#include "Param.hpp"
#include "Preset.hpp"
#include <map>
#include <iostream>
#include <cassert>


/** Constructor */
Param::Param( std::string _name, short int _type, short int _flags, void * _engine_val, void * _matrix,
              CValue _default_init_val, CValue _upper_bound, CValue _lower_bound)
  : name(_name),
    type(_type),
    flags (_flags),
    matrix_flag (0),
    engine_val(_engine_val),
    matrix (_matrix),
    default_init_val (_default_init_val),
    upper_bound (_upper_bound),
    lower_bound (_lower_bound)
{

}


/* Creates a user defined parameter */
Param::Param(std::string _name)
  : name(_name),
    type(P_TYPE_DOUBLE),
    flags(P_FLAG_USERDEF),
    matrix_flag(0),
    matrix(0)
{
  engine_val = new float();

  default_init_val.float_val = DEFAULT_DOUBLE_IV;
  upper_bound.float_val = DEFAULT_DOUBLE_UB;
  lower_bound.float_val = DEFAULT_DOUBLE_LB;

  /// @note may have fixed a recent bug. testing
  *((float*)engine_val) = default_init_val.float_val;
}

/* Free's a parameter type */
Param::~Param()
{
  // I hate this, but will let it be for now
  if (flags & P_FLAG_USERDEF) {
    delete((double*)engine_val);
  }

  if (PARAM_DEBUG) printf("~Param: freeing \"%s\".\n", name.c_str());
}


/* Returns nonzero if the string is valid parameter name */
bool
Param::is_valid_param_string( const char * string )
{

  if (string == NULL)
    return false;

  /* This ensures the first character is non numeric */
  if ( ((*string) >= 48) && ((*string) <= 57))
    return false;

  /* These probably should never happen */
  if (*string == '.')
    return false;

  if (*string == '+')
    return false;

  if (*string == '-')
    return false;

  /* Could also add checks for other symbols. May do later */

  return true;
}


/* Loads a float parameter into the builtin database */
Param *
Param::new_param_float (
const char  * name,
short int   flags,
void        * engine_val,
void        * matrix,
float       upper_bound,
float       lower_bound,
float       init_val
)
{
  Param   * param;
  CValue  iv, ub, lb;
  assert(engine_val);

  iv.float_val = init_val;
  ub.float_val = upper_bound;
  lb.float_val = lower_bound;

  if ((param = new Param(name, P_TYPE_DOUBLE, flags, engine_val, matrix,iv, ub, lb)) == NULL)
    return NULL;


  /* Finished, return success */
  return param;
}

/* Creates a new parameter of type int */
Param *
Param::new_param_int (
const char  * name,
short int   flags,
void        * engine_val,
int         upper_bound,
int         lower_bound,
int         init_val
)
{
  Param   * param;
  CValue  iv, ub, lb;
  assert(engine_val);

  iv.int_val = init_val;
  ub.int_val = upper_bound;
  lb.int_val = lower_bound;

  if ((param = new Param(name, P_TYPE_INT, flags, engine_val, NULL, iv, ub, lb)) == NULL)
    return NULL;


  /* Finished, return success */
  return param;
}

/* Creates a new parameter of type bool */
Param *
Param::new_param_bool (
const char  * name,
short int   flags,
void        * engine_val,
bool        upper_bound,
bool        lower_bound,
bool        init_val
)
{
  Param   * param;
  CValue  iv, ub, lb;
  assert(engine_val);

  iv.bool_val = init_val;
  ub.bool_val = upper_bound;
  lb.bool_val = lower_bound;

  if ((param = new Param(name, P_TYPE_BOOL, flags, engine_val, NULL, iv, ub, lb)) == NULL)
    return NULL;


  /* Finished, return success */
  return param;
}

/* Creates a new parameter of type string */
Param *
Param::new_param_string (const char * name, short int flags, void * engine_val)
{
  Param   * param;
  CValue  iv, ub, lb;
  assert(engine_val);

  iv.bool_val = 0;
  ub.bool_val = 0;
  lb.bool_val = 0;

  if ((param = new Param(name, P_TYPE_STRING, flags, engine_val, NULL, iv, ub, lb)) == NULL)
    return NULL;


  /* Finished, return success */
  return param;
}