<?php
/*
* 2007-2016 PrestaShop
*
* NOTICE OF LICENSE
*
* This source file is subject to the Open Software License (OSL 3.0)
* that is bundled with this package in the file LICENSE.txt.
* It is also available through the world-wide-web at this URL:
* http://opensource.org/licenses/osl-3.0.php
* If you did not receive a copy of the license and are unable to
* obtain it through the world-wide-web, please send an email
* to license@prestashop.com so we can send you a copy immediately.
*
* DISCLAIMER
*
* Do not edit or add to this file if you wish to upgrade PrestaShop to newer
* versions in the future. If you wish to customize PrestaShop for your
* needs please refer to http://www.prestashop.com for more information.
*
*  @author PrestaShop SA <contact@prestashop.com>
*  @copyright  2007-2016 PrestaShop SA
*  @license    http://opensource.org/licenses/osl-3.0.php  Open Software License (OSL 3.0)
*  International Registered Trademark & Property of PrestaShop SA
*/

class InstallXmlLoader
{
    /**
     * @var InstallLanguages
     */
    protected $language;

    /**
     * @var array List of languages stored as array(id_lang => iso)
     */
    protected $languages = array();

    /**
     * @var array Store in cache all loaded XML files
     */
    protected $cache_xml_entity = array();

    /**
     * @var array List of errors
     */
    protected $errors = array();

    protected $data_path;
    protected $lang_path;
    protected $img_path;
    public $path_type;

    protected $ids = array();

    protected $primaries = array();

    protected $delayed_inserts = array();

    public function __construct()
    {
        $this->language = InstallLanguages::getInstance();
        $this->setDefaultPath();
    }

    /**
     * Set list of installed languages
     *
     * @param array $languages array(id_lang => iso)
     */
    public function setLanguages(array $languages)
    {
        $this->languages = $languages;
    }

    public function setDefaultPath()
    {
        $this->path_type = 'common';
        $this->data_path = _PS_INSTALL_DATA_PATH_.'xml/';
        $this->lang_path = _PS_INSTALL_LANGS_PATH_;
        $this->img_path = _PS_INSTALL_DATA_PATH_.'img/';
    }

    public function setFixturesPath($path = null)
    {
        if ($path === null) {
            $path = _PS_INSTALL_FIXTURES_PATH_.'fashion/';
        }

        $this->path_type = 'fixture';
        $this->data_path = $path.'data/';
        $this->lang_path = $path.'langs/';
        $this->img_path = $path.'img/';
    }

    /**
     * Get list of errors
     *
     * @return array
     */
    public function getErrors()
    {
        return $this->errors;
    }

    /**
     * Add an error
     *
     * @param string $error
     */
    public function setError($error)
    {
        $this->errors[] = $error;
    }

    /**
     * Store an ID related to an entity and its identifier (E.g. we want to save that product with ID "ipod_nano" has the ID 1)
     *
     * @param string $entity
     * @param string $identifier
     * @param int $id
     */
    public function storeId($entity, $identifier, $id)
    {
        $this->ids[$entity.':'.$identifier] = $id;
    }

    /**
     * Retrieve an ID related to an entity and its identifier
     *
     * @param string $entity
     * @param string $identifier
     */
    public function retrieveId($entity, $identifier)
    {
        return isset($this->ids[$entity.':'.$identifier]) ? $this->ids[$entity.':'.$identifier] : 0;
    }

    public function getIds()
    {
        return $this->ids;
    }

    public function setIds($ids)
    {
        $this->ids = $ids;
    }

    public function getSortedEntities()
    {
        // Browse all XML files from data/xml directory
        $entities = array();
        $dependencies = array();
        $fd = opendir($this->data_path);
        while ($file = readdir($fd)) {
            if (preg_match('#^(.+)\.xml$#', $file, $m)) {
                $entity = $m[1];
                $xml = $this->loadEntity($entity);

                // Store entities dependencies (with field type="relation")
                if ($xml->fields) {
                    foreach ($xml->fields->field as $field) {
                        if ($field['relation'] && $field['relation'] != $entity) {
                            if (!isset($dependencies[(string)$field['relation']])) {
                                $dependencies[(string)$field['relation']] = array();
                            }
                            $dependencies[(string)$field['relation']][] = $entity;
                        }
                    }
                }
                $entities[] = $entity;
            }
        }
        closedir($fd);

        // Sort entities to populate database in good order (E.g. zones before countries)
        do {
            $current = (isset($sort_entities)) ? $sort_entities : array();
            $sort_entities = array();
            foreach ($entities as $key => $entity) {
                if (isset($dependencies[$entity])) {
                    $min = count($entities) - 1;
                    foreach ($dependencies[$entity] as $item) {
                        if (($key = array_search($item, $sort_entities)) !== false) {
                            $min = min($min, $key);
                        }
                    }
                    if ($min == 0) {
                        array_unshift($sort_entities, $entity);
                    } else {
                        array_splice($sort_entities, $min, 0, array($entity));
                    }
                } else {
                    $sort_entities[] = $entity;
                }
            }
            $entities = $sort_entities;
        } while ($current != $sort_entities);

        return $sort_entities;
    }

    /**
     * Read all XML files from data folder and populate tables
     */
    public function populateFromXmlFiles()
    {
        $entities = $this->getSortedEntities();

        // Populate entities
        foreach ($entities as $entity) {
            $this->populateEntity($entity);
        }
    }

    /**
     * Populate an entity
     *
     * @param string $entity
     */
    public function populateEntity($entity)
    {
        if (method_exists($this, 'populateEntity'.Tools::toCamelCase($entity))) {
            $this->{'populateEntity'.Tools::toCamelCase($entity)}();
            return;
        }

        if (substr($entity, 0, 1) == '.' || substr($entity, 0, 1) == '_') {
            return;
        }

        $xml = $this->loadEntity($entity);

        // Read list of fields
        if (!is_object($xml) || !$xml->fields) {
            throw new PrestashopInstallerException('List of fields not found for entity '.$entity);
        }

        if ($this->isMultilang($entity)) {
            $multilang_columns = $this->getColumns($entity, true);
            $xml_langs = array();
            $default_lang = null;
            foreach ($this->languages as $id_lang => $iso) {
                if ($iso == $this->language->getLanguageIso()) {
                    $default_lang = $id_lang;
                }

                try {
                    $xml_langs[$id_lang] = $this->loadEntity($entity, $iso);
                } catch (PrestashopInstallerException $e) {
                    $xml_langs[$id_lang] = null;
                }
            }
        }

        // Load all row for current entity and prepare data to be populated
        foreach ($xml->entities->$entity as $node) {
            $data = array();
            $identifier = (string)$node['id'];

            // Read attributes
            foreach ($node->attributes() as $k => $v) {
                if ($k != 'id') {
                    $data[$k] = (string)$v;
                }
            }

            // Read cdatas
            foreach ($node->children() as $child) {
                $data[$child->getName()] = (string)$child;
            }

            // Load multilang data
            $data_lang = array();
            if ($this->isMultilang($entity)) {
                $xpath_query = $entity.'[@id="'.$identifier.'"]';
                foreach ($xml_langs as $id_lang => $xml_lang) {
                    if (!$xml_lang) {
                        continue;
                    }

                    if (($node_lang = $xml_lang->xpath($xpath_query)) || ($node_lang = $xml_langs[$default_lang]->xpath($xpath_query))) {
                        $node_lang = $node_lang[0];
                        foreach ($multilang_columns as $column => $is_text) {
                            $value = '';
                            if ($node_lang[$column]) {
                                $value = (string)$node_lang[$column];
                            }

                            if ($node_lang->$column) {
                                $value = (string)$node_lang->$column;
                            }
                            $data_lang[$column][$id_lang] = $value;
                        }
                    }
                }
            }

            $data = $this->rewriteRelationedData($entity, $data);
            if (method_exists($this, 'createEntity'.Tools::toCamelCase($entity))) {
                // Create entity with custom method in current class
                $method = 'createEntity'.Tools::toCamelCase($entity);
                $this->$method($identifier, $data, $data_lang);
            } else {
                $this->createEntity($entity, $identifier, (string)$xml->fields['class'], $data, $data_lang);
            }

            if ($xml->fields['image']) {
                if (method_exists($this, 'copyImages'.Tools::toCamelCase($entity))) {
                    $this->{'copyImages'.Tools::toCamelCase($entity)}($identifier, $data);
                } else {
                    $this->copyImages($entity, $identifier, (string)$xml->fields['image'], $data);
                }
            }
        }

        $this->flushDelayedInserts();
        unset($this->cache_xml_entity[$this->path_type][$entity]);
    }

    protected function getFallBackToDefaultLanguage($iso)
    {
        return file_exists($this->lang_path.$iso.'/data/') ? $iso : 'en';
    }

    /**
     * Special case for "tag" entity
     */
    public function populateEntityTag()
    {
        foreach ($this->languages as $id_lang => $iso) {
            if (!file_exists($this->lang_path.$this->getFallBackToDefaultLanguage($iso).'/data/tag.xml')) {
                continue;
            }

            $xml = $this->loadEntity('tag', $this->getFallBackToDefaultLanguage($iso));
            $tags = array();
            foreach ($xml->tag as $tag_node) {
                $products = trim((string)$tag_node['products']);
                if (!$products) {
                    continue;
                }

                foreach (explode(',', $products) as $product) {
                    $product = trim($product);
                    $product_id = $this->retrieveId('product', $product);
                    if (!isset($tags[$product_id])) {
                        $tags[$product_id] = array();
                    }
                    $tags[$product_id][] = trim((string)$tag_node['name']);
                }
            }

            foreach ($tags as $id_product => $tag_list) {
                Tag::addTags($id_lang, $id_product, $tag_list);
            }
        }
    }

    /**
     * Load an entity XML file
     *
     * @param string $entity
     * @return SimpleXMLElement
     */
    protected function loadEntity($entity, $iso = null)
    {
        if (!isset($this->cache_xml_entity[$this->path_type][$entity][$iso])) {
            if (substr($entity, 0, 1) == '.' || substr($entity, 0, 1) == '_') {
                return;
            }

            $path = $this->data_path.$entity.'.xml';
            if ($iso) {
                $path = $this->lang_path.$this->getFallBackToDefaultLanguage($iso).'/data/'.$entity.'.xml';
            }

            if (!file_exists($path)) {
                throw new PrestashopInstallerException('XML data file '.$entity.'.xml not found');
            }

            $this->cache_xml_entity[$this->path_type][$entity][$iso] = @simplexml_load_file($path, 'InstallSimplexmlElement');
            if (!$this->cache_xml_entity[$this->path_type][$entity][$iso]) {
                throw new PrestashopInstallerException('XML data file '.$entity.'.xml invalid');
            }
        }

        return $this->cache_xml_entity[$this->path_type][$entity][$iso];
    }

    /**
     * Check fields related to an other entity, and replace their values by the ID created by the other entity
     *
     * @param string $entity
     * @param array $data
     */
    protected function rewriteRelationedData($entity, array $data)
    {
        $xml = $this->loadEntity($entity);
        foreach ($xml->fields->field as $field) {
            if ($field['relation']) {
                $id = $this->retrieveId((string)$field['relation'], $data[(string)$field['name']]);
                if (!$id && $data[(string)$field['name']] && is_numeric($data[(string)$field['name']])) {
                    $id = $data[(string)$field['name']];
                }
                $data[(string)$field['name']] = $id;
            }
        }
        return $data;
    }

    public function flushDelayedInserts()
    {
        foreach ($this->delayed_inserts as $entity => $queries) {
            $type = Db::INSERT_IGNORE;
            if ($entity == 'access') {
                $type = Db::REPLACE;
            }

            if (!Db::getInstance()->insert($entity, $queries, false, true, $type)) {
                $this->setError($this->language->l('An SQL error occurred for entity <i>%1$s</i>: <i>%2$s</i>', $entity, Db::getInstance()->getMsgError()));
            }
            unset($this->delayed_inserts[$entity]);
        }
    }

    /**
     * Create a simple entity with all its data and lang data
     * If a methode createEntity$entity exists, use it. Else if $classname is given, use it. Else do a simple insert in database.
     *
     * @param string $entity
     * @param string $identifier
     * @param string $classname
     * @param array $data
     * @param array $data_lang
     */
    public function createEntity($entity, $identifier, $classname, array $data, array $data_lang = array())
    {
        $xml = $this->loadEntity($entity);
        if ($classname) {
            // Create entity with ObjectModel class
            $object = new $classname();
            $object->hydrate($data);
            if ($data_lang) {
                $object->hydrate($data_lang);
            }
            $object->add(true, (isset($xml->fields['null'])) ? true : false);
            $entity_id = $object->id;
            unset($object);
        } else {
            // Generate primary key manually
            $primary = '';
            $entity_id = 0;
            if (!$xml->fields['primary']) {
                $primary = 'id_'.$entity;
            } elseif (strpos((string)$xml->fields['primary'], ',') === false) {
                $primary = (string)$xml->fields['primary'];
            }
            unset($xml);

            if ($primary) {
                $entity_id = $this->generatePrimary($entity, $primary);
                $data[$primary] = $entity_id;
            }

            // Store INSERT queries in order to optimize install with grouped inserts
            $this->delayed_inserts[$entity][] = array_map('pSQL', $data);
            if ($data_lang) {
                $real_data_lang = array();
                foreach ($data_lang as $field => $list) {
                    foreach ($list as $id_lang => $value) {
                        $real_data_lang[$id_lang][$field] = $value;
                    }
                }

                foreach ($real_data_lang as $id_lang => $insert_data_lang) {
                    $insert_data_lang['id_'.$entity] = $entity_id;
                    $insert_data_lang['id_lang'] = $id_lang;
                    $this->delayed_inserts[$entity.'_lang'][] = array_map('pSQL', $insert_data_lang);
                }

                // Store INSERT queries for _shop associations
                $entity_asso = Shop::getAssoTable($entity);
                if ($entity_asso !== false && $entity_asso['type'] == 'shop') {
                    $this->delayed_inserts[$entity.'_shop'][] = array(
                        'id_shop' => 1,
                        'id_'.$entity => $entity_id,
                    );
                }
            }
        }

        $this->storeId($entity, $identifier, $entity_id);
    }

    public function createEntityConfiguration($identifier, array $data, array $data_lang)
    {
        if (Db::getInstance()->getValue('SELECT id_configuration FROM '._DB_PREFIX_.'configuration WHERE name = \''.pSQL($data['name']).'\'')) {
            return;
        }

        $entity = 'configuration';
        $entity_id = $this->generatePrimary($entity, 'id_configuration');
        $data['id_configuration'] = $entity_id;

        // Store INSERT queries in order to optimize install with grouped inserts
        $this->delayed_inserts[$entity][] = array_map('pSQL', $data);
        if ($data_lang) {
            $real_data_lang = array();
            foreach ($data_lang as $field => $list) {
                foreach ($list as $id_lang => $value) {
                    $real_data_lang[$id_lang][$field] = $value;
                }
            }

            foreach ($real_data_lang as $id_lang => $insert_data_lang) {
                $insert_data_lang['id_'.$entity] = $entity_id;
                $insert_data_lang['id_lang'] = $id_lang;
                $this->delayed_inserts[$entity.'_lang'][] = array_map('pSQL', $insert_data_lang);
            }
        }

        $this->storeId($entity, $identifier, $entity_id);
    }
    
    public function createEntityStockAvailable($identifier, array $data, array $data_lang)
    {
        $stock_available = new StockAvailable();
        $stock_available->updateQuantity($data['id_product'], $data['id_product_attribute'], $data['quantity'], $data['id_shop']);
    }

    public function createEntityTab($identifier, array $data, array $data_lang)
    {
        static $position = array();

        $entity = 'tab';
        $xml = $this->loadEntity($entity);

        if (!isset($position[$data['id_parent']])) {
            $position[$data['id_parent']] = 0;
        }
        $data['position'] = $position[$data['id_parent']]++;

        // Generate primary key manually
        $primary = '';
        $entity_id = 0;
        if (!$xml->fields['primary']) {
            $primary = 'id_'.$entity;
        } elseif (strpos((string)$xml->fields['primary'], ',') === false) {
            $primary = (string)$xml->fields['primary'];
        }

        if ($primary) {
            $entity_id = $this->generatePrimary($entity, $primary);
            $data[$primary] = $entity_id;
        }

        // Store INSERT queries in order to optimize install with grouped inserts
        $this->delayed_inserts[$entity][] = array_map('pSQL', $data);
        if ($data_lang) {
            $real_data_lang = array();
            foreach ($data_lang as $field => $list) {
                foreach ($list as $id_lang => $value) {
                    $real_data_lang[$id_lang][$field] = $value;
                }
            }

            foreach ($real_data_lang as $id_lang => $insert_data_lang) {
                $insert_data_lang['id_'.$entity] = $entity_id;
                $insert_data_lang['id_lang'] = $id_lang;
                $this->delayed_inserts[$entity.'_lang'][] = array_map('pSQL', $insert_data_lang);
            }
        }

        $this->storeId($entity, $identifier, $entity_id);
    }

    public function generatePrimary($entity, $primary)
    {
        if (!isset($this->primaries[$entity])) {
            $this->primaries[$entity] = (int)Db::getInstance()->getValue('SELECT '.$primary.' FROM '._DB_PREFIX_.$entity.' ORDER BY '.$primary.' DESC');
        }
        return ++$this->primaries[$entity];
    }

    public function copyImages($entity, $identifier, $path, array $data, $extension = 'jpg')
    {
        // Get list of image types
        $reference = array(
            'product' => 'products',
            'category' => 'categories',
            'manufacturer' => 'manufacturers',
            'supplier' => 'suppliers',
            'scene' => 'scenes',
            'store' => 'stores',
        );

        $types = array();
        if (isset($reference[$entity])) {
            $types = ImageType::getImagesTypes($reference[$entity]);
        }

        // For each path copy images
        $path = array_map('trim', explode(',', $path));
        foreach ($path as $p) {
            $from_path = $this->img_path.$p.'/';
            $dst_path =  _PS_IMG_DIR_.$p.'/';
            $entity_id = $this->retrieveId($entity, $identifier);

            if (!@copy($from_path.$identifier.'.'.$extension, $dst_path.$entity_id.'.'.$extension)) {
                $this->setError($this->language->l('Cannot create image "%1$s" for entity "%2$s"', $identifier, $entity));
                return;
            }

            foreach ($types as $type) {
                $origin_file = $from_path.$identifier.'-'.$type['name'].'.'.$extension;
                $target_file = $dst_path.$entity_id.'-'.$type['name'].'.'.$extension;

                // Test if dest folder is writable
                if (!is_writable(dirname($target_file))) {
                    $this->setError($this->language->l('Cannot create image "%1$s" (bad permissions on folder "%2$s")', $identifier.'-'.$type['name'], dirname($target_file)));
                }
                // If a file named folder/entity-type.extension exists just copy it, this is an optimisation in order to prevent to much resize
                elseif (file_exists($origin_file)) {
                    if (!@copy($origin_file, $target_file)) {
                        $this->setError($this->language->l('Cannot create image "%s"', $identifier.'-'.$type['name']));
                    }
                    @chmod($target_file, 0644);
                }
                // Resize the image if no cache was prepared in fixtures
                elseif (!ImageManager::resize($from_path.$identifier.'.'.$extension, $target_file, $type['width'], $type['height'])) {
                    $this->setError($this->language->l('Cannot create image "%1$s" for entity "%2$s"', $identifier.'-'.$type['name'], $entity));
                }
            }
        }
        Image::moveToNewFileSystem();
    }

    public function copyImagesScene($identifier, array $data)
    {
        $this->copyImages('scene', $identifier, 'scenes', $data);

        $from_path = $this->img_path.'scenes/thumbs/';
        $dst_path =  _PS_IMG_DIR_.'scenes/thumbs/';
        $entity_id = $this->retrieveId('scene', $identifier);

        if (!@copy($from_path.$identifier.'-m_scene_default.jpg', $dst_path.$entity_id.'-m_scene_default.jpg')) {
            $this->setError($this->language->l('Cannot create image "%1$s" for entity "%2$s"', $identifier, 'scene'));
            return;
        }
    }

    public function copyImagesOrderState($identifier, array $data)
    {
        $this->copyImages('order_state', $identifier, 'os', $data, 'gif');
    }

    public function copyImagesTab($identifier, array $data)
    {
        $from_path = $this->img_path.'t/';
        $dst_path =  _PS_IMG_DIR_.'t/';
        if (file_exists($from_path.$data['class_name'].'.gif') && !file_exists($dst_path.$data['class_name'].'.gif')) {
            //test if file exist in install dir and if do not exist in dest folder.
            if (!@copy($from_path.$data['class_name'].'.gif', $dst_path.$data['class_name'].'.gif')) {
                $this->setError($this->language->l('Cannot create image "%1$s" for entity "%2$s"', $identifier, 'tab'));
                return;
            }
        }
    }

    public function copyImagesImage($identifier)
    {
        $path = $this->img_path.'p/';
        $image = new Image($this->retrieveId('image', $identifier));
        $dst_path = $image->getPathForCreation();
        if (!@copy($path.$identifier.'.jpg', $dst_path.'.'.$image->image_format)) {
            $this->setError($this->language->l('Cannot create image "%1$s" for entity "%2$s"', $identifier, 'product'));
            return;
        }
        @chmod($dst_path.'.'.$image->image_format, 0644);

        $types = ImageType::getImagesTypes('products');
        foreach ($types as $type) {
            $origin_file = $path.$identifier.'-'.$type['name'].'.jpg';
            $target_file = $dst_path.'-'.$type['name'].'.'.$image->image_format;

            // Test if dest folder is writable
            if (!is_writable(dirname($target_file))) {
                $this->setError($this->language->l('Cannot create image "%1$s" (bad permissions on folder "%2$s")', $identifier.'-'.$type['name'], dirname($target_file)));
            }
            // If a file named folder/entity-type.jpg exists just copy it, this is an optimisation in order to prevent to much resize
            elseif (file_exists($origin_file)) {
                if (!@copy($origin_file, $target_file)) {
                    $this->setError($this->language->l('Cannot create image "%1$s" for entity "%2$s"', $identifier.'-'.$type['name'], 'product'));
                }
                @chmod($target_file, 0644);
            }
            // Resize the image if no cache was prepared in fixtures
            elseif (!ImageManager::resize($path.$identifier.'.jpg', $target_file, $type['width'], $type['height'])) {
                $this->setError($this->language->l('Cannot create image "%1$s" for entity "%2$s"', $identifier.'-'.$type['name'], 'product'));
            }
        }
    }

    public function getTables()
    {
        static $tables = null;

        if (is_null($tables)) {
            $tables = array();
            foreach (Db::getInstance()->executeS('SHOW TABLES') as $row) {
                $table = current($row);
                if (preg_match('#^'._DB_PREFIX_.'(.+?)(_lang)?$#i', $table, $m)) {
                    $tables[$m[1]] = (isset($m[2]) && $m[2]) ? true : false;
                }
            }
        }

        return $tables;
    }

    public function hasElements($table)
    {
        return (bool)Db::getInstance()->getValue('SELECT COUNT(*) FROM '._DB_PREFIX_.$table);
    }

    public function getColumns($table, $multilang = false, array $exclude = array())
    {
        static $columns = array();

        if ($multilang) {
            return ($this->isMultilang($table)) ? $this->getColumns($table.'_lang', false, array('id_'.$table)) : array();
        }

        if (!isset($columns[$table])) {
            $columns[$table] = array();
            $sql = 'SHOW COLUMNS FROM `'._DB_PREFIX_.bqSQL($table).'`';
            foreach (Db::getInstance()->executeS($sql) as $row) {
                $columns[$table][$row['Field']] = $this->checkIfTypeIsText($row['Type']);
            }
        }

        $exclude = array_merge(array('id_'.$table, 'date_add', 'date_upd', 'deleted', 'id_lang'), $exclude);

        $list = array();
        foreach ($columns[$table] as $k => $v) {
            if (!in_array($k, $exclude)) {
                $list[$k] = $v;
            }
        }

        return $list;
    }

    public function getClasses($path = null)
    {
        static $cache = null;

        if (!is_null($cache)) {
            return $cache;
        }

        $dir = $path;
        if (is_null($dir)) {
            $dir = _PS_CLASS_DIR_;
        }

        $classes = array();
        foreach (scandir($dir) as $file) {
            if ($file[0] != '.' && $file != 'index.php') {
                if (is_dir($dir.$file)) {
                    $classes = array_merge($classes, $this->getClasses($dir.$file.'/'));
                } elseif (preg_match('#^(.+)\.php$#', $file, $m)) {
                    $classes[] = $m[1];
                }
            }
        }

        sort($classes);
        if (is_null($path)) {
            $cache = $classes;
        }
        return $classes;
    }

    public function checkIfTypeIsText($type)
    {
        if (preg_match('#^(longtext|text|tinytext)#i', $type)) {
            return true;
        }

        if (preg_match('#^varchar\(([0-9]+)\)$#i', $type, $m)) {
            return intval($m[1]) >= 64 ? true : false;
        }
        return false;
    }

    public function isMultilang($entity)
    {
        $tables = $this->getTables();
        return isset($tables[$entity]) && $tables[$entity];
    }

    public function entityExists($entity)
    {
        return file_exists($this->data_path.$entity.'.xml');
    }

    public function getEntitiesList()
    {
        $entities = array();
        foreach (scandir($this->data_path) as $file) {
            if ($file[0] != '.' && preg_match('#^(.+)\.xml$#', $file, $m)) {
                $entities[] = $m[1];
            }
        }
        return $entities;
    }

    public function getEntityInfo($entity)
    {
        $info = array(
            'config' => array(
                'id' =>        '',
                'primary' =>    '',
                'class' =>        '',
                'sql' =>        '',
                'ordersql' =>    '',
                'image' =>        '',
                'null' =>        '',
            ),
            'fields' =>    array(),
        );

        if (!$this->entityExists($entity)) {
            return $info;
        }

        $xml = @simplexml_load_file($this->data_path.$entity.'.xml', 'InstallSimplexmlElement');
        if (!$xml) {
            return $info;
        }

        if ($xml->fields['id']) {
            $info['config']['id'] = (string)$xml->fields['id'];
        }

        if ($xml->fields['primary']) {
            $info['config']['primary'] = (string)$xml->fields['primary'];
        }

        if ($xml->fields['class']) {
            $info['config']['class'] = (string)$xml->fields['class'];
        }

        if ($xml->fields['sql']) {
            $info['config']['sql'] = (string)$xml->fields['sql'];
        }

        if ($xml->fields['ordersql']) {
            $info['config']['ordersql'] = (string)$xml->fields['ordersql'];
        }

        if ($xml->fields['null']) {
            $info['config']['null'] = (string)$xml->fields['null'];
        }

        if ($xml->fields['image']) {
            $info['config']['image'] = (string)$xml->fields['image'];
        }

        foreach ($xml->fields->field as $field) {
            $column = (string)$field['name'];
            $info['fields'][$column] = array();
            if (isset($field['relation'])) {
                $info['fields'][$column]['relation'] = (string)$field['relation'];
            }
        }
        return $info;
    }

    public function getDependencies()
    {
        $entities = array();
        foreach ($this->getEntitiesList() as $entity) {
            $entities[$entity] = $this->getEntityInfo($entity);
        }

        $dependencies = array();
        foreach ($entities as $entity => $info) {
            foreach ($info['fields'] as $field => $info_field) {
                if (isset($info_field['relation']) && $info_field['relation'] != $entity) {
                    if (!isset($dependencies[$info_field['relation']])) {
                        $dependencies[$info_field['relation']] = array();
                    }
                    $dependencies[$info_field['relation']][] = $entity;
                }
            }
        }

        return $dependencies;
    }

    public function generateEntitySchema($entity, array $fields, array $config)
    {
        if ($this->entityExists($entity)) {
            $xml = $this->loadEntity($entity);
        } else {
            $xml = new InstallSimplexmlElement('<entity_'.$entity.' />');
        }
        unset($xml->fields);

        // Fill <fields> attributes (config)
        $xml_fields = $xml->addChild('fields');
        foreach ($config as $k => $v) {
            if ($v) {
                $xml_fields[$k] = $v;
            }
        }

        // Create list of fields
        foreach ($fields as $column => $info) {
            $field = $xml_fields->addChild('field');
            $field['name'] = $column;
            if (isset($info['relation'])) {
                $field['relation'] = $info['relation'];
            }
        }

        // Recreate entities nodes, in order to have the <entities> node after the <fields> node
        $store_entities = clone $xml->entities;
        unset($xml->entities);
        $xml->addChild('entities', $store_entities);

        $xml->asXML($this->data_path.$entity.'.xml');
    }

    /**
     * ONLY FOR DEVELOPMENT PURPOSE
     */
    public function generateAllEntityFiles()
    {
        $entities = array();
        foreach ($this->getEntitiesList() as $entity) {
            $entities[$entity] = $this->getEntityInfo($entity);
        }
        $this->generateEntityFiles($entities);
    }

    /**
     * ONLY FOR DEVELOPMENT PURPOSE
     */
    public function generateEntityFiles($entities)
    {
        $dependencies = $this->getDependencies();

        // Sort entities to populate database in good order (E.g. zones before countries)
        do {
            $current = (isset($sort_entities)) ? $sort_entities : array();
            $sort_entities = array();
            foreach ($entities as $entity) {
                if (isset($dependencies[$entity])) {
                    $min = count($entities) - 1;
                    foreach ($dependencies[$entity] as $item) {
                        if (($key = array_search($item, $sort_entities)) !== false) {
                            $min = min($min, $key);
                        }
                    }
                    if ($min == 0) {
                        array_unshift($sort_entities, $entity);
                    } else {
                        array_splice($sort_entities, $min, 0, array($entity));
                    }
                } else {
                    $sort_entities[] = $entity;
                }
            }
            $entities = $sort_entities;
        } while ($current != $sort_entities);

        foreach ($sort_entities as $entity) {
            $this->generateEntityContent($entity);
        }
    }

    public function generateEntityContent($entity)
    {
        $xml = $this->loadEntity($entity);
        if (method_exists($this, 'getEntityContents'.Tools::toCamelCase($entity))) {
            $content = $this->{'getEntityContents'.Tools::toCamelCase($entity)}($entity);
        } else {
            $content = $this->getEntityContents($entity);
        }

        unset($xml->entities);
        $entities = $xml->addChild('entities');
        $this->createXmlEntityNodes($entity, $content['nodes'], $entities);
        $xml->asXML($this->data_path.$entity.'.xml');

        // Generate multilang XML files
        if ($content['nodes_lang']) {
            foreach ($content['nodes_lang'] as $id_lang => $nodes) {
                if (!isset($this->languages[$id_lang])) {
                    continue;
                }

                $iso = $this->languages[$id_lang];
                if (!is_dir($this->lang_path.$this->getFallBackToDefaultLanguage($iso).'/data')) {
                    mkdir($this->lang_path.$this->getFallBackToDefaultLanguage($iso).'/data');
                }

                $xml_node = new InstallSimplexmlElement('<entity_'.$entity.' />');
                $this->createXmlEntityNodes($entity, $nodes, $xml_node);
                $xml_node->asXML($this->lang_path.$this->getFallBackToDefaultLanguage($iso).'/data/'.$entity.'.xml');
            }
        }

        if ($xml->fields['image']) {
            if (method_exists($this, 'backupImage'.Tools::toCamelCase($entity))) {
                $this->{'backupImage'.Tools::toCamelCase($entity)}((string)$xml->fields['image']);
            } else {
                $this->backupImage($entity, (string)$xml->fields['image']);
            }
        }
    }

    /**
     * ONLY FOR DEVELOPMENT PURPOSE
     */
    public function getEntityContents($entity)
    {
        $xml = $this->loadEntity($entity);
        $primary = (isset($xml->fields['primary']) && $xml->fields['primary']) ? (string)$xml->fields['primary'] : 'id_'.$entity;
        $is_multilang = $this->isMultilang($entity);

        // Check if current table is an association table (if multiple primary keys)
        $is_association = false;
        if (strpos($primary, ',') !== false) {
            $is_association = true;
            $primary = array_map('trim', explode(',', $primary));
        }

        // Build query
        $sql = new DbQuery();
        $sql->select('a.*');
        $sql->from($entity, 'a');
        if ($is_multilang) {
            $sql->select('b.*');
            $sql->leftJoin($entity.'_lang', 'b', 'a.'.$primary.' = b.'.$primary);
        }

        if (isset($xml->fields['sql']) && $xml->fields['sql']) {
            $sql->where((string)$xml->fields['sql']);
        }

        if (!$is_association) {
            $sql->select('a.'.$primary);
            if (!isset($xml->fields['ordersql']) || !$xml->fields['ordersql']) {
                $sql->orderBy('a.'.$primary);
            }
        }

        if ($is_multilang && (!isset($xml->fields['ordersql']) || !$xml->fields['ordersql'])) {
            $sql->orderBy('b.id_lang');
        }

        if (isset($xml->fields['ordersql']) && $xml->fields['ordersql']) {
            $sql->orderBy((string)$xml->fields['ordersql']);
        }

        // Get multilang columns
        $alias_multilang = array();
        if ($is_multilang) {
            $columns = $this->getColumns($entity);
            $multilang_columns = $this->getColumns($entity, true);

            // If some columns from _lang table have same name than original table, rename them (E.g. value in configuration)
            foreach ($multilang_columns as $c => $is_text) {
                if (isset($columns[$c])) {
                    $alias = $c.'_alias';
                    $alias_multilang[$c] = $alias;
                    $sql->select('a.'.$c.' as '.$c.', b.'.$c.' as '.$alias);
                }
            }
        }

        // Get all results
        $nodes = $nodes_lang = array();
        $results = Db::getInstance()->executeS($sql);
        if (Db::getInstance()->getNumberError()) {
            $this->setError($this->language->l('SQL error on query <i>%s</i>', $sql));
        } else {
            foreach ($results as $row) {
                // Store common columns
                if ($is_association) {
                    $id = $entity;
                    foreach ($primary as $key) {
                        $id .= '_'.$row[$key];
                    }
                } else {
                    $id = $this->generateId($entity, $row[$primary], $row, (isset($xml->fields['id']) && $xml->fields['id']) ? (string)$xml->fields['id'] : null);
                }

                if (!isset($nodes[$id])) {
                    $node = array();
                    foreach ($xml->fields->field as $field) {
                        $column = (string)$field['name'];
                        if (isset($field['relation'])) {
                            $sql = 'SELECT `id_'.bqSQL($field['relation']).'`
									FROM `'.bqSQL(_DB_PREFIX_.$field['relation']).'`
									WHERE `id_'.bqSQL($field['relation']).'` = '.(int)$row[$column];
                            $node[$column] = $this->generateId((string)$field['relation'], Db::getInstance()->getValue($sql));

                            // A little trick to allow storage of some hard values, like '-1' for tab.id_parent
                            if (!$node[$column] && $row[$column]) {
                                $node[$column] = $row[$column];
                            }
                        } else {
                            $node[$column] = $row[$column];
                        }
                    }
                    $nodes[$id] = $node;
                }

                // Store multilang columns
                if ($is_multilang && $row['id_lang']) {
                    $node = array();
                    foreach ($multilang_columns as $column => $is_text) {
                        $node[$column] = $row[isset($alias_multilang[$column]) ? $alias_multilang[$column] : $column];
                    }
                    $nodes_lang[$row['id_lang']][$id] = $node;
                }
            }
        }

        return array(
            'nodes' =>        $nodes,
            'nodes_lang' =>    $nodes_lang,
        );
    }

    public function getEntityContentsTag()
    {
        $nodes_lang = array();

        $sql = 'SELECT t.id_tag, t.id_lang, t.name, pt.id_product
				FROM '._DB_PREFIX_.'tag t
				LEFT JOIN '._DB_PREFIX_.'product_tag pt ON t.id_tag = pt.id_tag
				ORDER BY id_lang';
        foreach (Db::getInstance()->executeS($sql) as $row) {
            $identifier = $this->generateId('tag', $row['id_tag']);
            if (!isset($nodes_lang[$row['id_lang']])) {
                $nodes_lang[$row['id_lang']] = array();
            }

            if (!isset($nodes_lang[$row['id_lang']][$identifier])) {
                $nodes_lang[$row['id_lang']][$identifier] = array(
                    'name' =>        $row['name'],
                    'products' =>    '',
                );
            }

            $nodes_lang[$row['id_lang']][$identifier]['products'] .= (($nodes_lang[$row['id_lang']][$identifier]['products']) ? ',' : '').$this->generateId('product', $row['id_product']);
        }

        return array(
            'nodes' =>        array(),
            'nodes_lang' => $nodes_lang,
        );
    }

    /**
     * ONLY FOR DEVELOPMENT PURPOSE
     */
    public function generateId($entity, $primary, array $row = array(), $id_format = null)
    {
        static $ids = array();

        if (isset($ids[$entity][$primary])) {
            return $ids[$entity][$primary];
        }

        if (!isset($ids[$entity])) {
            $ids[$entity] = array();
        }

        if (!$primary) {
            return '';
        }

        if (!$id_format || !$row || !$row[$id_format]) {
            $ids[$entity][$primary] = $entity.'_'.$primary;
        } else {
            $value = $row[$id_format];
            $value = preg_replace('#[^a-z0-9_-]#i', '_', $value);
            $value = preg_replace('#_+#', '_', $value);
            $value = preg_replace('#^_+#', '', $value);
            $value = preg_replace('#_+$#', '', $value);

            $store_identifier = $value;
            $i = 1;
            while (in_array($store_identifier, $ids[$entity])) {
                $store_identifier = $value.'_'.$i++;
            }
            $ids[$entity][$primary] = $store_identifier;
        }
        return $ids[$entity][$primary];
    }

    /**
     * ONLY FOR DEVELOPMENT PURPOSE
     */
    public function createXmlEntityNodes($entity, array $nodes, SimpleXMLElement $entities)
    {
        $types = array_merge($this->getColumns($entity), $this->getColumns($entity, true));
        foreach ($nodes as $id => $node) {
            $entity_node = $entities->addChild($entity);
            $entity_node['id'] = $id;
            foreach ($node as $k => $v) {
                if (isset($types[$k]) && $types[$k]) {
                    $entity_node->addChild($k, $v);
                } else {
                    $entity_node[$k] = $v;
                }
            }
        }
    }

    /**
     * ONLY FOR DEVELOPMENT PURPOSE
     */
    public function backupImage($entity, $path)
    {
        $reference = array(
            'product' => 'products',
            'category' => 'categories',
            'manufacturer' => 'manufacturers',
            'supplier' => 'suppliers',
            'scene' => 'scenes',
            'store' => 'stores',
        );

        $types = array();
        if (isset($reference[$entity])) {
            $types = array();
            foreach (ImageType::getImagesTypes($reference[$entity]) as $type) {
                $types[] = $type['name'];
            }
        }

        $path_list = array_map('trim', explode(',', $path));
        foreach ($path_list as $p) {
            $backup_path = $this->img_path.$p.'/';
            $from_path = _PS_IMG_DIR_.$p.'/';

            if (!is_dir($backup_path) && !mkdir($backup_path)) {
                $this->setError(sprintf('Cannot create directory <i>%s</i>', $backup_path));
            }

            foreach (scandir($from_path) as $file) {
                if ($file[0] != '.' && preg_match('#^(([0-9]+)(-('.implode('|', $types).'))?)\.(gif|jpg|jpeg|png)$#i', $file, $m)) {
                    $file_id = $m[2];
                    $file_type = $m[3];
                    $file_extension = $m[5];
                    copy($from_path.$file, $backup_path.$this->generateId($entity, $file_id).$file_type.'.'.$file_extension);
                }
            }
        }
    }

    /**
     * ONLY FOR DEVELOPMENT PURPOSE
     */
    public function backupImageImage()
    {
        $types = array();
        foreach (ImageType::getImagesTypes('products') as $type) {
            $types[] = $type['name'];
        }

        $backup_path = $this->img_path.'p/';
        $from_path = _PS_PROD_IMG_DIR_;
        if (!is_dir($backup_path) && !mkdir($backup_path)) {
            $this->setError(sprintf('Cannot create directory <i>%s</i>', $backup_path));
        }

        foreach (Image::getAllImages() as $image) {
            $image = new Image($image['id_image']);
            $image_path = $image->getExistingImgPath();
            if (file_exists($from_path.$image_path.'.'.$image->image_format)) {
                copy($from_path.$image_path.'.'.$image->image_format, $backup_path.$this->generateId('image', $image->id).'.'.$image->image_format);
            }

            foreach ($types as $type) {
                if (file_exists($from_path.$image_path.'-'.$type.'.'.$image->image_format)) {
                    copy($from_path.$image_path.'-'.$type.'.'.$image->image_format, $backup_path.$this->generateId('image', $image->id).'-'.$type.'.'.$image->image_format);
                }
            }
        }
    }

    /**
     * ONLY FOR DEVELOPMENT PURPOSE
     */
    public function backupImageTab()
    {
        $backup_path = $this->img_path.'t/';
        $from_path = _PS_IMG_DIR_.'t/';
        if (!is_dir($backup_path) && !mkdir($backup_path)) {
            $this->setError(sprintf('Cannot create directory <i>%s</i>', $backup_path));
        }

        $xml = $this->loadEntity('tab');
        foreach ($xml->entities->tab as $tab) {
            if (file_exists($from_path.$tab->class_name.'.gif')) {
                copy($from_path.$tab->class_name.'.gif', $backup_path.$tab->class_name.'.gif');
            }
        }
    }
}
