#include <iostream>
#include <string>
#include "node.h"
#include "globals.h"
#include <cmath>
/*
 *Written by Jessica Smith from code adapted from code written by rcd.
 */

Constant::Constant (double value)
  : myValue(value),
    myPrecedence(CONSTANT_PRECEDENCE)
{
}
Constant:: ~Constant (){}
// return the number
double Constant:: evaluate () const
{
    return myValue;
}
// print the number
string Constant::description()const
{
    string Desc="";
    Desc+=myValue;
    return(Desc);
}
void Constant::print (ostream & out) const
{
    out << myValue;
}
// copy this node
Node * Constant::copy () const
{
    return new Constant(myValue);
}
int Constant:: precedence()const
{
    return myPrecedence;
}
// this is the generic operator node
Node* Constant:: takeDerivative(string & key)
{
    //Returns 0
    return(new Constant(0));
}

Paren::Paren (const char & parenthesis,const int & precedence)
  : myParenthesis(parenthesis),
    myPrecedence(precedence)
{
}
Paren:: ~Paren ()
{
}
// return the number
double Paren:: evaluate () const
{
    return myParenthesis;
}
string Paren::description()const
{
    string Paren="";
    Paren+=myParenthesis;
    return Paren;
}
// print the number
void Paren::print (ostream & out) const
{
    out << myParenthesis;
}
// copy this node
Node * Paren::copy () const
{
    return new Paren(myParenthesis,myPrecedence);
}
int Paren:: precedence()const
{
    return myPrecedence;
}
char Paren::parenSymbol()
{
    //returns parenthsis sumbol of the node
    return myParenthesis;
}
Equals::Equals ()
  : myPrecedence(EQUALS_PRECEDENCE)
{
}
Equals::~Equals()
{
}
// print the number
string Equals::description()const
{
    return("=");
}
double Equals::evaluate()const
{
    return(0);
}
void Equals::print (ostream & out) const
{
    out << "=";
}

// copy this node
Node * Equals::copy () const
{
    return (new Equals());
}
int Equals::precedence()const
{
    return myPrecedence;
}
Variable::Variable(string name)
  :myName(name),
   myPrecedence(VARIABLE_PRECEDENCE),
   myLHS(0),
   myValue(0)
{
}
Variable::Variable(string name, double value)
  :myName(name),
   myPrecedence(VARIABLE_PRECEDENCE),
   myLHS(new Constant(0)),
   myValue(value)
{
}
Variable::Variable(string name, double value, int precedence)
  :myName(name),
   myPrecedence(precedence),
   myLHS(new Constant(0)),
   myValue(value)
{
}
Variable::~Variable()
{
    delete myLHS;
}
// print the number
string Variable::description()const
{
    return(myName);
}
void Variable::print (ostream & out) const
{
    out << myName;
}
// copy this node
double Variable::evaluate()const
{
    if(myValue==0)
    {
        return(myLHS->evaluate());
    }
    else
    {
        return myValue;
    }
}
Node * Variable::copy () const
{
    return new Variable(myName);
}
int Variable::precedence()const
{
    return myPrecedence;
}
void Variable::Left(Node * lhNode)
{
    myLHS= lhNode;
    // myValue=myLHS->evaluate();
}
void Variable::changePrecedence(int precedence)
{
    myPrecedence=precedence;
}
void Variable::postAlert(bool statement)
{
	myAlert=statement;
}
bool Variable::getAlert()
{
	return myAlert;
}
bool Variable::isVariable()
{
	return true;
			    
}
Node * Variable::takeDerivative(string & key)
{
    //Returns 1 if variable is key
    //Zero else
    if(myName==key)
    {
        return(new Constant(1));
    }
    return(new Constant(0));
}
Comma::Comma ()
  : myPrecedence(COMMA_PRECEDENCE)
{
}
Comma::~Comma()
{
}
// print the number
string Comma::description()const
{
    return(",");
}
double Comma::evaluate()const
{
    return(0);
}
void Comma::print (ostream & out) const
{
    out << ",";
}

// copy this node
Node * Comma::copy () const
{
    return (new Comma());
}
int Comma::precedence()const
{
    return myPrecedence;
}