<?php
/**
* Mirasvit
*
* This source file is subject to the Mirasvit Software License, which is available at https://mirasvit.com/license/.
* Do not edit or add to this file if you wish to upgrade the to newer versions in the future.
* If you wish to customize this module for your needs.
* Please refer to http://www.magentocommerce.com for more information.
*
* @category Mirasvit
* @package mirasvit/module-report-api
* @version 1.0.41
* @copyright Copyright (C) 2020 Mirasvit (https://mirasvit.com/)
*/



namespace Mirasvit\ReportApi\Handler;

use Magento\Framework\App\ResourceConnection;
use Magento\Framework\DB\Select\SelectRenderer;
use Mirasvit\ReportApi\Api\Config\ColumnInterface;
use Mirasvit\ReportApi\Api\Config\FieldInterface;
use Mirasvit\ReportApi\Api\Config\RelationInterface;
use Mirasvit\ReportApi\Api\Config\SelectInterface;
use Mirasvit\ReportApi\Api\Config\TableInterface;
use Mirasvit\ReportApi\Config\Schema;
use Mirasvit\ReportApi\Service\SelectService;

/**
* @SuppressWarnings(PHPMD.CouplingBetweenObjects)
*/
class Select extends \Magento\Framework\DB\Select implements SelectInterface
{
/**
* @var ColumnInterface[]
*/
private $usedColumnsPool = [];

/**
* @var string[]
*/
private $joinedTablesPool = [];

/**
* @var RelationInterface[]
*/
private $usedRelationsPool = [];

private $resource;

private $connection;

private $baseTable;

private $schema;

private $selectService;

public function __construct(
ResourceConnection $resource,
Schema $schema,
SelectService $selectService,
SelectRenderer $selectRenderer
) {
$this->schema = $schema;
$this->selectService = $selectService;
$this->resource = $resource;

/** @var \Magento\Framework\DB\Adapter\Pdo\Mysql $adapter */
$adapter = $resource->getConnection();

parent::__construct($adapter, $selectRenderer);
}

/**
* @param TableInterface $table
*
* @return $this
*/
public function setBaseTable($table)
{
$this->baseTable = $table;
$this->connection = $this->resource->getConnection($this->baseTable->getConnectionName());

$this->joinedTablesPool[] = $table->getName();

$this->from(
[$table->getName() => $this->resource->getTableName($table->getName())],
[]
);

return $this;
}

/**
* @param FieldInterface $field
* @param null $alias
*
* @return $this
*/
public function addFieldToSelect(FieldInterface $field, $alias = null)
{
$field->join($this);

$alias = $alias ? $alias : $field->getName();

$this->columns([
$alias => $field->toDbExpr(),
]);

return $this;
}

/**
* @param ColumnInterface $column
* @param string $alias
*
* @return $this
*/
public function addColumnToSelect(ColumnInterface $column, $alias = null)
{
$this->usedColumnsPool[] = $column;

$column->join($this);

foreach ($column->getFields() as $field) {
$field->join($this);
}

$alias = $alias ? $alias : $column->getIdentifier();

$this->columns([
$alias => $column->toDbExpr(),
]);

return $this;
}

/**
* @param FieldInterface $field
*
* @return $this
*/
public function addFieldToGroup(FieldInterface $field)
{
$field->join($this);

$this->group($field->toDbExpr());

return $this;
}

/**
* @param ColumnInterface $column
*
* @return $this
*/
public function addColumnToGroup(ColumnInterface $column)
{
$column->join($this);

foreach ($column->getFields() as $field) {
$field->join($this);
}

$this->usedColumnsPool[] = $column;

$this->group($column->toDbExpr());

return $this;
}

/**
* @param ColumnInterface $column
* @param integer|string|array $condition
*
* @return $this
*/
public function addColumnToFilter(ColumnInterface $column, $condition)
{
// $this->validateColumn($column);

$this->usedColumnsPool[] = $column;

$column->join($this);

foreach ($column->getFields() as $field) {
$field->join($this);
}

$conditionSql = $this->connection->prepareSqlCondition($column->toDbExpr(), $condition);

if (strpos($conditionSql, 'COUNT(') !== false
|| strpos($conditionSql, 'AVG(') !== false
|| strpos($conditionSql, 'SUM(') !== false
|| strpos($conditionSql, 'CONCAT(') !== false
|| strpos($conditionSql, 'MIN(') !== false
|| strpos($conditionSql, 'MAX(') !== false
) {
$this->having($conditionSql);
} elseif ($condition) {
$this->where($conditionSql);
}


return $this;
}

/**
* @param ColumnInterface $column
* @param string $direction
*
* @return $this
*/
public function addColumnToOrder(ColumnInterface $column, $direction)
{
$column->join($this);

foreach ($column->getFields() as $field) {
$field->join($this);
}

$this->validateColumn($column);
$this->usedColumnsPool[] = $column;

$this->order(new \Zend_Db_Expr($column->toDbExpr() . ' ' . $direction));

return $this;
}

/**
* @param ColumnInterface $column
*
* @return bool
* @throws \Exception
*/
private function validateColumn(ColumnInterface $column)
{
return true;
if ($this->selectService->getRelationType($this->baseTable, $column->getTable()) !== RelationInterface::TYPE_ONE) {
throw new \LogicException("Wrong column for select: {$column->getIdentifier()}");
}
}

/**
* {@inheritdoc}
*/
public function assemble()
{
if (!count($this->_parts[self::FROM])) {
$this->columns([
new \Zend_Db_Expr(1),
]);
}

$query = parent::assemble();

return $query;
}

/**
* @param TableInterface $table
*
* @return bool
*/
public function joinTable($table)
{
if (in_array($table->getName(), $this->joinedTablesPool)) {
return true;
}

$relations = $this->selectService->joinWay($this->baseTable, $table);

$isJoined = $relations ? true : false;

/** @var RelationInterface $relation */
foreach ($relations as $relation) {
if (!in_array($relation->getRightTable()->getName(), $this->joinedTablesPool)) {
$isJoined = $this->doJoinTable($relation->getRightTable(), $relation) ? $isJoined : false;
}

if (!in_array($relation->getLeftTable()->getName(), $this->joinedTablesPool)) {
$isJoined = $this->doJoinTable($relation->getLeftTable(), $relation) ? $isJoined : false;
}
}


return $isJoined;
}

/**
* Join $tbl to current select based on relation condition.
*
* @param TableInterface $table
* @param RelationInterface $relation
*
* @return Select
*/
private function doJoinTable(TableInterface $table, RelationInterface $relation)
{
$this->selectService->replicateTable($table, $this->baseTable);

if ($this->leftJoin(
[$table->getName() => $table->isTmp()
? $table->getName()
: $this->resource->getTableName($table->getName()),
],
$relation->getCondition(),
[]
)) {
$this->usedRelationsPool[] = $relation;
}

return $this;
}

/**
* @param array $name
* @param string $cond
* @param string $cols
*
* @return bool
*/
public function leftJoin($name, $cond, $cols = '*')
{
if (count($this->joinedTablesPool) > 50) {
throw new \LogicException("Too many tables for join");
}

$n = implode('-', array_merge(array_keys($name), array_values($name)));

if (!in_array($n, $this->joinedTablesPool)) {
$this->joinedTablesPool[] = $n;
$this->joinedTablesPool[] = array_keys($name)[0];

parent::joinLeft($name, $cond, $cols);

return true;
}

return false;
}

/**
* @param array $name
* @param string $cond
* @param string $cols
*
* @return bool
*/
public function rightJoin($name, $cond, $cols = '*')
{
if (count($this->joinedTablesPool) > 50) {
throw new \LogicException("Too many tables for join");
}

$n = implode('-', array_merge(array_keys($name), array_values($name)));

if (!in_array($n, $this->joinedTablesPool)) {
$this->joinedTablesPool[] = $n;

parent::joinRight($name, $cond, $cols);

return true;
}

return false;
}

/**
* @param TableInterface $table
*
* @return bool
*/
public function isJoined(TableInterface $table)
{
foreach ($this->joinedTablesPool as $t) {
if ($t === $table->getName()) {
return true;
}
}

return false;
}
}