<?php

/**
 * SOTESHOP/stMailPlugin
 *
 * Ten plik należy do aplikacji stMailPlugin opartej na licencji (Professional License SOTE).
 * Nie zmieniaj tego pliku, jeśli chcesz korzystać z automatycznych aktualizacji oprogramowania.
 * Jeśli chcesz wprowadzać swoje modyfikacje do programu, zapoznaj się z dokumentacją, jak zmieniać
 * oprogramowanie bez zmiany kodu bazowego http://www.sote.pl/modifications
 *
 * @package     stMailPlugin
 * @subpackage  libs
 * @copyright   SOTE (www.sote.pl)
 * @license     http://www.sote.pl/license/sote (Professional License SOTE)
 * @version     $Id: stMail.class.php 12185 2011-04-13 11:31:16Z marcin $
 * @author      Marcin Butlak <marcin.butlak@sote.pl>
 */

/**
 * Klasa stMailTemplate
 *
 * @author Marcin Butlak <marcin.butlak@sote.pl>
 *
 * @package     stMailPlugin
 * @subpackage  libs
 */
class stMailTemplate
{

   /**
    * Zwraca zawartosc szablonu dla maili
    *
    * @param   string      $templateName       Nazwa szablonu
    * @param   array       $templateVars       zmienne przekazywane do szablonu
    * @return  string      zawartosc szablonu
    */
   static public function render($templateName, $templateVars = array())
   {
      $context = sfContext::getInstance();

      $actionName = $templateName."Mail";

      if (($pos = strpos($templateName, '/')) !== false)
      {
         $moduleName = substr($templateName, 0, $pos);

         $templateFile = substr($templateName, $pos + 1);
      }
      else
      {
         $moduleName = $context->getModuleName();

         $templateFile = $templateName;
      }

      $actionName = $templateFile.'Mail';

      $view = new sfPartialView();
      $view->initialize($context, $moduleName, $actionName, '');
      return $view->render($templateVars);
   }

}

/**
 * A wrapper class which implements most of the Swift mailer functionality
 *
 * This class only purpose is to maintain the compatibility between Swift mailer versions
 * 
 * @author Marcin Butlak <marcin.butlak@sote.pl>
 *
 * @package     stMailPlugin
 * @subpackage  libs
 */
class stMail
{

   protected static $instance = array();
   protected static $port = array('tls' => 25, 'ssl' => 465, null => 25);
   /**
    * @var stMailLogger
    */
   protected $logger = null;
   /**
    * @var Swift_Message
    */
   protected $message = null;
   /**
    * @var Swift_Mailer
    */
   public $mailer = null;

   protected $attachments = array();

   const TIMEOUT = 30;

   /**
    * Adres email wysyłającego wiadomość
    *
    * @var string
    */
   protected $sender = null;

   /**
    * Singleton
    *
    * @return static
    */
   public static function getInstance($class = null)
   {
      if (!isset(self::$instance[$class]))
      {
         if (null === $class)
         {
            $class = __CLASS__;
         }

         self::$instance[$class] = new $class();

         self::$instance[$class]->initialize();
      }

      return self::$instance[$class];
   }

   /**
    *
    * Initialize
    *
    */
   public function initialize()
   {
      require_once sfConfig::get('sf_plugins_dir').'/stSwiftPlugin/vendor/autoload.php';

      if (sfConfig::get('sf_logging_enabled'))
      {
         $this->logger = new stMailLogger();
      }

      $this->setConnection(new Swift_SmtpTransport());

      $this->createNewMessage();
   }

   /**
    *
    * Validate the current connection
    *
    * @return bool Return true if everything is ok, false otherwise
    */
   public function validateConnection()
   {
      $transport = $this->mailer->getTransport();

      try
      {
         $transport->start();
      }
      catch (Exception $e)
      {
         return false;
      }

      return $transport->isStarted();
   }

   /**
    *
    * Return Swift Mailer instance
    *
    * @return Swift_Mailer instance
    */
   public function getSwiftMailer()
   {
      return $this->mailer;
   }

   public function createNewMessage($subject = null, $body = null)
   {
      $this->message = new Swift_Message($subject, $body);

      return $this;
   }

   /**
    * @deprecated use setSmtpConnection
    */
   public function addSmtpConnection($email, $host = 'localhost', $port = null, $username = null, $password = null, $security = null)
   {
      return $this->setSmtpConnection($email, $host, $port, $username, $password, $security);
   }

   /**
    * Set a new smtp connection
    * @param string $sender
    * @param string $host
    * @param int $port
    * @param string $username
    * @param string $password
    * @param int $security
    * @return static
    */
   public function setSmtpConnection($sender, $host = 'localhost', $port = null, $username = null, $password = null, $security = null)
   {
      $transport = new Swift_SmtpTransport($host, $port, $security);
      if (isset($username))
      {
         $transport->setUsername($username);
      }

      if (isset($password))
      {
         $transport->setPassword($password);
      }

      $transport->setTimeout(self::TIMEOUT);

      $this->setConnection($transport);

      $this->sender = $sender;

      return $this;
   }

   /**
    * Set swift connection
    *
    * @param Swift_Transport $transport
    * 
    * @return static
    */
   public function setConnection($transport)
   {
      $this->mailer = new Swift_Mailer($transport);

      if ($this->logger)
      {
         $this->mailer->registerPlugin(new Swift_Plugins_LoggerPlugin($this->logger));
      }

      return $this;
   }

   /**
    * Set the html body content of this message
    * @param string $content
    * 
    * @return static
    */
   public function setHtmlMessage($content)
   {
      $this->message->setBody(self::addHost($content), 'text/html');

      return $this;
   }

   /**
    * Set the alternative plain text body content of this message
    * @param string $content
    * 
    * @return static
    */
   public function setPlainMessage($content)
   {
      $this->message->addPart(self::addHost($content), 'text/plain');

      return $this;
   }

   /**
    * Set the From address
    * 
    * It is permissible for multiple From addresses to be set using an array.
    * 
    * If multiple From addresses are used, you SHOULD set the Sender address and
    * according to RFC 2822, MUST set the sender address.
    * 
    * An array can be used if display names are to be provided: i.e.
    * array('email@address.com' => 'Real Name').
    * 
    * If the second parameter is provided and the first is a string, then $name
    * is associated with the address.
    *
    * @param mixed $addresses
    * @param string $name optional
    */
   public function setFrom($addresses, $name = null)
   {
      $this->message->setFrom($addresses, $name);

      return $this;
   }

   /**
    * Set the sender of this message.
    * 
    * If multiple addresses are present in the From field, this SHOULD be set.
    * 
    * According to RFC 2822 it is a requirement when there are multiple From
    * addresses, but Swift itself does not require it directly.
    * 
    * An associative array (with one element!) can be used to provide a display-
    * name: i.e. array('email@address' => 'Real Name').
    * 
    * If the second parameter is provided and the first is a string, then $name
    * is associated with the address.
    * 
    * @param mixed $address
    * @param string $name optional
    * @return static 
    */
   public function setSender($address, $name = null)
   {
      $this->message->setSender($address, $name);

      return $this;
   }

   /**
    * Set the To address(es).
    * 
    * Recipients set in this field will receive a copy of this message.
    * 
    * This method has the same synopsis as {@link setFrom()} and {@link setCc()}.
    * 
    * If the second parameter is provided and the first is a string, then $name
    * is associated with the address.
    * 
    * @param mixed $addresses
    * @param string $name optional
    * @return static
    */
   public function setTo($addresses, $name = null)
   {
      $this->message->setTo($addresses, $name);

      return $this;
   }

   /**
    * Set the Bcc address(es).
    *
    * Recipients set in this field will receive a 'blind-carbon-copy' of this
    * message.
    *
    * In other words, they will get the message, but any other recipients of the
    * message will have no such knowledge of their receipt of it.
    *
    * This method has the same synopsis as {@link setFrom()} and {@link setTo()}.
    *
    * @param mixed $addresses
    * @param string $name optional
    */
   public function setBcc($addresses, $name = null)
   {
      $this->message->setBcc($addresses, $name);

      return $this;
   }

   /**
    * Add a Bcc: address
    *
    * If $name is passed this name will be associated with the address.
    *
    * @param string $address
    * @param string $name optional
    */
   public function addBcc($address, $name = null)
   {
      $this->message->addBcc($address, $name);
   }

   /**
    * Set the Reply-To address(es).
    * 
    * Any replies from the receiver will be sent to this address.
    * 
    * It is permissible for multiple reply-to addresses to be set using an array.
    * 
    * This method has the same synopsis as {@link setFrom()} and {@link setTo()}.
    * 
    * If the second parameter is provided and the first is a string, then $name
    * is associated with the address.
    * 
    * @param mixed $addresses
    * @param string $name optional
    * @return static
    */
   public function setReplyTo($addresses, $name = null)
   {
      $this->message->setReplyTo($addresses, $name);

      return $this;
   }

   /**
    * Set subject of this message
    *
    * @param string $subject  
    * @return static
    */
   public function setSubject($subject)
   {
      $this->message->setSubject($subject);

      return $this;
   }

   public function getSubject()
   {
      return $this->message->getSubject();
   }

   /**
    * Set the charaset of this message
    * 
    * @param string $charset
    * @return static
    */
   public function setCharset($charset = 'utf-8')
   {
      $this->message->setCharset($charset);

      return $this;
   }

   /**
    * Add a new Attachment from a filesystem path
    * 
    * @param string $filename optional
    * @param string $path
    * @param string $content_type optional
    * @return static
    */
   public function addAttachment($filename = null, $path, $content_type = null)
   {
      $attachment = Swift_Attachment::fromPath($path, $content_type);

      if ($filename)
      {
         $attachment->setFilename($filename);
      }

      $this->message->attach($attachment);

      $this->attachments[] = $attachment;

      return $this;
   }

   public function addAttachmentData($filename, $data, $content_type)
   {
      $attachment = Swift_Attachment::newInstance($data, $filename, $content_type); 
       
      $this->message->attach($attachment);

      $this->attachments[] = $attachment;

      return $this;          
   }

   public function removeAttachments()
   {
      foreach ($this->attachments as $attachment)
      {
         $this->message->detach($attachment);
      }

      $this->attachments = array();

      return $this;
   }

   /**
    * Send the given Message like it would be sent in a mail client.
    *
    * All recipients (with the exception of Bcc) will be able to see the other
    * recipients this message was sent to.
    *
    * If you need to send to each recipient without disclosing details about the
    * other recipients see {@link batchSend()}.
    *
    * The return value is the number of recipients who were accepted for
    * delivery.
    *
    * @param array &$failed_recipients, optional
    * @return int
    * @see batchSend()
    */
   public function send(&$failed_recipients = null)
   {
      try
      {
         if (!$this->message->getSender())
         {
            $this->message->setSender($this->sender);
         }

         if (!$this->message->getFrom())
         {
            $this->message->setFrom($this->sender);
         }

         $ret = $this->mailer->send($this->message, $failed_recipients);
         $this->createNewMessage();
      }
      catch (Exception $e)
      {
         $ret = false;
      }

      return $ret;
   }

   /**
    * Send the given Message to all recipients individually.
    *
    * This differs from {@link send()} in the way headers are presented to the
    * recipient.  The only recipient in the "To:" field will be the individual
    * recipient it was sent to.
    *
    * The return value is the number of recipients who were accepted for
    * delivery.
    *
    * @param array &$failedRecipients, optional
    * @return int
    * @see send()
    */
   public function sendBatch(&$failed_recipients = null)
   {
      try
      {
         $ret = $this->mailer->send($this->message, $failed_recipients);
         $this->createNewMessage();
      }
      catch (Exception $e)
      {
         $ret = false;
      }

      return $ret;
   }

   public static function defaultPort($security = null)
   {
      return isset(self::$port[$security]) ? self::$port[$security] : self::$port[null];
   }
   
   public static function getDefaultPorts()
   {
      return self::$port;
   }

   public static function addHost($content)
   {
      return sfContext::getInstance()->getRequest()->addHost($content);
   }

}