<?php
namespace Makarovsoft\Email\Model\ResourceModel;

use Magento\Framework\Model\ResourceModel\Db\AbstractDb;
use Magento\Framework\Model\ResourceModel\Db\Context;
use Magento\Framework\Stdlib\DateTime\DateTime;
use Magento\Store\Model\StoreManagerInterface;
use Magento\Framework\Stdlib\DateTime as LibDateTime;
use Magento\Framework\Model\AbstractModel;
use Magento\Store\Model\Store;
use Makarovsoft\Email\Model\Message as MessageModel;
use Magento\Framework\Event\ManagerInterface;
use Magento\Catalog\Model\Product;
use Makarovsoft\Email\Model\Message\Product as MessageProduct;
use Makarovsoft\Email\Model\Message\Category as MessageCategory;

class Message extends AbstractDb
{
/**
* Store model
*
* @var \Magento\Store\Model\Store
*/
protected $store = null;

/**
* @var \Magento\Framework\Stdlib\DateTime\DateTime
*/
protected $date;

/**
* Store manager
*
* @var \Magento\Store\Model\StoreManagerInterface
*/
protected $storeManager;

/**
* @var \Magento\Framework\Stdlib\DateTime
*/
protected $dateTime;

/**
* @var string
*/
protected $messageProductTable;

/**
* @var string
*/
protected $messageCategoryTable;

/**
* @var \Magento\Framework\Event\ManagerInterface
*/
protected $eventManager;

/**
* @var \Makarovsoft\Email\Model\Message\Product
*/
protected $messageProduct;

/**
* @param Context $context
* @param DateTime $date
* @param StoreManagerInterface $storeManager
* @param LibDateTime $dateTime
* @param ManagerInterface $eventManager
* @param MessageProduct $messageProduct
* @param MessageCategory $messageCategory
*/
public function __construct(
Context $context,
DateTime $date,
StoreManagerInterface $storeManager,
LibDateTime $dateTime,
ManagerInterface $eventManager,
MessageProduct $messageProduct,
MessageCategory $messageCategory
)
{
$this->date = $date;
$this->storeManager = $storeManager;
$this->dateTime = $dateTime;
$this->eventManager = $eventManager;
$this->messageProduct = $messageProduct;
$this->messageCategory = $messageCategory;

parent::__construct($context);
$this->messageProductTable = $this->getTable('makarovsoft_email_message_product');
$this->messageCategoryTable = $this->getTable('makarovsoft_email_message_category');

}

/**
* Initialize resource model
*
* @return void
*/
protected function _construct()
{
$this->_init('makarovsoft_email_message', 'message_id');
}

/**
* Process message data before deleting
*
* @param \Magento\Framework\Model\AbstractModel $object
* @return $this
*/
protected function _beforeDelete(AbstractModel $object)
{
$condition = ['message_id = ?' => (int)$object->getId()];
$this->getConnection()->delete($this->getTable('makarovsoft_email_message_store'), $condition);
return parent::_beforeDelete($object);
}

/**
* before save callback
*
* @param AbstractModel|\Makarovsoft\Email\Model\Message $object
* @return $this
*/
protected function _beforeSave(AbstractModel $object)
{
foreach (['dob'] as $field) {
$value = !$object->getData($field) ? null : $object->getData($field);
$object->setData($field, $this->dateTime->formatDate($value));
}

if ($object->isObjectNew()) {
$object->setCreatedAt($this->date->gmtDate());
$object->setUpdatedAt(null);
} else {
$object->setUpdatedAt($this->date->gmtDate());
}
return parent::_beforeSave($object);
}

/**
* Assign message to store views
*
* @param AbstractModel|\Makarovsoft\Email\Model\Message $object
* @return $this
*/
protected function _afterSave(AbstractModel $object)
{
$this->saveStoreRelation($object);
return parent::_afterSave($object);
}

/**
* Load an object using 'url_key' field if there's no field specified and value is not numeric
*
* @param AbstractModel|\Makarovsoft\Email\Model\Message $object
* @param mixed $value
* @param string $field
* @return $this
*/
public function load(AbstractModel $object, $value, $field = null)
{
return parent::load($object, $value, $field);
}

/**
* Perform operations after object load
*
* @param AbstractModel $object
* @return $this
*/
protected function _afterLoad(AbstractModel $object)
{
if ($object->getId()) {
$stores = $this->lookupStoreIds($object->getId());
$object->setData('store_id', $stores);
}
return parent::_afterLoad($object);
}

/**
* Retrieve select object for load object data
*
* @param string $field
* @param mixed $value
* @param \Makarovsoft\Email\Model\Message $object
* @return \Zend_Db_Select
*/
protected function _getLoadSelect($field, $value, $object)
{
$select = parent::_getLoadSelect($field, $value, $object);

if ($object->getStoreId()) {
$storeIds = [
Store::DEFAULT_STORE_ID,
(int)$object->getStoreId()
];
$select->join(
[
'makarovsoft_email_message_store' => $this->getTable('makarovsoft_email_message_store')
],
$this->getMainTable() . '.message_id = makarovsoft_email_message_store.message_id',
[]
)//TODO: check if is_active filter is needed
->where('is_active = ?', 1)
->where(
'makarovsoft_email_message_store.store_id IN (?)',
$storeIds
)
->order('makarovsoft_email_message_store.store_id DESC')
->limit(1);
}
return $select;
}

/**
* Retrieve load select with filter by url_key, store and activity
*
* @param string $urlKey
* @param int|array $store
* @param int $isActive
* @return \Magento\Framework\DB\Select
*/
protected function getLoadByUrlKeySelect($urlKey, $store, $isActive = null)
{
$select = $this->getConnection()
->select()
->from(['message' => $this->getMainTable()])
->join(
['message_store' => $this->getTable('makarovsoft_email_message_store')],
'message.message_id = message_store.message_id',
[]
)
->where(
'message.url_key = ?',
$urlKey
)
->where(
'message_store.store_id IN (?)',
$store
);
if (!is_null($isActive)) {
$select->where('message.is_active = ?', $isActive);
}
return $select;
}


/**
* Check if message url_key exist
* return message id if message exists
*
* @param string $urlKey
* @param int $storeId
* @return int
*/
public function checkUrlKey($urlKey, $storeId)
{
$stores = [Store::DEFAULT_STORE_ID, $storeId];
$select = $this->getLoadByUrlKeySelect($urlKey, $stores, 1);
$select->reset(\Zend_Db_Select::COLUMNS)
->columns('message.message_id')
->order('message_store.store_id DESC')
->limit(1);
return $this->getConnection()->fetchOne($select);
}

/**
* Retrieves message name from DB by passed url key.
*
* @param string $urlKey
* @return string|bool
*/
public function getMessageNameByUrlKey($urlKey)
{
$stores = [Store::DEFAULT_STORE_ID];
if ($this->store) {
$stores[] = (int)$this->getStore()->getId();
}
$select = $this->getLoadByUrlKeySelect($urlKey, $stores);
$select->reset(\Zend_Db_Select::COLUMNS)
->columns('message.name')
->order('message.store_id DESC')
->limit(1);
return $this->getConnection()->fetchOne($select);
}

/**
* Retrieves message name from DB by passed id.
*
* @param string $id
* @return string|bool
*/
public function getMessageNameById($id)
{
$adapter = $this->getConnection();
$select = $adapter->select()
->from($this->getMainTable(), 'name')
->where('message_id = :message_id');
$binds = ['message_id' => (int)$id];
return $adapter->fetchOne($select, $binds);
}

/**
* Retrieves message url key from DB by passed id.
*
* @param int $id
* @return string|bool
*/
public function getMessageUrlKeyById($id)
{
$adapter = $this->getConnection();
$select = $adapter->select()
->from($this->getMainTable(), 'url_key')
->where('message_id = :message_id');
$binds = ['message_id' => (int)$id];
return $adapter->fetchOne($select, $binds);
}

/**
* Get store ids to which specified item is assigned
*
* @param int $messageId
* @return array
*/
public function lookupStoreIds($messageId)
{
$adapter = $this->getConnection();
$select = $adapter->select()->from(
$this->getTable('makarovsoft_email_message_store'),
'store_id'
)
->where(
'message_id = ?',
(int)$messageId
);
return $adapter->fetchCol($select);
}

/**
* Set store model
*
* @param Store $store
* @return $this
*/
public function setStore(Store $store)
{
$this->store = $store;
return $this;
}

/**
* Retrieve store model
*
* @return Store
*/
public function getStore()
{
return $this->storeManager->getStore($this->store);
}

/**
* check if url key is unique
*
* @param AbstractModel|\Makarovsoft\Email\Model\Message $object
* @return bool
*/
public function getIsUniqueMessageToStores(AbstractModel $object)
{
if ($this->storeManager->hasSingleStore() || !$object->hasStores()) {
$stores = [Store::DEFAULT_STORE_ID];
} else {
$stores = (array)$object->getData('stores');
}
$select = $this->getLoadByUrlKeySelect($object->getData('url_key'), $stores);
if ($object->getId()) {
$select->where('message_store.message_id <> ?', $object->getId());
}
if ($this->getConnection()->fetchRow($select)) {
return false;
}
return true;
}

/**
* @param MessageModel $message
* @return array
*/
public function getProductsPosition(MessageModel $message)
{
$select = $this->getConnection()->select()->from(
$this->messageProductTable,
['product_id', 'position']
)
->where(
'message_id = :message_id'
);
$bind = ['message_id' => (int)$message->getId()];
return $this->getConnection()->fetchPairs($select, $bind);
}

/**
* @param MessageModel $message
* @return $this
*/
protected function saveStoreRelation(MessageModel $message)
{
$oldStores = $this->lookupStoreIds($message->getId());
$newStores = (array)$message->getStores();
if (empty($newStores)) {
$newStores = (array)$message->getStoreId();
}
$table = $this->getTable('makarovsoft_email_message_store');
$insert = array_diff($newStores, $oldStores);
$delete = array_diff($oldStores, $newStores);

if ($delete) {
$where = [
'message_id = ?' => (int)$message->getId(),
'store_id IN (?)' => $delete
];
$this->getConnection()->delete($table, $where);
}
if ($insert) {
$data = [];
foreach ($insert as $storeId) {
$data[] = [
'message_id' => (int)$message->getId(),
'store_id' => (int)$storeId
];
}
$this->getConnection()->insertMultiple($table, $data);
}
return $this;
}

/**
* @param MessageModel $message
* @return $this
*/
protected function saveProductRelation(MessageModel $message)
{
$message->setIsChangedProductList(false);
$id = $message->getId();
$products = $message->getProductsData();

if ($products === null) {
return $this;
}
$oldProducts = $message->getProductsPosition();
$insert = array_diff_key($products, $oldProducts);
$delete = array_diff_key($oldProducts, $products);
$update = array_intersect_key($products, $oldProducts);
$_update = array();
foreach ($update as $key=>$settings) {
if ( isset($oldProducts[$key]) && isset($settings['position']) &&
$oldProducts[$key] != $settings['position']
) {
$_update[$key] = $settings;
}
}
$update = $_update;
$adapter = $this->getConnection();
if (!empty($delete)) {
$condition = ['product_id IN(?)' => array_keys($delete), 'message_id=?' => $id];
$adapter->delete($this->messageProductTable, $condition);
}
if (!empty($insert)) {
$data = [];
foreach ($insert as $productId => $position) {
$data[] = [
'message_id' => (int)$id,
'product_id' => (int)$productId,
'position' => (int)$position
];
}
$adapter->insertMultiple($this->messageProductTable, $data);
}

if (!empty($update)) {
foreach ($update as $productId => $position) {
$where = ['message_id = ?' => (int)$id, 'product_id = ?' => (int)$productId];
$bind = ['position' => (int)$position['position']];
$adapter->update($this->messageProductTable, $bind, $where);
}
}

if (!empty($insert) || !empty($delete)) {
$productIds = array_unique(array_merge(array_keys($insert), array_keys($delete)));
$this->eventManager->dispatch(
'makarovsoft_email_message_change_products',
['message' => $message, 'product_ids' => $productIds]
);
}

if (!empty($insert) || !empty($update) || !empty($delete)) {
$message->setIsChangedProductList(true);
$productIds = array_keys($insert + $delete + $update);
$message->setAffectedProductIds($productIds);
}
return $this;
}

/**
* @param Product $product
* @param $messages
* @return $this
*/
public function saveMessageProductRelation(Product $product, $messages)
{
$product->setIsChangedMessageList(false);
$id = $product->getId();
if ($messages === null) {
return $this;
}
$oldMessageObjects = $this->messageProduct->getSelectedMessages($product);
if (!is_array($oldMessageObjects)) {
$oldMessageObjects = [];
}
$oldMessages = [];
foreach ($oldMessageObjects as $message) {
/** @var \Makarovsoft\Email\Model\Message $message */
$oldMessages[$message->getId()] = ['position' => $message->getPosition()];
}
$insert = array_diff_key($messages, $oldMessages);

$delete = array_diff_key($oldMessages, $messages);

$update = array_intersect_key($messages, $oldMessages);
$toUpdate = [];
foreach ($update as $productId => $values) {
if (isset($oldMessages[$productId]) && $oldMessages[$productId]['position'] != $values['position']) {
$toUpdate[$productId] = [];
$toUpdate[$productId]['position'] = $values['position'];
}
}

$update = $toUpdate;
$adapter = $this->getConnection();
if (!empty($delete)) {
$condition = ['message_id IN(?)' => array_keys($delete), 'product_id=?' => $id];
$adapter->delete($this->messageProductTable, $condition);
}
if (!empty($insert)) {
$data = [];
foreach ($insert as $messageId => $position) {
$data[] = [
'product_id' => (int)$id,
'message_id' => (int)$messageId,
'position' => (int)$position['position']
];
}
$adapter->insertMultiple($this->messageProductTable, $data);
}

if (!empty($update)) {
foreach ($update as $messageId => $position) {
$where = ['product_id = ?' => (int)$id, 'message_id = ?' => (int)$messageId];
$bind = ['position' => (int)$position['position']];
$adapter->update($this->messageProductTable, $bind, $where);
}
}

if (!empty($insert) || !empty($delete)) {
$messageIds = array_unique(array_merge(array_keys($insert), array_keys($delete)));
$this->eventManager->dispatch(
'makarovsoft_email_product_change_messages',
['product' => $product, 'message_ids' => $messageIds]
);
}

if (!empty($insert) || !empty($update) || !empty($delete)) {
$product->setIsChangedMessageList(true);
$messageIds = array_keys($insert + $delete + $update);
$product->setAffectedMessageIds($messageIds);
}
return $this;
}

protected function saveCategoryRelation(MessageModel $message)
{
$message->setIsChangedCategoryList(false);
$id = $message->getId();
$categories = $message->getCategoriesIds();

if ($categories === null) {
return $this;
}
$oldCategoryIds = $message->getCategoryIds();
$insert = array_diff_key($categories, $oldCategoryIds);
$delete = array_diff_key($oldCategoryIds, $categories);

$adapter = $this->getConnection();
if (!empty($delete)) {
$condition = array('category_id IN(?)' => $delete, 'message_id=?' => $id);
$adapter->delete($this->messageCategoryTable, $condition);
}
if (!empty($insert)) {
$data = array();
foreach ($insert as $categoryId) {
$data[] = array(
'message_id' => (int)$id,
'category_id' => (int)$categoryId,
'position' => 1
);
}
$adapter->insertMultiple($this->messageCategoryTable, $data);
}

if (!empty($insert) || !empty($delete)) {
$categoryIds = array_unique(array_merge(array_keys($insert), array_keys($delete)));
$this->eventManager->dispatch(
'makarovsoft_email_message_change_categories',
array('message' => $message, 'category_ids' => $categoryIds)
);
}

if (!empty($insert) /*|| !empty($update)*/ || !empty($delete)) {
$message->setIsChangedCategoryList(true);
$categoryIds = array_keys($insert + $delete /* + $update*/);
$message->setAffectedCategoryIds($categoryIds);
}
return $this;
}

/**
* @param MessageModel $message
*
* @return array
*/
public function getCategoryIds(MessageModel $message)
{
$adapter = $this->getConnection();
$select = $adapter->select()->from(
$this->messageCategoryTable,
'category_id'
)
->where(
'message_id = ?',
(int)$message->getId()
);
return $adapter->fetchCol($select);
}

/**
* @param $category
* @param $messages
* @return $this
*/
public function saveMessageCategoryRelation($category, $messages)
{
/** @var \Magento\Catalog\Model\Category $category */
$category->setIsChangedMessageList(false);
$id = $category->getId();
if ($messages === null) {
return $this;
}
$oldMessageObjects = $this->messageCategory->getSelectedMessages($category);
if (!is_array($oldMessageObjects)) {
$oldMessageObjects = array();
}
$oldMessages = [];
foreach ($oldMessageObjects as $message) {
/** @var \Makarovsoft\Email\Model\Message $message */
$oldMessages[$message->getId()] = $message->getPosition();
}
$insert = array_diff_key($messages, $oldMessages);
$delete = array_diff_key($oldMessages, $messages);
$update = array_intersect_key($messages, $oldMessages);
$update = array_diff_assoc($update, $oldMessages);


$adapter = $this->getConnection();
if (!empty($delete)) {
$condition = array('message_id IN(?)' => array_keys($delete), 'message_id=?' => $id);
$adapter->delete($this->messageCategoryTable, $condition);
}
if (!empty($insert)) {
$data = array();
foreach ($insert as $messageId => $position) {
$data[] = [
'category_id' => (int)$id,
'message_id' => (int)$messageId,
'position' => (int)$position
];
}
$adapter->insertMultiple($this->messageCategoryTable, $data);
}

if (!empty($update)) {
foreach ($update as $messageId => $position) {
$where = ['category_id = ?' => (int)$id, 'message_id = ?' => (int)$messageId];
$bind = ['position' => (int)$position];
$adapter->update($this->messageCategoryTable, $bind, $where);
}
}

if (!empty($insert) || !empty($delete)) {
$messageIds = array_unique(array_merge(array_keys($insert), array_keys($delete)));
$this->eventManager->dispatch(
'makarovsoft_email_category_change_messages',
array('category' => $category, 'message_ids' => $messageIds)
);
}

if (!empty($insert) || !empty($update) || !empty($delete)) {
$category->setIsChangedMessageList(true);
$messageIds = array_keys($insert + $delete + $update);
$category->setAffectedMessageIds($messageIds);
}
return $this;
}

}