<?php

/** PHPExcel root directory */
if (! defined ( 'PHPEXCEL_ROOT' ))
{
  /**
   *
   * @ignore
   *
   */
  define ( 'PHPEXCEL_ROOT', dirname ( __FILE__ ) . '/../../' );
  require (PHPEXCEL_ROOT . 'PHPExcel/Autoloader.php');
}

/**
 * PHPExcel_Calculation_Logical
 *
 * Copyright (c) 2006 - 2015 PHPExcel
 *
 * 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 *
 * @category PHPExcel
 * @package PHPExcel_Calculation
 * @copyright Copyright (c) 2006 - 2015 PHPExcel (http://www.codeplex.com/PHPExcel)
 * @license http://www.gnu.org/licenses/old-licenses/lgpl-2.1.txt LGPL
 * @version ##VERSION##, ##DATE##
 */
class PHPExcel_Calculation_Logical
{
  /**
   * TRUE
   *
   * Returns the boolean TRUE.
   *
   * Excel Function:
   * =TRUE()
   *
   * @access public
   * @category Logical Functions
   * @return boolean True
   */
  public static function TRUE()
  {
    return true;
  }
  
  /**
   * FALSE
   *
   * Returns the boolean FALSE.
   *
   * Excel Function:
   * =FALSE()
   *
   * @access public
   * @category Logical Functions
   * @return boolean False
   */
  public static function FALSE()
  {
    return false;
  }
  
  /**
   * LOGICAL_AND
   *
   * Returns boolean TRUE if all its arguments are TRUE; returns FALSE if one or more argument is FALSE.
   *
   * Excel Function:
   * =AND(logical1[,logical2[, ...]])
   *
   * The arguments must evaluate to logical values such as TRUE or FALSE, or the arguments must be arrays
   * or references that contain logical values.
   *
   * Boolean arguments are treated as True or False as appropriate
   * Integer or floating point arguments are treated as True, except for 0 or 0.0 which are False
   * If any argument value is a string, or a Null, the function returns a #VALUE! error, unless the string holds
   * the value TRUE or FALSE, in which case it is evaluated as the corresponding boolean value
   *
   * @access public
   * @category Logical Functions
   * @param mixed $arg,...
   *          Data values
   * @return boolean The logical AND of the arguments.
   */
  public static function LOGICAL_AND()
  {
    // Return value
    $returnValue = true;
    
    // Loop through the arguments
    $aArgs = PHPExcel_Calculation_Functions::flattenArray ( func_get_args () );
    $argCount = - 1;
    foreach ( $aArgs as $argCount => $arg )
    {
      // Is it a boolean value?
      if (is_bool ( $arg ))
      {
        $returnValue = $returnValue && $arg;
      }
      elseif ((is_numeric ( $arg )) && (! is_string ( $arg )))
      {
        $returnValue = $returnValue && ($arg != 0);
      }
      elseif (is_string ( $arg ))
      {
        $arg = strtoupper ( $arg );
        if (($arg == 'TRUE') || ($arg == PHPExcel_Calculation::getTRUE ()))
        {
          $arg = true;
        }
        elseif (($arg == 'FALSE') || ($arg == PHPExcel_Calculation::getFALSE ()))
        {
          $arg = false;
        }
        else
        {
          return PHPExcel_Calculation_Functions::VALUE ();
        }
        $returnValue = $returnValue && ($arg != 0);
      }
    }
    
    // Return
    if ($argCount < 0)
    {
      return PHPExcel_Calculation_Functions::VALUE ();
    }
    return $returnValue;
  }
  
  /**
   * LOGICAL_OR
   *
   * Returns boolean TRUE if any argument is TRUE; returns FALSE if all arguments are FALSE.
   *
   * Excel Function:
   * =OR(logical1[,logical2[, ...]])
   *
   * The arguments must evaluate to logical values such as TRUE or FALSE, or the arguments must be arrays
   * or references that contain logical values.
   *
   * Boolean arguments are treated as True or False as appropriate
   * Integer or floating point arguments are treated as True, except for 0 or 0.0 which are False
   * If any argument value is a string, or a Null, the function returns a #VALUE! error, unless the string holds
   * the value TRUE or FALSE, in which case it is evaluated as the corresponding boolean value
   *
   * @access public
   * @category Logical Functions
   * @param mixed $arg,...
   *          Data values
   * @return boolean The logical OR of the arguments.
   */
  public static function LOGICAL_OR()
  {
    // Return value
    $returnValue = false;
    
    // Loop through the arguments
    $aArgs = PHPExcel_Calculation_Functions::flattenArray ( func_get_args () );
    $argCount = - 1;
    foreach ( $aArgs as $argCount => $arg )
    {
      // Is it a boolean value?
      if (is_bool ( $arg ))
      {
        $returnValue = $returnValue || $arg;
      }
      elseif ((is_numeric ( $arg )) && (! is_string ( $arg )))
      {
        $returnValue = $returnValue || ($arg != 0);
      }
      elseif (is_string ( $arg ))
      {
        $arg = strtoupper ( $arg );
        if (($arg == 'TRUE') || ($arg == PHPExcel_Calculation::getTRUE ()))
        {
          $arg = true;
        }
        elseif (($arg == 'FALSE') || ($arg == PHPExcel_Calculation::getFALSE ()))
        {
          $arg = false;
        }
        else
        {
          return PHPExcel_Calculation_Functions::VALUE ();
        }
        $returnValue = $returnValue || ($arg != 0);
      }
    }
    
    // Return
    if ($argCount < 0)
    {
      return PHPExcel_Calculation_Functions::VALUE ();
    }
    return $returnValue;
  }
  
  /**
   * NOT
   *
   * Returns the boolean inverse of the argument.
   *
   * Excel Function:
   * =NOT(logical)
   *
   * The argument must evaluate to a logical value such as TRUE or FALSE
   *
   * Boolean arguments are treated as True or False as appropriate
   * Integer or floating point arguments are treated as True, except for 0 or 0.0 which are False
   * If any argument value is a string, or a Null, the function returns a #VALUE! error, unless the string holds
   * the value TRUE or FALSE, in which case it is evaluated as the corresponding boolean value
   *
   * @access public
   * @category Logical Functions
   * @param mixed $logical
   *          A value or expression that can be evaluated to TRUE or FALSE
   * @return boolean The boolean inverse of the argument.
   */
  public static function NOT($logical = false)
  {
    $logical = PHPExcel_Calculation_Functions::flattenSingleValue ( $logical );
    if (is_string ( $logical ))
    {
      $logical = strtoupper ( $logical );
      if (($logical == 'TRUE') || ($logical == PHPExcel_Calculation::getTRUE ()))
      {
        return false;
      }
      elseif (($logical == 'FALSE') || ($logical == PHPExcel_Calculation::getFALSE ()))
      {
        return true;
      }
      else
      {
        return PHPExcel_Calculation_Functions::VALUE ();
      }
    }
    
    return ! $logical;
  }
  
  /**
   * STATEMENT_IF
   *
   * Returns one value if a condition you specify evaluates to TRUE and another value if it evaluates to FALSE.
   *
   * Excel Function:
   * =IF(condition[,returnIfTrue[,returnIfFalse]])
   *
   * Condition is any value or expression that can be evaluated to TRUE or FALSE.
   * For example, A10=100 is a logical expression; if the value in cell A10 is equal to 100,
   * the expression evaluates to TRUE. Otherwise, the expression evaluates to FALSE.
   * This argument can use any comparison calculation operator.
   * ReturnIfTrue is the value that is returned if condition evaluates to TRUE.
   * For example, if this argument is the text string "Within budget" and the condition argument evaluates to TRUE,
   * then the IF function returns the text "Within budget"
   * If condition is TRUE and ReturnIfTrue is blank, this argument returns 0 (zero). To display the word TRUE, use
   * the logical value TRUE for this argument.
   * ReturnIfTrue can be another formula.
   * ReturnIfFalse is the value that is returned if condition evaluates to FALSE.
   * For example, if this argument is the text string "Over budget" and the condition argument evaluates to FALSE,
   * then the IF function returns the text "Over budget".
   * If condition is FALSE and ReturnIfFalse is omitted, then the logical value FALSE is returned.
   * If condition is FALSE and ReturnIfFalse is blank, then the value 0 (zero) is returned.
   * ReturnIfFalse can be another formula.
   *
   * @access public
   * @category Logical Functions
   * @param mixed $condition
   *          Condition to evaluate
   * @param mixed $returnIfTrue
   *          Value to return when condition is true
   * @param mixed $returnIfFalse
   *          Optional value to return when condition is false
   * @return mixed The value of returnIfTrue or returnIfFalse determined by condition
   */
  public static function STATEMENT_IF($condition = true, $returnIfTrue = 0, $returnIfFalse = false)
  {
    $condition = (is_null ( $condition )) ? true : ( boolean ) PHPExcel_Calculation_Functions::flattenSingleValue ( $condition );
    $returnIfTrue = (is_null ( $returnIfTrue )) ? 0 : PHPExcel_Calculation_Functions::flattenSingleValue ( $returnIfTrue );
    $returnIfFalse = (is_null ( $returnIfFalse )) ? false : PHPExcel_Calculation_Functions::flattenSingleValue ( $returnIfFalse );
    
    return ($condition) ? $returnIfTrue : $returnIfFalse;
  }
  
  /**
   * IFERROR
   *
   * Excel Function:
   * =IFERROR(testValue,errorpart)
   *
   * @access public
   * @category Logical Functions
   * @param mixed $testValue
   *          Value to check, is also the value returned when no error
   * @param mixed $errorpart
   *          Value to return when testValue is an error condition
   * @return mixed The value of errorpart or testValue determined by error condition
   */
  public static function IFERROR($testValue = '', $errorpart = '')
  {
    $testValue = (is_null ( $testValue )) ? '' : PHPExcel_Calculation_Functions::flattenSingleValue ( $testValue );
    $errorpart = (is_null ( $errorpart )) ? '' : PHPExcel_Calculation_Functions::flattenSingleValue ( $errorpart );
    
    return self::STATEMENT_IF ( PHPExcel_Calculation_Functions::IS_ERROR ( $testValue ), $errorpart, $testValue );
  }
}
