#include <symcalc/symcalc.hpp>

using namespace symcalc; // Integrate the namespace

#include <symcalc/symcalc.hpp>
#include <cmath>

class CustomAbs : public EquationBase{
public:
	
	EquationBase* insides; // The expression that's inside of our abs operation
	
	
	CustomAbs(EquationBase* insides) : EquationBase("abs"), insides(insides) {} // Normal constructor
	CustomAbs(const CustomAbs& lvalue) : EquationBase(lvalue){
		// Use the copy function to copy the insides of the lvalue CustomAbs object
		this->insides = copy(lvalue.insides);
	}
	
	// Deconstructor
	~CustomAbs(){
		// Delete the insides on deconstruct
		delete_equation_base(insides);
	}
	
	
	// Dynamic cast copy function
	EquationBase* _copy_equation_base() const override{
		const CustomAbs* casted = dynamic_cast<const CustomAbs*>(this);
		return new CustomAbs(*casted); // Create a copy and return it
	}
	
	
	// Dynamic cast delete function
	void _delete_equation_base() override{
		CustomAbs* casted = dynamic_cast<CustomAbs*>(this);
		delete casted;
	}
	
	// Text represantation
	std::string txt() const override{
		return "|" + insides->txt() + "|";
	}
	
	// Eval function
	double eval(std::map<std::string, double> var_hash) const override{
		double insides_eval = insides->eval(var_hash);
		if(insides_eval < 0){
			return -insides_eval;
		}else{
			return insides_eval;
		}
	}
	
	// List variables function
	std::vector<std::string> list_variables() const override{
		return insides->list_variables();
	}
	
	// Derivative function
	// |f(x)|' = (f(x) / |f(x)|) * f'(x)
	// Example:
	// If f(x) = x, then
	// |x|' = (x / |x|) * (x)' = (x / |x|) * 1 = x / |x|
	EquationBase* _derivative(std::string var) const override{
		EquationBase* insides_derivative = insides->_derivative(var); // f'(x)
		EquationBase* insides_copy_1 = copy(insides); // f(x)
		EquationBase* insides_copy_2 = copy(insides); // f(x)
		EquationBase* abs_insides = new CustomAbs(insides_copy_2); // |f(x)|
		EquationBase* div = new Div(insides_copy_1, abs_insides); // f(x) / |f(x)|
		EquationBase* mult = new Mult({div, insides_derivative}); // (f(x) / |f(x)|) * f'(x)
		return mult;
	}
	
	
	// Simplify function
	EquationBase* _simplify() const override{
		EquationBase* simplified_insides = insides->_simplify();
		if(simplified_insides->type == "abs"){
			return simplified_insides; // CustomAbsolute function twice is the same as once, ||x|| = |x| 
		}else if(simplified_insides->type == "pow"){
			// Check for a power that can be only positive, e.g. |x^2| = x^2
			const Power* casted = dynamic_cast<const Power*>(simplified_insides);
			if(casted->power->type == "val"){
				const EquationValue* val_casted = dynamic_cast<const EquationValue*>(casted->power);
				if(fmod(val_casted->value, 2) == 0){ // Check if power is divisible by 2
					return simplified_insides;
				}
			}
		}
		// Implement further checks if needed
		
		// If no simplifications work, return the insides simplified in an abs function
		return new CustomAbs(simplified_insides);
	}
};

// Create a custom_abs() function for easier expression definition when using SymCalc
Equation custom_abs(const Equation equation){
	// Create an Equation object with the pointer to a CustomAbs that holds a copy of equation's eq
	return Equation(new CustomAbs(equation.copy_eq()));
}

#include <symcalc/symcalc.hpp>

// You can paste the new CustomAbs class here, or create a header and a cpp file to compile with

int main(){
	Equation x ("x"); // Declare a variable
	
	Equation fx = custom_abs(x - 4); // Use our abs function
	
	// Print the value at x = 3, this should be |3 - 4| = |-1| = 1
	std::cout << fx.eval({{x, 3}}) << std::endl; // => 1
	
	return 0;
}

symcalc::SYMCALC_AUTO_SIMPLIFY = false;
// or
symcalc::SYMCALC_AUTO_SIMPLIFY = true; // the default option

#define SYMCALC_VALUE_TYPE float // changed from double
// Change other types if needed