<?php
declare(strict_types=1);

use PHPUnit\Framework\TestCase;

require_once __DIR__ . '/../../php/markdown.php';
require_once __DIR__ . '/../../php/spreadsheet.php';

final class ExpressionSetTests extends TestCase {
	private function assertSameCellValue(CellValue $expected, CellValue $actual) {
		$this->assertSame($expected->formattedValue, $actual->formattedValue);
		if (gettype($expected->value) === 'double' && gettype($actual->value) === 'double') {
			$this->assertEqualsWithDelta($expected->value, $actual->value, 0.000_001);
		} else {
			$this->assertSame($expected->value, $actual->value);
		}
		$this->assertSame($expected->type, $actual->type);
		$this->assertSame($expected->decimals, $actual->decimals);
	}

	public function test_simpleMath() {
		$grid = new SpreadsheetGrid(1, 1);
		$grid->cells[0][0]->originalValue = CellValue::fromCellString('=7*3');
		$expressionSet = new CellExpressionSet($grid);
		$expressionSet->calculateCells();
		$expected = CellValue::fromValue(21);
		$actual = $grid->cells[0][0]->outputValue;
		$this->assertSameCellValue($expected, $actual);
	}

	public function test_reference() {
		$grid = new SpreadsheetGrid(3, 1);
		$grid->cells[0][0]->originalValue = CellValue::fromValue(123);
		$grid->cells[1][0]->originalValue = CellValue::fromValue(3);
		$grid->cells[2][0]->originalValue = CellValue::fromCellString('=A1*B1');
		$expressionSet = new CellExpressionSet($grid);
		$expressionSet->calculateCells();
		$expected = CellValue::fromValue(369);
		$actual = $grid->cells[2][0]->outputValue;
		$this->assertSameCellValue($expected, $actual);
	}

	public function test_infixPriority() {
		$grid = new SpreadsheetGrid(1, 1);
		$grid->cells[0][0]->originalValue = CellValue::fromCellString('=4*9/3+7-4');
		$expressionSet = new CellExpressionSet($grid);
		$expressionSet->calculateCells();
		$expected = CellValue::fromValue(15);
		$actual = $grid->cells[0][0]->outputValue;
		$this->assertSameCellValue($expected, $actual);
	}

	public function test_filledFormula() {
		$grid = new SpreadsheetGrid(3, 3);
		$grid->cells[0][0]->originalValue = CellValue::fromValue(4);
		$grid->cells[1][0]->originalValue = CellValue::fromValue(5);
		$grid->cells[2][0]->originalValue = CellValue::fromCellString('=A1*B1 FILL');
		$grid->cells[0][1]->originalValue = CellValue::fromValue(6);
		$grid->cells[1][1]->originalValue = CellValue::fromValue(7);
		$grid->cells[0][2]->originalValue = CellValue::fromValue(8);
		$grid->cells[1][2]->originalValue = CellValue::fromValue(9);
		$expressionSet = new CellExpressionSet($grid);
		$expressionSet->calculateCells();
		$this->assertSameCellValue(CellValue::fromValue(20), $grid->cells[2][0]->outputValue);
		$this->assertSameCellValue(CellValue::fromValue(42), $grid->cells[2][1]->outputValue);
		$this->assertSameCellValue(CellValue::fromValue(72), $grid->cells[2][2]->outputValue);
	}

	public function test_dependencies() {
		$grid = new SpreadsheetGrid(2, 4);
		$grid->cells[0][0]->originalValue = CellValue::fromValue(1);
		$grid->cells[1][0]->originalValue = CellValue::fromCellString('=A1+B2');
		$grid->cells[0][1]->originalValue = CellValue::fromValue(2);
		$grid->cells[1][1]->originalValue = CellValue::fromCellString('=A2+B3');
		$grid->cells[0][2]->originalValue = CellValue::fromValue(3);
		$grid->cells[1][2]->originalValue = CellValue::fromCellString('=A3+B4');
		$grid->cells[0][3]->originalValue = CellValue::fromValue(4);
		$grid->cells[1][3]->originalValue = CellValue::fromCellString('=A4');
		$expressionSet = new CellExpressionSet($grid);
		$expressionSet->calculateCells();
		$this->assertSameCellValue(CellValue::fromValue(10), $grid->cells[1][0]->outputValue);
		$this->assertSameCellValue(CellValue::fromValue(9), $grid->cells[1][1]->outputValue);
		$this->assertSameCellValue(CellValue::fromValue(7), $grid->cells[1][2]->outputValue);
		$this->assertSameCellValue(CellValue::fromValue(4), $grid->cells[1][3]->outputValue);
	}

	private function test_simple_formula($expected, $formula) {
		$grid = new SpreadsheetGrid(1, 1);
		$grid->cells[0][0]->originalValue = CellValue::fromCellString($formula);
		$expressionSet = new CellExpressionSet($grid);
		$expressionSet->calculateCells();
		$actual = $grid->cells[0][0]->outputValue;
		$exp = ($expected instanceof CellValue) ? $expected : CellValue::fromValue($expected);
		$this->assertSameCellValue($exp, $actual);
	}

	public function test_func_abs() {
		$this->test_simple_formula(3, '=ABS(-3)');
		$this->test_simple_formula(4, '=ABS(4)');
	}

	public function test_func_and() {
		$this->test_simple_formula(false, '=AND(FALSE, FALSE)');
		$this->test_simple_formula(false, '=AND(FALSE, TRUE)');
		$this->test_simple_formula(false, '=AND(TRUE, FALSE)');
		$this->test_simple_formula(true, '=AND(TRUE, TRUE)');
		$this->test_simple_formula(true, '=AND(TRUE, TRUE, TRUE, TRUE)');
		$this->test_simple_formula(false, '=AND(TRUE, TRUE, TRUE, FALSE)');
	}

	public function test_func_average() {
		$this->test_simple_formula(4, '=AVERAGE(4, 6, 2, 4)');
		$this->test_simple_formula(4, '=AVERAGE(4, 6, 2, "foo", 4)');
	}

	public function test_func_ceiling() {
		$this->test_simple_formula(4.0, '=CEILING(3.1)');
		$this->test_simple_formula(3.0, '=CEILING(3)');
		$this->test_simple_formula(-3.0, '=CEILING(-3.1)');
	}

	public function test_func_exp() {
		$this->test_simple_formula(2.718281828459045, '=EXP(1)');
	}

	public function test_func_floor() {
		$this->test_simple_formula(3.0, '=FLOOR(3.1)');
		$this->test_simple_formula(3.0, '=FLOOR(3)');
		$this->test_simple_formula(-4.0, '=FLOOR(-3.1)');
	}

	public function test_func_if() {
		$this->test_simple_formula(6, '=IF(FALSE, 4, 6)');
		$this->test_simple_formula(4, '=IF(TRUE, 4, 6)');
	}

	public function test_func_ifs() {
		$this->test_simple_formula(1, '=IFS(TRUE, 1, FALSE, 2, FALSE, 3, FALSE, 4, 5)');
		$this->test_simple_formula(2, '=IFS(FALSE, 1, TRUE, 2, FALSE, 3, FALSE, 4, 5)');
		$this->test_simple_formula(3, '=IFS(FALSE, 1, FALSE, 2, TRUE, 3, FALSE, 4, 5)');
		$this->test_simple_formula(4, '=IFS(FALSE, 1, FALSE, 2, FALSE, 3, TRUE, 4, 5)');
		$this->test_simple_formula(5, '=IFS(FALSE, 1, FALSE, 2, FALSE, 3, FALSE, 4, 5)');
	}

	public function test_func_ln() {
		$this->test_simple_formula(1.0, '=LN(2.718281828459045)');
	}

	public function test_func_log() {
		$this->test_simple_formula(3.0, '=LOG(1000, 10)');
		$this->test_simple_formula(6.0, '=LOG(64, 2)');
	}

	public function test_func_lower() {
		$this->test_simple_formula('mixed', '=LOWER("MiXeD")');
	}

	public function test_func_max() {
		$this->test_simple_formula(8, '=MAX(4, 8, 5, 2)');
	}

	public function test_func_min() {
		$this->test_simple_formula(2, '=MIN(4, 8, 5, 2)');
	}

	public function test_func_mod() {
		$this->test_simple_formula(1, '=MOD(37, 4)');
	}

	public function test_func_not() {
		$this->test_simple_formula(false, '=NOT(TRUE)');
		$this->test_simple_formula(true, '=NOT(FALSE)');
	}

	public function test_func_or() {
		$this->test_simple_formula(false, '=OR(FALSE, FALSE)');
		$this->test_simple_formula(true, '=OR(FALSE, TRUE)');
		$this->test_simple_formula(true, '=OR(TRUE, FALSE)');
		$this->test_simple_formula(true, '=OR(TRUE, TRUE)');
		$this->test_simple_formula(true, '=OR(FALSE, FALSE, FALSE, TRUE)');
	}

	public function test_func_power() {
		$this->test_simple_formula(8, '=POWER(2, 3)');
	}

	public function test_func_round() {
		$this->test_simple_formula(3.0, '=ROUND(3.1)');
		$this->test_simple_formula(4.0, '=ROUND(3.5)');
		$this->test_simple_formula(4.0, '=ROUND(4)');
		$this->test_simple_formula(-3.0, '=ROUND(-3.1)');
		$this->test_simple_formula(-3.0, '=ROUND(-3.5)');
		$this->test_simple_formula(-4.0, '=ROUND(-3.9)');
		$this->test_simple_formula(3.1, '=ROUND(3.1415926535, 1)');
		$this->test_simple_formula(3.14, '=ROUND(3.1415926535, 2)');
		$this->test_simple_formula(30.0, '=ROUND(31.415926535, -1)');
	}

	public function test_func_sqrt() {
		$this->test_simple_formula(4.0, '=SQRT(16)');
	}

	public function test_func_substitute() {
		$this->test_simple_formula('cot sot on the mot', '=SUBSTITUTE("cat sat on the mat", "at", "ot")');
		$this->test_simple_formula('cot sot on the mot', '=SUBSTITUTE("cAt saT on the mat", "at", "ot")');
		$this->test_simple_formula('cot sot on the mot', '=SUBSTITUTE("c.*t s.*t on the m.*t", ".*t", "ot")');
	}

	public function test_func_sum() {
		$this->test_simple_formula(15, '=SUM(1, 2, 3, 4, 5)');
	}

	public function test_func_upper() {
		$this->test_simple_formula('MIXED', '=UPPER("mIxEd")');
	}

	public function test_func_xor() {
		$this->test_simple_formula(false, '=XOR(FALSE, FALSE)');
		$this->test_simple_formula(true, '=XOR(FALSE, TRUE)');
		$this->test_simple_formula(true, '=XOR(TRUE, FALSE)');
		$this->test_simple_formula(false, '=XOR(TRUE, TRUE)');
		$this->test_simple_formula(true, '=XOR(FALSE, FALSE, TRUE)');
		$this->test_simple_formula(false, '=XOR(TRUE, FALSE, TRUE)');
	}

	public function test_format() {
		$this->test_simple_formula(new CellValue('2.718', 2.718281828459045, 'number', 3), '=2.718281828459045 ; number 3');
		$this->test_simple_formula(new CellValue('271.83%', 2.718281828459045, 'percent', 2), '=2.718281828459045 ; percent 2');
		$this->test_simple_formula(new CellValue('$2.72', 2.718281828459045, 'currency', 2), '=2.718281828459045 ; currency 2');
	}
}
?>