<?php
/**
* @copyright: Copyright © 2017 Firebear Studio. All rights reserved.
* @author : Firebear Studio <fbeardev@gmail.com>
*/

namespace Firebear\ImportExport\Model\Import\Source;

use Firebear\ImportExport\Exception\XmlException as FirebearXmlException;
use Firebear\ImportExport\Model\Source\Platform\PlatformInterface;
use Firebear\ImportExport\Traits\Import\Map as ImportMap;
use Magento\Framework\Exception\LocalizedException;
use Magento\Framework\Filesystem\Directory\Read as Directory;
use Magento\ImportExport\Model\Import\AbstractSource;
use SimpleXMLIterator;

/**
* XML Import Adapter
*/
class Xml extends AbstractSource
{
use ImportMap;

const CREATE_ATTRIBUTE = 'create_attribute';

/**
* @var SimpleXMLIterator
*/
protected $reader;

private $lastRead;

private $elementStack;

protected $maps;

protected $extension = 'xml';

protected $mimeTypes = [
'text/xml',
'text/plain',
'application/excel',
'application/xml',
'application/vnd.ms-excel',
'application/vnd.msexcel'
];

/**
* Platform
*
* @var \Firebear\ImportExport\Model\Source\Platform\PlatformInterface
*/
protected $platform;

/**
* Iterator Lock Flag
*
* @var bool
*/
protected $_lock = false;

/**
* Prepared Items
*
* @var array
*/
protected $_items = [];

/**
* Object attributes
*
* @var array
*/
protected $_data = [];

/**
* Initialize Adapter
*
* @param array $file
* @param Directory $directory
* @param PlatformInterface $platform
* @param array $data
*
* @throws LocalizedException
* @throws FirebearXmlException
*/
public function __construct(
$file,
Directory $directory,
PlatformInterface $platform = null,
$data = []
) {
$this->_data = $data;
$filePath = $file;
if (0 !== strpos($file, $directory->getAbsolutePath())) {
$filePath = $directory->getAbsolutePath($file);
}

$result = $this->checkMimeType($filePath);

if ($result !== true) {
throw new LocalizedException($result);
}

libxml_use_internal_errors(true);

$this->platform = $platform;
$this->reader = simplexml_load_file(
$filePath,
SimpleXMLIterator::class
);

if (false === $this->reader) {
throw new FirebearXmlException(libxml_get_errors());
}

$this->reader->rewind();

$this->getColumns();
parent::__construct(
$this->_colNames
);
}

/**
* Close file handle
*
* @return void
*/
public function destruct()
{
$this->reader->close();
}

/**
* Read next item from XML-file
*
* @return array
*/
protected function _getNextRow()
{
$parsed = [];
/* reader prepared items */
if ($this->_lock) {
foreach ($this->_items as $field => $items) {
foreach ($items as $key => $item) {
$parsed[$field] = $item;
unset($this->_items[$field][$key]);
break;
}
if (0 == count($this->_items[$field])) {
unset($this->_items[$field]);
}
break;
}
if (0 == count($this->_items)) {
$this->_items = [];
$this->_lock = false;
}
return $parsed;
} elseif ($this->reader->hasChildren()) {
foreach ($this->reader->getChildren() as $name => $data) {
if ($name == self::CREATE_ATTRIBUTE) {
$text = 'attribute';
$valueText = '';
foreach ($data as $nameAttribute => $valueAttribute) {
if ($nameAttribute != 'value') {
$text .= "|" . $nameAttribute . ":" . (string)$valueAttribute;
} else {
$valueText = (string)$valueAttribute;
}
}
$parsed[$text] = $valueText;
continue;
} elseif (isset($data->item)) { /* prepare child children */
$key = (string)$name;
$this->_items[$key] = [];
foreach ($data->item as $itemField) {
$item = [];
foreach ($itemField as $field => $fieldValue) {
$field = (string)$field;
if (isset($fieldValue->item)) {
$subKey = $key . '_' . $field;
$this->_items[$subKey] = [];
foreach ($fieldValue->item as $subItemField) {
$subItem = [];
foreach ($subItemField as $subField => $subFieldValue) {
$subItem[(string)$subField] = (string)$subFieldValue;
}
$this->_items[$subKey][] = $subItem;
}
$item[$field] = '';
} else {
$item[$field] = (string)$fieldValue;
}
}
$this->_items[$key][] = $item;
}
$value = '';
} else {
$value = (string)$data;
if (strpos($value, "'") !== false) {
$this->_foundWrongQuoteFlag = true;
}
}
$parsed[$name] = $value;
}
$this->_lock = (0 < count($this->_items)) ? true : false;
}
return $parsed;
}

/**
* Return Columns List
*
* @return array
*/
protected function getColumns()
{
for ($this->reader->rewind(); $this->reader->valid(); $this->reader->next()) {
$colNames = array_keys($this->_getNextRow());
if (count(array_unique($colNames)) != count($colNames)) {
throw new \InvalidArgumentException('Duplicates found in column names: ' . var_export($colNames, 1));
}
$diffArray = array_diff($colNames, $this->_colNames);
$this->_colNames = array_merge($this->_colNames, $diffArray);
$this->_colQty = count($this->_colNames);
}
}

/**
* Rewind the \Iterator to the first element (\Iterator interface)
*
* @return void
*/
public function rewind()
{
$this->_key = -1;
$this->_row = [];
$this->_items = [];
$this->_lock = false;
$this->reader->rewind();
$row = $this->_getNextRow();
$this->_row = $row;
}

/**
* Return the current element
*
* @return array
*/
public function current()
{
$row = $this->_row;
$diffArray = array_diff($this->_colNames, array_keys($row));
if (count($diffArray)) {
foreach ($diffArray as $name) {
$row[$name] = '';
}
}
return $this->replaceValue($this->changeFields($row));
}

/**
* Move forward to next element (\Iterator interface)
*
* @return void
*/
public function next()
{
if (!$this->_lock) {
$this->reader->next();
}
parent::next();
}

/**
* Checks if current position is valid (\Iterator interface)
*
* @return bool
*/
public function valid()
{
return $this->_lock ? true : $this->reader->valid();
}

/**
* @return mixed
*/
public function getColNames()
{
return $this->replaceColumns($this->_colNames);
}

/**
* @param $platform
* @return $this
*/
public function setPlatform($platform)
{
$this->platform = $platform;

return $this;
}

/**
* @return mixed
*/
public function getPlatform()
{
return $this->platform;
}
}