<?php

/**
 * This file is part of the MathExecutor package
 *
 * (c) Alexander Kiryukhin
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code
 */

namespace NXP;

use NXP\Classes\Func;
use NXP\Classes\Operand;
use NXP\Classes\Token;
use NXP\Classes\TokenParser;
use NXP\Exception\IncorrectExpressionException;
use NXP\Exception\UnknownFunctionException;
use NXP\Exception\UnknownOperatorException;
use NXP\Exception\UnknownTokenException;

/**
 * Class MathExecutor
 * @package NXP
 */
class MathExecutor
{
    /**
     * Available operators
     *
     * @var array
     */
    private $operators = array();

    /**
     * Available functions
     *
     * @var array
     */
    private $functions = array();

    /**
     * Available variables
     *
     * @var array
     */
    private $variables = array();

    /**
     * @var \SplStack
     */
    private $stack;

    /**
     * @var \SplQueue
     */
    private $queue;

    /**
     * Base math operators
     */
    public function __construct()
    {
        $this->addDefaults();
    }

    public function __clone()
    {
        $this->variables = array();
        $this->operators = array();
        $this->functions = array();

        $this->addDefaults();
    }

    /**
     * Set default operands and functions
     */
    protected function addDefaults()
    {
        $this->addOperator(new Operand('+', 1, Operand::LEFT_ASSOCIATED, Operand::BINARY, function ($op1, $op2) { return $op1+$op2; }));
        $this->addOperator(new Operand('-', 1, Operand::LEFT_ASSOCIATED, Operand::BINARY, function ($op1, $op2) { return $op1-$op2; }));
        $this->addOperator(new Operand('*', 2, Operand::LEFT_ASSOCIATED, Operand::BINARY, function ($op1, $op2) { return $op1*$op2; }));
        $this->addOperator(new Operand('/', 2, Operand::LEFT_ASSOCIATED, Operand::BINARY, function ($op1, $op2) { return $op1/$op2; }));
        $this->addOperator(new Operand('^', 3, Operand::LEFT_ASSOCIATED, Operand::BINARY, function ($op1, $op2) { return pow($op1,$op2); }));

        $this->addFunction(new Func('sin',  function ($arg) { return sin($arg); }));
        $this->addFunction(new Func('cos',  function ($arg) { return cos($arg); }));
        $this->addFunction(new Func('tn',   function ($arg) { return tan($arg); }));
        $this->addFunction(new Func('asin', function ($arg) { return asin($arg); }));
        $this->addFunction(new Func('acos', function ($arg) { return acos($arg); }));
        $this->addFunction(new Func('atn',  function ($arg) { return atan($arg); }));
    }

    /**
     * Add operator to executor
     *
     * @param  Operand      $operator
     * @return MathExecutor
     */
    public function addOperator(Operand $operator)
    {
        $this->operators[$operator->getSymbol()] = $operator;

        return $this;
    }

    /**
     * Add function to executor
     *
     * @param  string       $name
     * @param  callable     $function
     * @return MathExecutor
     */
    public function addFunction($name, callable $function = null)
    {
        if ($name instanceof Func) {
            $this->functions[$name->getName()] = $name->getCallback();
        } else {
            $this->functions[$name] = $function;
        }

        return $this;
    }

    /**
     * Add variable to executor
     *
     * @param  string        $variable
     * @param  integer|float $value
     * @throws \Exception
     * @return MathExecutor
     */
    public function setVar($variable, $value)
    {
        if (!is_numeric($value)) {
            throw new \Exception("Variable value must be a number");
        }

        $this->variables[$variable] = $value;

        return $this;
    }

    /**
     * Add variables to executor
     *
     * @param  array        $variables
     * @param  bool         $clear     Clear previous variables
     * @return MathExecutor
     */
    public function setVars(array $variables, $clear = true)
    {
        if ($clear) {
            $this->removeVars();
        }

        foreach ($variables as $name => $value) {
            $this->setVar($name, $value);
        }

        return $this;
    }

    /**
     * Remove variable from executor
     *
     * @param  string       $variable
     * @return MathExecutor
     */
    public function removeVar($variable)
    {
        unset ($this->variables[$variable]);

        return $this;
    }

    /**
     * Remove all variables
     */
    public function removeVars()
    {
        $this->variables = array();

        return $this;
    }

    /**
     * Execute expression
     *
     * @param $expression
     * @return int|float
     */
    public function execute($expression)
    {
        $reversePolishNotation = $this->convertToReversePolishNotation($expression);
        $result = $this->calculateReversePolishNotation($reversePolishNotation);

        return $result;
    }

    /**
     * Convert expression from normal expression form to RPN
     *
     * @param $expression
     * @return \SplQueue
     * @throws \Exception
     */
    private function convertToReversePolishNotation($expression)
    {
        $this->stack = new \SplStack();
        $this->queue = new \SplQueue();

        $tokenParser = new TokenParser();
        $input = $tokenParser->tokenize($expression);

        foreach ($input as $token) {
            $this->categorizeToken($token);
        }

        while (!$this->stack->isEmpty()) {
            $token = $this->stack->pop();

            if ($token->getType() != Token::OPERATOR) {
                throw new \Exception('Opening bracket without closing bracket');
            }

            $this->queue->push($token);
        }

        return $this->queue;
    }

    /**
     * @param  Token      $token
     * @throws \Exception
     */
    private function categorizeToken(Token $token)
    {
        switch ($token->getType()) {
            case Token::NUMBER :
                $this->queue->push($token);
                break;

            case Token::STRING:
                if (array_key_exists($token->getValue(), $this->variables)) {
                    $this->queue->push(new Token(Token::NUMBER, $this->variables[$token->getValue()]));
                } else {
                    $this->stack->push($token);
                }
                break;

            case Token::LEFT_BRACKET:
                $this->stack->push($token);
                break;

            case Token::RIGHT_BRACKET:
                $previousToken = $this->stack->pop();
                while (!$this->stack->isEmpty() && ($previousToken->getType() != Token::LEFT_BRACKET)) {
                    $this->queue->push($previousToken);
                    $previousToken = $this->stack->pop();
                }
                if ((!$this->stack->isEmpty()) && ($this->stack->top()->getType() == Token::STRING)) {
                    $funcName = $this->stack->pop()->getValue();
                    if (!array_key_exists($funcName, $this->functions)) {
                        throw new UnknownFunctionException(sprintf(
                            'Unknown function: "%s".',
                            $funcName
                        ));
                    }
                    $this->queue->push(new Token(Token::FUNC, $funcName));
                }
                break;

            case Token::OPERATOR:
                if (!array_key_exists($token->getValue(), $this->operators)) {
                    throw new UnknownOperatorException(sprintf(
                        'Unknown operator: "%s".',
                        $token->getValue()
                    ));
                }

                $this->proceedOperator($token);
                $this->stack->push($token);
                break;

            default:
                throw new UnknownTokenException(sprintf(
                    'Unknown token: "%s".',
                    $token->getValue()
                ));
        }
    }

    /**
     * @param $token
     * @throws \Exception
     */
    private function proceedOperator(Token $token)
    {
        if (!array_key_exists($token->getValue(), $this->operators)) {
            throw new UnknownOperatorException(sprintf(
                'Unknown operator: "%s".',
                $token->getValue()
            ));
        }

        /** @var Operand $operator */
        $operator = $this->operators[$token->getValue()];

        while (!$this->stack->isEmpty()) {
            $top = $this->stack->top();

            if ($top->getType() == Token::OPERATOR) {
                /** @var Operand $operator */
                $operator = $this->operators[$top->getValue()];
                $priority = $operator->getPriority();
                if ( $operator->getAssociation() == Operand::RIGHT_ASSOCIATED) {
                    if (($priority > $operator->getPriority())) {
                        $this->queue->push($this->stack->pop());
                    } else {
                        return;
                    }
                } else {
                    if (($priority >= $operator->getPriority())) {
                        $this->queue->push($this->stack->pop());
                    } else {
                        return;
                    }
                }
            } elseif ($top->getType() == Token::STRING) {
                $this->queue->push($this->stack->pop());
            } else {
                return;
            }
        }
    }

    /**
     * @param  \SplQueue  $expression
     * @return mixed
     * @throws \Exception
     */
    private function calculateReversePolishNotation(\SplQueue $expression)
    {
        $this->stack = new \SplStack();
        /** @var Token $token */
        foreach ($expression as $token) {
            switch ($token->getType()) {
                case Token::NUMBER :
                    $this->stack->push($token);
                    break;

                case Token::OPERATOR:
                    /** @var Operand $operator */
                    $operator = $this->operators[$token->getValue()];
                    if ($operator->getType() == Operand::BINARY) {
                        $arg2 = $this->stack->pop()->getValue();
                        $arg1 = $this->stack->pop()->getValue();
                    } else {
                        $arg2 = null;
                        $arg1 = $this->stack->pop()->getValue();
                    }
                    $callback = $operator->getCallback();

                    $this->stack->push(new Token(Token::NUMBER, (call_user_func($callback, $arg1, $arg2))));
                    break;

                case Token::FUNC:
                    /** @var Func $function */
                    $callback = $this->functions[$token->getValue()];
                    $arg = $this->stack->pop()->getValue();
                    $this->stack->push(new Token(Token::NUMBER, (call_user_func($callback, $arg))));
                    break;

                default:
                    throw new UnknownTokenException(sprintf(
                        'Unknown token: "%s".',
                        $token->getValue()
                    ));
            }
        }

        $result = $this->stack->pop()->getValue();

        if (!$this->stack->isEmpty()) {
            throw new IncorrectExpressionException('Incorrect expression.');
        }

        return $result;
    }
}