/**
 * 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
 *
 */

#include "wipemalloc.h"

#include "Expr.hpp"
#include <cassert>

#include <iostream>
#include "Eval.hpp"


float
GenExpr::eval_gen_expr ( int mesh_i, int mesh_j )
{
  float l;

  assert ( item );
  switch ( this->type )
  {
  case VAL_T:
    return ( ( ValExpr* ) item )->eval_val_expr ( mesh_i, mesh_j );
  case PREFUN_T:
    l = ( ( PrefunExpr * ) item )->eval_prefun_expr ( mesh_i, mesh_j );
    //if (EVAL_DEBUG) DWRITE( "eval_gen_expr: prefix function return value: %f\n", l);
    return l;
  case TREE_T:
    return ( ( TreeExpr* ) ( item ) )->eval_tree_expr ( mesh_i, mesh_j );
  default:
    return EVAL_ERROR;
  }
}

/* Evaluates functions in prefix form */
float
PrefunExpr::eval_prefun_expr ( int mesh_i, int mesh_j )
{
  assert ( func_ptr );

  float * arg_list = new float[this->num_args];

  assert(arg_list);

  //printf("numargs %d", num_args);

  /* Evaluate each argument before calling the function itself */
  for ( int i = 0; i < num_args; i++ )
  {
    arg_list[i] = expr_list[i]->eval_gen_expr ( mesh_i, mesh_j );
    //printf("numargs %x", arg_list[i]);
  }
  /* Now we call the function, passing a list of
     floats as its argument */

  const float value = ( func_ptr ) ( arg_list );

  delete[](arg_list);
  return value;
}


/* Evaluates a value expression */
float
ValExpr::eval_val_expr ( int mesh_i, int mesh_j )
{
  /* Value is a constant, return the float value */
  if ( type == CONSTANT_TERM_T )
  {
    return ( term.constant );
  }

  /* Value is variable, dereference it */
  if ( type == PARAM_TERM_T )
  {
    switch ( term.param->type )
    {
    case P_TYPE_BOOL:
      return ( float ) ( * ( ( bool* ) ( term.param->engine_val ) ) );

    case P_TYPE_INT:
      return ( float ) ( * ( ( int* ) ( term.param->engine_val ) ) );

    case P_TYPE_DOUBLE:
      if ( term.param->matrix_flag | ( term.param->flags & P_FLAG_ALWAYS_MATRIX ) )
      {
        /* Sanity check the matrix is there... */
        assert ( term.param->matrix != NULL );

        /// @slow boolean check could be expensive in this critical (and common) step of evaluation
        if ( mesh_i >= 0 )
        {
          if ( mesh_j >= 0 )
          {
            return ( ( ( float** ) term.param->matrix ) [mesh_i][mesh_j] );
          }
          else
          {
            return ( ( ( float* ) term.param->matrix ) [mesh_i] );
          }
        }
        //assert(mesh_i >=0);
      }
      //std::cout << term.param->name << ": " << (*((float*)term.param->engine_val)) << std::endl;
      return * ( ( float* ) ( term.param->engine_val ) );

    default:
      return EVAL_ERROR;
    }
  }
  /* Unknown type, return failure */
  return PROJECTM_FAILURE;
}

/* Evaluates an expression tree */
float
TreeExpr::eval_tree_expr ( int mesh_i, int mesh_j )
{

  float left_arg, right_arg;

  /* A leaf node, evaluate the general expression. If the expression is null as well, return zero */
  if ( infix_op == NULL )
  {
    if ( gen_expr == NULL )
      return 0;
    else
      return gen_expr->eval_gen_expr ( mesh_i, mesh_j );
  }

  /* Otherwise, this node is an infix operator. Evaluate
     accordingly */

  assert(left);
  left_arg = left->eval_tree_expr ( mesh_i, mesh_j );

  assert(right);
  right_arg = right->eval_tree_expr ( mesh_i, mesh_j );


  switch ( infix_op->type )
  {
  case INFIX_ADD:
    return ( left_arg + right_arg );
  case INFIX_MINUS:
    return ( left_arg - right_arg );
  case INFIX_MULT:
    return ( left_arg * right_arg );
  case INFIX_MOD:
    if ( ( int ) right_arg == 0 )
    {
      return PROJECTM_DIV_BY_ZERO;
    }
    return ( ( int ) left_arg % ( int ) right_arg );
  case INFIX_OR:
    return ( ( int ) left_arg | ( int ) right_arg );
  case INFIX_AND:
    return ( ( int ) left_arg & ( int ) right_arg );
  case INFIX_DIV:
    if ( right_arg == 0 )
    {
      return MAX_DOUBLE_SIZE;
    }
    return ( left_arg / right_arg );
  default:
    return EVAL_ERROR;
  }

  return EVAL_ERROR;
}

/* Converts a float value to a general expression */
GenExpr *
GenExpr::const_to_expr ( float val )
{

  GenExpr * gen_expr;
  ValExpr * val_expr;
  Term term;

  term.constant = val;

  if ( ( val_expr = new ValExpr ( CONSTANT_TERM_T, &term ) ) == NULL )
    return NULL;

  gen_expr = new GenExpr ( VAL_T, ( void* ) val_expr );

  if ( gen_expr == NULL )
  {
    delete val_expr;
  }

  return gen_expr;
}

/* Converts a regular parameter to an expression */
GenExpr *
GenExpr::param_to_expr ( Param * param )
{

  GenExpr * gen_expr = NULL;
  ValExpr * val_expr = NULL;
  Term term;

  if ( param == NULL )
    return NULL;

  /* This code is still a work in progress. We need
     to figure out if the initial condition is used for
     each per frame equation or not. I am guessing that
     it isn't, and it is thusly implemented this way */

  /* Current guess of true behavior (08/01/03) note from carm
     First try to use the per_pixel_expr (with cloning)
     If it is null however, use the engine variable instead. */

  /* 08/20/03 : Presets are now objects, as well as per pixel equations. This ends up
     making the parser handle the case where parameters are essentially per pixel equation
     substitutions */


  term.param = param;
  if ( ( val_expr = new ValExpr ( PARAM_TERM_T, &term ) ) == NULL )
    return NULL;

  if ( ( gen_expr = new GenExpr ( VAL_T, ( void* ) val_expr ) ) == NULL )
  {
    delete val_expr;
    return NULL;
  }
  return gen_expr;
}

/* Converts a prefix function to an expression */
GenExpr *
GenExpr::prefun_to_expr ( float ( *func_ptr ) ( void * ), GenExpr ** expr_list, int num_args )
{

  GenExpr * gen_expr;
  PrefunExpr * prefun_expr;

  prefun_expr = new PrefunExpr();

  if ( prefun_expr == NULL )
    return NULL;

  prefun_expr->num_args = num_args;
  prefun_expr->func_ptr = ( float ( * ) ( void* ) ) func_ptr;
  prefun_expr->expr_list = expr_list;

  gen_expr = new GenExpr ( PREFUN_T, ( void* ) prefun_expr );

  if ( gen_expr == NULL )
    delete prefun_expr;

  return gen_expr;
}

/* Creates a new tree expression */
TreeExpr::TreeExpr (
InfixOp   * _infix_op,
GenExpr   * _gen_expr,
TreeExpr  * _left,
TreeExpr  * _right
)
  : infix_op ( _infix_op ),
    gen_expr ( _gen_expr ),
    left ( _left ),
    right ( _right )
{}


/* Creates a new value expression */
ValExpr::ValExpr ( int _type, Term * _term ) :type ( _type )
{
  //val_expr->type = _type;
  term.constant = _term->constant;
  term.param = _term->param;

  //return val_expr;
}

/* Creates a new general expression */

GenExpr::GenExpr ( int _type, void * _item )
  : type ( _type ), item ( _item )
{}

/* Frees a general expression */
GenExpr::~GenExpr()
{
  switch ( type )
  {
  case VAL_T:
    delete ( ( ValExpr* ) item );
    break;
  case PREFUN_T:
    delete ( ( PrefunExpr* ) item );
    break;
  case TREE_T:
    delete ( ( TreeExpr* ) item );
    break;
  }
}

/* Frees a function in prefix notation */
PrefunExpr::~PrefunExpr()
{
  int i;

  /* Free every element in expression list */
  for ( i = 0 ; i < num_args; i++ )
  {
    delete expr_list[i];
  }
  free ( expr_list );
}

/* Frees values of type VARIABLE and CONSTANT */
ValExpr::~ValExpr()
{}

/* Frees a tree expression */
TreeExpr::~TreeExpr()
{
  /* free left tree */
  if ( left != NULL )
  {
    delete left;
  }

  /* free general expression object */
  if ( gen_expr != NULL )
  {
    delete gen_expr;
  }

  /* Note that infix operators are always
     stored in memory unless the program
     exits, so we don't remove them here */

  /* free right tree */
  if ( right != NULL )
  {
    delete right;
  }
}

/* Initializes an infix operator */
InfixOp::InfixOp ( int type, int precedence )
{
  this->type = type;
  this->precedence = precedence;
}


PrefunExpr::PrefunExpr() {}