<?php
namespace MailPoet\Models;
use Carbon\Carbon;
use MailPoet\Newsletter\Renderer\Renderer;
use MailPoet\Settings\SettingsController;
use MailPoet\Tasks\Sending as SendingTask;
use MailPoet\Util\Helpers;
use MailPoet\Util\Security;
use MailPoet\WooCommerce\Helper as WCHelper;
use MailPoet\WP\Emoji;
use function MailPoet\Util\array_column;
use MailPoet\WP\Functions as WPFunctions;

if (!defined('ABSPATH')) exit;

/**
 * @property int $id
 * @property string $type
 * @property object|boolean $queue
 * @property string $hash
 * @property string $sender_address
 * @property string $status
 * @property string|object $meta
 * @property array $options
 * @property int $children_count
 * @property bool|array $statistics
 * @property string $deleted_at
 * @property int $total_sent
 * @property int $total_scheduled
 * @property array $segments
 * @property string $subject
 * @property string $body
 * @property string|null $schedule
 * @property boolean|null $isScheduled
 * @property string|null $scheduledAt
 */

class Newsletter extends Model {
  public static $_table = MP_NEWSLETTERS_TABLE;
  const TYPE_AUTOMATIC = 'automatic';
  const TYPE_STANDARD = 'standard';
  const TYPE_WELCOME = 'welcome';
  const TYPE_NOTIFICATION = 'notification';
  const TYPE_NOTIFICATION_HISTORY = 'notification_history';
  // standard newsletters
  const STATUS_DRAFT = 'draft';
  const STATUS_SCHEDULED = 'scheduled';
  const STATUS_SENDING = 'sending';
  const STATUS_SENT = 'sent';
  // automatic newsletters status
  const STATUS_ACTIVE = 'active';

  private $emoji;

  function __construct() {
    parent::__construct();
    $this->addValidations('type', [
      'required' => WPFunctions::get()->__('Please specify a type.', 'mailpoet'),
    ]);
    $this->emoji = new Emoji();
  }

  function queue() {
    return $this->hasOne(__NAMESPACE__ . '\SendingQueue', 'newsletter_id', 'id');
  }

  function children() {
    return $this->hasMany(
      __NAMESPACE__ . '\Newsletter',
      'parent_id',
      'id'
    );
  }

  function parent() {
    return $this->hasOne(
      __NAMESPACE__ . '\Newsletter',
      'id',
      'parent_id'
    );
  }

  function segments() {
    return $this->hasManyThrough(
      __NAMESPACE__ . '\Segment',
      __NAMESPACE__ . '\NewsletterSegment',
      'newsletter_id',
      'segment_id'
    );
  }

  function segmentRelations() {
    return $this->hasMany(
      __NAMESPACE__ . '\NewsletterSegment',
      'newsletter_id',
      'id'
    );
  }

  function options() {
    return $this->hasManyThrough(
      __NAMESPACE__ . '\NewsletterOptionField',
      __NAMESPACE__ . '\NewsletterOption',
      'newsletter_id',
      'option_field_id'
    )->select_expr(MP_NEWSLETTER_OPTION_TABLE . '.value');
  }

  function save() {
    if (is_string($this->deleted_at) && strlen(trim($this->deleted_at)) === 0) {
      $this->set_expr('deleted_at', 'NULL');
    }

    if (isset($this->body)) {
      if (is_array($this->body)) {
        $this->body = json_encode($this->body);
      }
      $this->set(
        'body',
        $this->emoji->encodeForUTF8Column(self::$_table, 'body', $this->body)
      );
    }

    $this->set('hash',
      ($this->hash)
      ? $this->hash
      : Security::generateHash()
    );
    return parent::save();
  }

  function trash() {
    // trash queue associations
    $children = $this->children()->select('id')->findArray();
    if ($children) {
      $this->children()->rawExecute(
        'UPDATE `' . self::$_table . '` ' .
        'SET `deleted_at` = NOW() ' .
        'WHERE `parent_id` = ' . $this->id
      );
      ScheduledTask::rawExecute(
        'UPDATE `' . ScheduledTask::$_table . '` t ' .
        'JOIN `' . SendingQueue::$_table . '` q ON t.`id` = q.`task_id` ' .
        'SET t.`deleted_at` = NOW() ' .
        'WHERE q.`newsletter_id` IN (' . join(',', array_merge(Helpers::flattenArray($children), [$this->id])) . ')'
      );
      SendingQueue::rawExecute(
        'UPDATE `' . SendingQueue::$_table . '` ' .
        'SET `deleted_at` = NOW() ' .
        'WHERE `newsletter_id` IN (' . join(',', array_merge(Helpers::flattenArray($children), [$this->id])) . ')'
      );
    } else {
      ScheduledTask::rawExecute(
        'UPDATE `' . ScheduledTask::$_table . '` t ' .
        'JOIN `' . SendingQueue::$_table . '` q ON t.`id` = q.`task_id` ' .
        'SET t.`deleted_at` = NOW() ' .
        'WHERE q.`newsletter_id` = ' . $this->id
      );
      SendingQueue::rawExecute(
        'UPDATE `' . SendingQueue::$_table . '` ' .
        'SET `deleted_at` = NOW() ' .
        'WHERE `newsletter_id` = ' . $this->id
      );
    }

    return parent::trash();
  }

  static function bulkTrash($orm) {
    // bulk trash queue and notification history associations
    parent::bulkAction($orm, function($ids) {
      $children = Newsletter::whereIn('parent_id', $ids)->select('id')->findArray();
      if ($children) {
        Newsletter::rawExecute(
          'UPDATE `' . Newsletter::$_table . '` ' .
          'SET `deleted_at` = NOW() ' .
          'WHERE `parent_id` IN (' . join(',', Helpers::flattenArray($ids)) . ')'
        );
        ScheduledTask::rawExecute(
          'UPDATE `' . ScheduledTask::$_table . '` t ' .
          'JOIN `' . SendingQueue::$_table . '` q ON t.`id` = q.`task_id` ' .
          'SET t.`deleted_at` = NOW() ' .
          'WHERE q.`newsletter_id` IN (' . join(',', array_merge(Helpers::flattenArray($children), $ids)) . ')'
        );
        SendingQueue::rawExecute(
          'UPDATE `' . SendingQueue::$_table . '` ' .
          'SET `deleted_at` = NOW() ' .
          'WHERE `newsletter_id` IN (' . join(',', array_merge(Helpers::flattenArray($children), $ids)) . ')'
        );
      } else {
        ScheduledTask::rawExecute(
          'UPDATE `' . ScheduledTask::$_table . '` t ' .
          'JOIN `' . SendingQueue::$_table . '` q ON t.`id` = q.`task_id` ' .
          'SET t.`deleted_at` = NOW() ' .
          'WHERE q.`newsletter_id` IN (' . join(',', Helpers::flattenArray($ids)) . ')'
        );
        SendingQueue::rawExecute(
          'UPDATE `' . SendingQueue::$_table . '` ' .
          'SET `deleted_at` = NOW() ' .
          'WHERE `newsletter_id` IN (' . join(',', Helpers::flattenArray($ids)) . ')'
        );
      }
    });

    return parent::bulkTrash($orm);
  }

  function delete() {
    // delete queue, notification history and segment associations
    $children = $this->children()->select('id')->findArray();
    if ($children) {
      $children = Helpers::flattenArray($children);
      $this->children()->deleteMany();
      SendingQueue::getTasks()
        ->whereIn('queues.newsletter_id', array_merge($children, [$this->id]))
        ->findResultSet()
        ->delete();
      SendingQueue::whereIn('newsletter_id', array_merge($children, [$this->id]))->deleteMany();
      NewsletterSegment::whereIn('newsletter_id', array_merge($children, [$this->id]))->deleteMany();
    } else {
      SendingQueue::getTasks()
        ->where('queues.newsletter_id', $this->id)
        ->findResultSet()
        ->delete();
      $this->queue()->deleteMany();
      $this->segmentRelations()->deleteMany();
    }

    return parent::delete();
  }

  static function bulkDelete($orm) {
    // bulk delete queue, notification history and segment associations
    parent::bulkAction($orm, function($ids) {
      $children = Newsletter::whereIn('parent_id', $ids)->select('id')->findArray();
      if ($children) {
        $children = Helpers::flattenArray($children);
        Newsletter::whereIn('parent_id', $ids)->deleteMany();
        SendingQueue::getTasks()
          ->whereIn('queues.newsletter_id', array_merge($children, $ids))
          ->findResultSet()
          ->delete();
        SendingQueue::whereIn('newsletter_id', array_merge($children, $ids))->deleteMany();
        NewsletterSegment::whereIn('newsletter_id', array_merge($children, $ids))->deleteMany();
      } else {
        SendingQueue::getTasks()
          ->whereIn('queues.newsletter_id', $ids)
          ->findResultSet()
          ->delete();
        SendingQueue::whereIn('newsletter_id', $ids)->deleteMany();
        NewsletterSegment::whereIn('newsletter_id', $ids)->deleteMany();
      }
    });

    return parent::bulkDelete($orm);
  }

  function restore() {
    // restore trashed queue and notification history associations
    $children = $this->children()->select('id')->findArray();
    if ($children) {
      $this->children()->rawExecute(
        'UPDATE `' . self::$_table . '` ' .
        'SET `deleted_at` = null ' .
        'WHERE `parent_id` = ' . $this->id
      );
      ScheduledTask::rawExecute(
        'UPDATE `' . ScheduledTask::$_table . '` t ' .
        'JOIN `' . SendingQueue::$_table . '` q ON t.`id` = q.`task_id` ' .
        'SET t.`deleted_at` = null ' .
        'WHERE q.`newsletter_id` IN (' . join(',', array_merge(Helpers::flattenArray($children), [$this->id])) . ')'
      );
      SendingQueue::rawExecute(
        'UPDATE `' . SendingQueue::$_table . '` ' .
        'SET `deleted_at` = null ' .
        'WHERE `newsletter_id` IN (' . join(',', array_merge(Helpers::flattenArray($children), [$this->id])) . ')'
      );
    } else {
      ScheduledTask::rawExecute(
        'UPDATE `' . ScheduledTask::$_table . '` t ' .
        'JOIN `' . SendingQueue::$_table . '` q ON t.`id` = q.`task_id` ' .
        'SET t.`deleted_at` = null ' .
        'WHERE q.`newsletter_id` = ' . $this->id
      );
      SendingQueue::rawExecute(
        'UPDATE `' . SendingQueue::$_table . '` ' .
        'SET `deleted_at` = null ' .
        'WHERE `newsletter_id` = ' . $this->id
      );
    }

    if ($this->status == self::STATUS_SENDING) {
      $this->set('status', self::STATUS_DRAFT);
      $this->save();
    }
    return parent::restore();
  }

  static function bulkRestore($orm) {
    // bulk restore trashed queue and notification history associations
    parent::bulkAction($orm, function($ids) {
      $children = Newsletter::whereIn('parent_id', $ids)->select('id')->findArray();
      if ($children) {
        Newsletter::whereIn('parent_id', $ids)
          ->whereNotNull('deleted_at')
          ->findResultSet()
          ->set('deleted_at', null)
          ->save();
        SendingQueue::getTasks()
          ->whereIn('queues.newsletter_id', Helpers::flattenArray($children))
          ->whereNotNull('tasks.deleted_at')
          ->findResultSet()
          ->set('deleted_at', null)
          ->save();
        SendingQueue::whereIn('newsletter_id', Helpers::flattenArray($children))
          ->whereNotNull('deleted_at')
          ->findResultSet()
          ->set('deleted_at', null)
          ->save();
      } else {
        SendingQueue::getTasks()
          ->whereIn('queues.newsletter_id', $ids)
          ->whereNotNull('tasks.deleted_at')
          ->findResultSet()
          ->set('deleted_at', null)
          ->save();
        SendingQueue::whereIn('newsletter_id', $ids)
          ->whereNotNull('deleted_at')
          ->findResultSet()
          ->set('deleted_at', null)
          ->save();
      }
    });

    parent::bulkAction($orm, function($ids) {
      Newsletter::whereIn('id', $ids)
        ->where('status', Newsletter::STATUS_SENDING)
        ->findResultSet()
        ->set('status', Newsletter::STATUS_DRAFT)
        ->save();
    });

    return parent::bulkRestore($orm);
  }

  function setStatus($status = null) {
    if (in_array($status, [
      self::STATUS_DRAFT,
      self::STATUS_SCHEDULED,
      self::STATUS_SENDING,
      self::STATUS_SENT,
      self::STATUS_ACTIVE,
    ])) {
      $this->set('status', $status);
      $this->save();
    }

    $types_with_activation = [self::TYPE_NOTIFICATION, self::TYPE_WELCOME, self::TYPE_AUTOMATIC];

    if (($status === self::STATUS_DRAFT) && in_array($this->type, $types_with_activation)) {
      ScheduledTask::pauseAllByNewsletter($this);
    }
    if (($status === self::STATUS_ACTIVE) && in_array($this->type, $types_with_activation)) {
      ScheduledTask::setScheduledAllByNewsletter($this);
    }
    return $this;
  }

  function duplicate($data = []) {
    $newsletter_data = $this->asArray();

    // remove id so that it creates a new record
    unset($newsletter_data['id']);

    // merge data with newsletter data (allows override)
    $data = array_merge($newsletter_data, $data);

    $duplicate = self::create();
    $duplicate->hydrate($data);

    // reset timestamps
    $duplicate->set_expr('created_at', 'NOW()');
    $duplicate->set_expr('updated_at', 'NOW()');
    $duplicate->set_expr('deleted_at', 'NULL');

    // reset status
    $duplicate->set('status', self::STATUS_DRAFT);

    // reset hash
    $duplicate->set('hash', null);

    // reset sent at date
    $duplicate->set('sent_at', null);

    $duplicate->save();

    if ($duplicate->getErrors() === false) {
      // create relationships between duplicate and segments
      $segments = $this->segments()->findMany();

      if (!empty($segments)) {
        foreach ($segments as $segment) {
          $relation = NewsletterSegment::create();
          $relation->segment_id = $segment->id;
          $relation->newsletter_id = $duplicate->id;
          $relation->save();
        }
      }

      // duplicate options
      $options = NewsletterOption::where('newsletter_id', $this->id)
        ->findMany();

      $ignored_option_field_ids = Helpers::flattenArray(
        NewsletterOptionField::whereIn('name', ['isScheduled', 'scheduledAt'])
          ->select('id')
          ->findArray()
      );

      if (!empty($options)) {
        foreach ($options as $option) {
          if (in_array($option->option_field_id, $ignored_option_field_ids)) {
            continue;
          }
          $relation = NewsletterOption::create();
          $relation->newsletter_id = $duplicate->id;
          $relation->option_field_id = $option->option_field_id;
          $relation->value = $option->value;
          $relation->save();
        }
      }
    }

    return $duplicate;
  }

  function createNotificationHistory() {
    $newsletter_data = $this->asArray();

    // remove id so that it creates a new record
    unset($newsletter_data['id']);

    $data = array_merge(
      $newsletter_data,
      [
        'parent_id' => $this->id,
        'type' => self::TYPE_NOTIFICATION_HISTORY,
        'status' => self::STATUS_SENDING,
      ]
    );

    $notification_history = self::create();
    $notification_history->hydrate($data);

    // reset timestamps
    $notification_history->set_expr('created_at', 'NOW()');
    $notification_history->set_expr('updated_at', 'NOW()');
    $notification_history->set_expr('deleted_at', 'NULL');

    // reset hash
    $notification_history->set('hash', null);

    $notification_history->save();

    if ($notification_history->getErrors() === false) {
      // create relationships between notification history and segments
      $segments = $this->segments()->findMany();

      if (!empty($segments)) {
        foreach ($segments as $segment) {
          $relation = NewsletterSegment::create();
          $relation->segment_id = $segment->id;
          $relation->newsletter_id = $notification_history->id;
          $relation->save();
        }
      }
    }

    return $notification_history;
  }

  function asArray() {
    $model = parent::asArray();

    if (isset($model['body'])) {
      $model['body'] = json_decode($model['body'], true);
    }
    return $model;
  }

  function withSegments($incl_deleted = false) {
    $this->segments = $this->segments()->findArray();
    if ($incl_deleted) {
      $this->withDeletedSegments();
    }
    return $this;
  }

  function withDeletedSegments() {
    if (!empty($this->segments)) {
      $segment_ids = array_column($this->segments, 'id');
      $links = $this->segmentRelations()
        ->whereNotIn('segment_id', $segment_ids)->findArray();
      $deleted_segments = [];

      foreach ($links as $link) {
        $deleted_segments[] = [
          'id' => $link['segment_id'],
          'name' => WPFunctions::get()->__('Deleted list', 'mailpoet'),
        ];
      }
      $this->segments = array_merge($this->segments, $deleted_segments);
    }

    return $this;
  }

  function withChildrenCount() {
    $this->children_count = $this->children()->count();
    return $this;
  }

  function getQueue($columns = '*') {
    return SendingTask::getByNewsletterId($this->id);
  }

  function withSendingQueue() {
    $queue = $this->getQueue();
    if ($queue === false) {
      $this->queue = false;
    } else {
      $this->queue = $queue->asArray();
    }
    return $this;
  }

  function withOptions() {
    $options = $this->options()->findArray();
    if (empty($options)) {
      $this->options = [];
    } else {
      $this->options = array_column($options, 'value', 'name');
    }
    return $this;
  }

  function withTotalSent() {
    // total of subscribers who received the email
    $this->total_sent = (int)SendingQueue::findTaskByNewsletterId($this->id)
      ->where('tasks.status', SendingQueue::STATUS_COMPLETED)
      ->sum('queues.count_processed');
    return $this;
  }

  function withScheduledToBeSent() {
    $this->total_scheduled = (int)SendingQueue::findTaskByNewsletterId($this->id)
      ->where('tasks.status', SendingQueue::STATUS_SCHEDULED)
      ->count();
    return $this;
  }

  function withStatistics(WCHelper $woocommerce_helper) {
    $statistics = $this->getStatistics($woocommerce_helper);
    $this->statistics = $statistics;
    return $this;
  }

  function render() {
    $renderer = new Renderer($this);
    return $renderer->render();
  }

  function getStatistics(WCHelper $woocommerce_helper) {
    if (($this->type !== self::TYPE_WELCOME) && ($this->queue === false)) {
      return false;
    }

    $statisticsExprs = [
      'clicked' => StatisticsClicks::selectExpr('COUNT(DISTINCT subscriber_id) as cnt')->tableAlias("stat"),
      'opened' => StatisticsOpens::selectExpr('COUNT(DISTINCT subscriber_id) as cnt')->tableAlias("stat"),
      'unsubscribed' => StatisticsUnsubscribes::selectExpr('COUNT(DISTINCT subscriber_id) as cnt')->tableAlias("stat"),
    ];
    $result = [];

    foreach ($statisticsExprs as $name => $statisticsExpr) {
      if (!in_array($this->type, [self::TYPE_WELCOME, self::TYPE_AUTOMATIC])) {
        $row = $statisticsExpr->whereRaw('`queue_id` = ?', [$this->queue['id']])->findOne();
      } else {
        $row = $statisticsExpr
          ->join(MP_SENDING_QUEUES_TABLE, ["queue_id", "=", "qt.id"], "qt")
          ->join(MP_SCHEDULED_TASKS_TABLE, ["qt.task_id", "=", "tasks.id"], "tasks")
          ->where([
            "tasks.status" => SendingQueue::STATUS_COMPLETED,
            "stat.newsletter_id" => $this->id,
          ])->findOne();
      }

      $result[$name] = !empty($row->cnt) ? (int)$row->cnt : 0;
    }

    // WooCommerce revenues
    if ($woocommerce_helper->isWooCommerceActive()) {
      $currency = $woocommerce_helper->getWoocommerceCurrency();
      $row = StatisticsWooCommercePurchases::selectExpr('SUM(order_price_total) AS total')
        ->selectExpr('count(*)', 'count')
        ->where([
          'newsletter_id' => $this->id,
          'order_currency' => $currency,
        ])
        ->findOne();

      $revenue = !empty($row->total) ? (float)$row->total : 0.0;
      $count = !empty($row->count) ? (int)$row->count : 0;
      $result['revenue'] = [
        'currency' => $currency,
        'value' => $revenue,
        'count' => $count,
        'formatted' => $woocommerce_helper->getRawPrice($revenue, ['currency' => $currency]),
      ];
    } else {
      $result['revenue'] = null;
    }

    return $result;
  }

  function wasScheduledForSubscriber($subscriber_id) {
    /** @var \stdClass */
    $queue = SendingQueue::rawQuery(
      "SELECT COUNT(*) as count
      FROM `" . SendingQueue::$_table . "`
      JOIN `" . ScheduledTask::$_table . "` ON " . SendingQueue::$_table . ".task_id = " . ScheduledTask::$_table . ".id
      JOIN `" . ScheduledTaskSubscriber::$_table . "` ON " . ScheduledTask::$_table . ".id = " . ScheduledTaskSubscriber::$_table . ".task_id
      WHERE " . ScheduledTaskSubscriber::$_table . ".subscriber_id = " . $subscriber_id . "
      AND " . SendingQueue::$_table . ".newsletter_id = " . $this->id
    )->findOne();

    return ((int)$queue->count) > 0;
  }


  static function getAnalytics() {
    $welcome_newsletters_count = Newsletter::getPublished()
      ->filter('filterType', self::TYPE_WELCOME)
      ->filter('filterStatus', self::STATUS_ACTIVE)
      ->count();

    $notifications_count = Newsletter::getPublished()
      ->filter('filterType', self::TYPE_NOTIFICATION)
      ->filter('filterStatus', self::STATUS_ACTIVE)
      ->count();

    $automatic_count = Newsletter::getPublished()
      ->filter('filterType', self::TYPE_AUTOMATIC)
      ->filter('filterStatus', self::STATUS_ACTIVE)
      ->count();

    $newsletters_count = Newsletter::getPublished()
      ->filter('filterType', self::TYPE_STANDARD)
      ->filter('filterStatus', self::STATUS_SENT)
      ->count();

    $first_purchase_emails_count = self::getActiveAutomaticNewslettersCount('woocommerce_first_purchase');
    $product_purchased_emails_count = self::getActiveAutomaticNewslettersCount('woocommerce_product_purchased');

    $sent_newsletters_3_months = self::sentAfter(Carbon::now()->subMonths(3));
    $sent_newsletters_30_days = self::sentAfter(Carbon::now()->subDays(30));

    return [
      'welcome_newsletters_count' => $welcome_newsletters_count,
      'notifications_count' => $notifications_count,
      'automatic_emails_count' => $automatic_count,
      'sent_newsletters_count' => $newsletters_count,
      'sent_newsletters_3_months' => $sent_newsletters_3_months,
      'sent_newsletters_30_days' => $sent_newsletters_30_days,
      'first_purchase_emails_count' => $first_purchase_emails_count,
      'product_purchased_emails_count' => $product_purchased_emails_count,
    ];
  }

  private static function getActiveAutomaticNewslettersCount($event_name) {
    return NewsletterOption::tableAlias('options')
      ->join(
        self::$_table,
        'newsletters.id = options.newsletter_id',
        'newsletters'
      )
      ->join(
        MP_NEWSLETTER_OPTION_FIELDS_TABLE,
        'option_fields.id = options.option_field_id',
        'option_fields'
      )
      ->whereNull('newsletters.deleted_at')
      ->where('newsletters.type', self::TYPE_AUTOMATIC)
      ->where('newsletters.status', self::STATUS_ACTIVE)
      ->where('option_fields.name', 'event')
      ->where('options.value', $event_name)
      ->count();
  }

  static function sentAfter($date) {
    return static::tableAlias('newsletters')
      ->where('newsletters.type', self::TYPE_STANDARD)
      ->where('newsletters.status', self::STATUS_SENT)
      ->join(
        MP_SENDING_QUEUES_TABLE,
        'queues.newsletter_id = newsletters.id',
        'queues'
      )
      ->join(
        MP_SCHEDULED_TASKS_TABLE,
        'queues.task_id = tasks.id',
        'tasks'
      )
      ->where('tasks.status', SendingQueue::STATUS_COMPLETED)
      ->whereGte('tasks.processed_at', $date)
      ->count();
  }

  static function search($orm, $search = '') {
    if (strlen(trim($search)) > 0) {
      $orm->whereLike('subject', '%' . $search . '%');
    }
    return $orm;
  }

  static function filters($data = []) {
    $type = isset($data['params']['type']) ? $data['params']['type'] : null;
    $group = (isset($data['params']['group'])) ? $data['params']['group'] : null;

    // newsletter types without filters
    if (in_array($type, [
      self::TYPE_NOTIFICATION_HISTORY,
    ])) {
      return false;
    }

    $segments = Segment::orderByAsc('name')->findMany();
    $segment_list = [];
    $segment_list[] = [
      'label' => WPFunctions::get()->__('All Lists', 'mailpoet'),
      'value' => '',
    ];

    foreach ($segments as $segment) {
      $newsletters = $segment->newsletters()
        ->filter('filterType', $type, $group)
        ->filter('groupBy', $data);

      $newsletters_count = $newsletters->count();

      if ($newsletters_count > 0) {
        $segment_list[] = [
          'label' => sprintf('%s (%d)', $segment->name, $newsletters_count),
          'value' => $segment->id,
        ];
      }
    }

    $filters = [
      'segment' => $segment_list,
    ];

    return $filters;
  }

  static function filterBy($orm, $data = []) {
    // apply filters
    if (!empty($data['filter'])) {
      foreach ($data['filter'] as $key => $value) {
        if ($key === 'segment') {
          $segment = Segment::findOne($value);
          if ($segment !== false) {
            $orm = $segment->newsletters();
          }
        }
      }
    }

    // filter by type
    $type = isset($data['params']['type']) ? $data['params']['type'] : null;
    if ($type !== null) {
      $group = (isset($data['params']['group'])) ? $data['params']['group'] : null;
      $orm->filter('filterType', $type, $group);
    }

    // filter by parent id
    $parent_id = isset($data['params']['parent_id'])
      ? (int)$data['params']['parent_id']
      : null;
    if ($parent_id !== null) {
      $orm->where('parent_id', $parent_id);
    }

    return $orm;
  }

  static function filterWithOptions($orm, $type) {
    $orm = $orm->select(MP_NEWSLETTERS_TABLE . '.*');
    $optionFields = NewsletterOptionField::findArray();
    foreach ($optionFields as $optionField) {
      if ($optionField['newsletter_type'] !== $type) {
        continue;
      }
      $orm = $orm->select_expr(
        'IFNULL(GROUP_CONCAT(CASE WHEN ' .
        MP_NEWSLETTER_OPTION_FIELDS_TABLE . '.id=' . $optionField['id'] . ' THEN ' .
        MP_NEWSLETTER_OPTION_TABLE . '.value END), NULL) as "' . $optionField['name'] . '"');
    }
    $orm = $orm
      ->left_outer_join(
        MP_NEWSLETTER_OPTION_TABLE,
        [
          MP_NEWSLETTERS_TABLE . '.id',
          '=',
          MP_NEWSLETTER_OPTION_TABLE . '.newsletter_id',
        ]
      )
      ->left_outer_join(
        MP_NEWSLETTER_OPTION_FIELDS_TABLE,
        [
          MP_NEWSLETTER_OPTION_FIELDS_TABLE . '.id',
          '=',
          MP_NEWSLETTER_OPTION_TABLE . '.option_field_id',
        ]
      )
      ->group_by(MP_NEWSLETTERS_TABLE . '.id');
    return $orm;
  }

  static function groups($data = []) {
    $type = isset($data['params']['type']) ? $data['params']['type'] : null;
    $group = (isset($data['params']['group'])) ? $data['params']['group'] : null;

    // newsletter types without groups
    if (in_array($type, [
      self::TYPE_NOTIFICATION_HISTORY,
    ])) {
      return false;
    }

    $groups = [
      [
        'name' => 'all',
        'label' => WPFunctions::get()->__('All', 'mailpoet'),
        'count' => Newsletter::getPublished()
          ->filter('filterType', $type, $group)
          ->count(),
      ],
    ];

    switch ($type) {
      case self::TYPE_STANDARD:
        $groups = array_merge($groups, [
          [
            'name' => self::STATUS_DRAFT,
            'label' => WPFunctions::get()->__('Draft', 'mailpoet'),
            'count' => Newsletter::getPublished()
              ->filter('filterType', $type, $group)
              ->filter('filterStatus', self::STATUS_DRAFT)
              ->count(),
          ],
          [
            'name' => self::STATUS_SCHEDULED,
            'label' => WPFunctions::get()->__('Scheduled', 'mailpoet'),
            'count' => Newsletter::getPublished()
              ->filter('filterType', $type, $group)
              ->filter('filterStatus', self::STATUS_SCHEDULED)
              ->count(),
          ],
          [
            'name' => self::STATUS_SENDING,
            'label' => WPFunctions::get()->__('Sending', 'mailpoet'),
            'count' => Newsletter::getPublished()
              ->filter('filterType', $type, $group)
              ->filter('filterStatus', self::STATUS_SENDING)
              ->count(),
          ],
          [
            'name' => self::STATUS_SENT,
            'label' => WPFunctions::get()->__('Sent', 'mailpoet'),
            'count' => Newsletter::getPublished()
              ->filter('filterType', $type, $group)
              ->filter('filterStatus', self::STATUS_SENT)
              ->count(),
          ],
        ]);
        break;

      case self::TYPE_WELCOME:
      case self::TYPE_NOTIFICATION:
      case self::TYPE_AUTOMATIC:
        $groups = array_merge($groups, [
          [
            'name' => self::STATUS_ACTIVE,
            'label' => WPFunctions::get()->__('Active', 'mailpoet'),
            'count' => Newsletter::getPublished()
              ->filter('filterType', $type, $group)
              ->filter('filterStatus', self::STATUS_ACTIVE)
              ->count(),
          ],
          [
            'name' => self::STATUS_DRAFT,
            'label' => WPFunctions::get()->__('Not active', 'mailpoet'),
            'count' => Newsletter::getPublished()
              ->filter('filterType', $type, $group)
              ->filter('filterStatus', self::STATUS_DRAFT)
              ->count(),
          ],
        ]);
        break;
    }

    $groups[] = [
      'name' => 'trash',
      'label' => WPFunctions::get()->__('Trash', 'mailpoet'),
      'count' => Newsletter::getTrashed()
        ->filter('filterType', $type, $group)
        ->count(),
    ];

    return $groups;
  }

  static function groupBy($orm, $data = []) {
    $group = (!empty($data['group'])) ? $data['group'] : 'all';

    switch ($group) {
      case self::STATUS_DRAFT:
      case self::STATUS_SCHEDULED:
      case self::STATUS_SENDING:
      case self::STATUS_SENT:
      case self::STATUS_ACTIVE:
        $orm
          ->whereNull('deleted_at')
          ->filter('filterStatus', $group);
        break;

      case 'trash':
        $orm->whereNotNull('deleted_at');
        break;

      default:
        $orm->whereNull('deleted_at');
    }
    return $orm;
  }

  static function filterStatus($orm, $status = false) {
    if (in_array($status, [
      self::STATUS_DRAFT,
      self::STATUS_SCHEDULED,
      self::STATUS_SENDING,
      self::STATUS_SENT,
      self::STATUS_ACTIVE,
    ])) {
      $orm->where('status', $status);
    }
    return $orm;
  }

  static function filterType($orm, $type = false, $group = false) {
    if (in_array($type, [
      self::TYPE_STANDARD,
      self::TYPE_WELCOME,
      self::TYPE_AUTOMATIC,
      self::TYPE_NOTIFICATION,
      self::TYPE_NOTIFICATION_HISTORY,
    ])) {
      if ($type === self::TYPE_AUTOMATIC && $group) {
        $orm = $orm->join(
          NewsletterOptionField::$_table,
          [
            'option_fields.newsletter_type', '=', self::$_table . '.type',
          ],
          'option_fields'
        )
        ->join(
          NewsletterOption::$_table,
          [
            'options.newsletter_id', '=', self::$_table . '.id',
          ],
          'options'
        )
        ->whereRaw('`options`.`option_field_id` = `option_fields`.`id`')
        ->where('options.value', $group);
      }
      $orm = $orm->where(self::$_table . '.type', $type);
    }
    return $orm;
  }

  static function listingQuery($data = []) {
    $query = self::select(
      [
        self::$_table . '.id',
        self::$_table . '.subject',
        self::$_table . '.hash',
        self::$_table . '.type',
        self::$_table . '.status',
        self::$_table . '.sent_at',
        self::$_table . '.updated_at',
        self::$_table . '.deleted_at',
      ]
    );
    if ($data['sort_by'] === 'sent_at') {
      $query = $query->orderByExpr('ISNULL(sent_at) DESC');
    }
    return $query
      ->filter('filterBy', $data)
      ->filter('groupBy', $data)
      ->filter('search', $data['search']);
  }

  static function createOrUpdate($data = []) {
    return parent::_createOrUpdate($data, false, function($data) {
      $settings = new SettingsController();
      // set default sender based on settings
      if (empty($data['sender'])) {
        $sender = $settings->get('sender', []);
        $data['sender_name'] = (
          !empty($sender['name'])
          ? $sender['name']
          : ''
        );
        $data['sender_address'] = (
          !empty($sender['address'])
          ? $sender['address']
          : ''
        );
      }

      // set default reply_to based on settings
      if (empty($data['reply_to'])) {
        $reply_to = $settings->get('reply_to', []);
        $data['reply_to_name'] = (
          !empty($reply_to['name'])
          ? $reply_to['name']
          : ''
        );
        $data['reply_to_address'] = (
          !empty($reply_to['address'])
          ? $reply_to['address']
          : ''
        );
      }

      return $data;
    });
  }

  static function getWelcomeNotificationsForSegments($segments) {
    return NewsletterOption::tableAlias('options')
      ->select('options.newsletter_id')
      ->select('options.value', 'segment_id')
      ->join(
        self::$_table,
        'newsletters.id = options.newsletter_id',
        'newsletters'
      )
      ->join(
        MP_NEWSLETTER_OPTION_FIELDS_TABLE,
        'option_fields.id = options.option_field_id',
        'option_fields'
      )
      ->whereNull('newsletters.deleted_at')
      ->where('newsletters.type', 'welcome')
      ->where('option_fields.name', 'segment')
      ->whereIn('options.value', $segments)
      ->findMany();
  }

  static function getArchives($segment_ids = []) {
    $orm = self::tableAlias('newsletters')
      ->distinct()->select('newsletters.*')
      ->select('newsletter_rendered_subject')
      ->whereIn('newsletters.type', [
        self::TYPE_STANDARD,
        self::TYPE_NOTIFICATION_HISTORY,
      ])
      ->join(
        MP_SENDING_QUEUES_TABLE,
        'queues.newsletter_id = newsletters.id',
        'queues'
      )
      ->join(
        MP_SCHEDULED_TASKS_TABLE,
        'queues.task_id = tasks.id',
        'tasks'
      )
      ->where('tasks.status', SendingQueue::STATUS_COMPLETED)
      ->whereNull('newsletters.deleted_at')
      ->select('tasks.processed_at')
      ->orderByDesc('tasks.processed_at');

    if (!empty($segment_ids)) {
      $orm->join(
        MP_NEWSLETTER_SEGMENT_TABLE,
        'newsletter_segments.newsletter_id = newsletters.id',
        'newsletter_segments'
      )
      ->whereIn('newsletter_segments.segment_id', $segment_ids);
    }
    return $orm->findMany();
  }

  static function getByHash($hash) {
    return parent::where('hash', $hash)
      ->findOne();
  }

  function getMeta() {
    if (!$this->meta) return;

    return (Helpers::isJson($this->meta)) ? json_decode($this->meta, true) : $this->meta;
  }

  static function findOneWithOptions($id) {
    $newsletter = self::findOne($id);
    if ($newsletter === false) {
      return false;
    }
    return self::filter('filterWithOptions', $newsletter->type)->findOne($id);
  }
}