<?php
/**
 * @author markus
 * $Id: $
 */

/**
 * required files
 * @ignore
 */
require_once('exception.IMAPException.php');

define('IMAP_RETRIES', 5);

/**
 * Wraps PHP built in imap commands within a class, features open, hold, close connection and
 * issue imap commands.
 *
 * @author markus
 */
class imapConnection {

    /**
     * Array mit den bereits vorhandenen Instanzen
     * @var array
     */
    private static $instances = array();

    /**
     * Instanzname, die unterschiedlichen Entitäten werden über den Namen
     * auseinandergehalten.
     * @var string
     */
    private $instanceName = '';

    /**
     * Configsection
     * @var Config
     */
    private $config = null;

    /**
     * IMAP Resource
     * @var imap_stream
     */
    private $imap = null;

    /**
     * Servername, Port, Flags
     * @var string
     */
    private $server = '';

    /**
     * Name der zuletzt geöffneten Mailbox
     * @var string
     */
    private $mbox = '';

    /**
     * wird auf true gesetzt, wenn imapPing die Connection neu aufbaut
     * @var boolean
     */
    private $reopenedConnection = false;

    /**
     * liefert eine Liste der verfügbaren Folder
     * @param string $pattern
     * @return array
     */
    public function imapList($pattern = '*') {
        if ($this->imap === null) {
            throw new IMAPException(__METHOD__ . ' not connected');
        }
        $this->imapPing(true);

        return imap_list($this->imap, $this->server, $pattern);
    }


    /**
     * Checkt die Anzahl Messages in einer Mailbox
     * return array
     */
    public function imapCheck() {
        if ($this->imap === null) {
            throw new IMAPException(__METHOD__ . ' not connected');
        }
        $this->imapPing(true);

        return imap_check($this->imap);
    }


    /**
     * per imap_reopen die aktuelle Connection auf eine andere mbox umstellen
     * @param string $mbox
     * @return boolean
     */
    public function imapSwitchMbox($mbox) {
        if ($this->imap === null) {
            throw new IMAPException(__METHOD__ . ' not connected');
        }
        $this->imapPing(true);

        if (imap_reopen($this->imap, $this->server.$mbox) === false) {
            throw new IMAPException(__METHOD__ . ' reopen failed');
        }

        $this->mbox = $mbox;

        return true;
    }


    /**
     * setzt ein Flag bei allen in $sequence aufgeführten Messages
     * @param string $sequence
     * @param string $flag
     * @param integer $options
     * @return boolean
     */
    public function imapSetflagFull($sequence, $flag, $options = 0) {
        if ($this->imap === null) {
            throw new IMAPException(__METHOD__ . ' not connected');
        }
        $this->imapPing(true);

        return imap_setflag_full($this->imap, $sequence, $flag, $options);
    }


    /**
     * liefert die Mailheader
     * @return array
     */
    public function imapHeaders() {
        if ($this->imap === null) {
            throw new IMAPException(__METHOD__ . ' not connected');
        }
        $this->imapPing(true);

        return imap_headers($this->imap);
    }

    /**
     * liefert die Header zu genau einer Mail mit der gegebenen ID
     * @param integer $number
     * @return array
     */
    public function imapHeader($number) {
        if ($this->imap === null) {
            throw new IMAPException(__METHOD__ . ' not connected');
        }
        $this->imapPing(true);

        return imap_headerinfo($this->imap, $number);
    }

    /**
     * liefert die Header zu genau einer Mail mit der gegebenen UID
     * @param integer $uid
     * @return array
     */
    public function imapFetchHeader($uid) {
        if ($this->imap === null) {
            throw new IMAPException(__METHOD__ . ' not connected');
        }

        $ret = imap_fetchheader($this->imap, $uid, FT_UID);

        return $ret;
    }

    /**
     * liefert die Header zu genau einer Mail mit der gegebenen UID
     * @param integer $uid
     * @return array
     */
    public function imapFetchOverview($uid) {
        if ($this->imap === null) {
            throw new IMAPException(__METHOD__ . ' not connected');
        }

        $ret = imap_fetch_overview($this->imap, $uid, FT_UID);

        return $ret[0];
    }

    /**
     * liefert den Body zu genau einer Mail mit der gegebenen ID
     * @param integer $number
     * @return string
     */
    public function imapBody($number) {
        if ($this->imap === null) {
            throw new IMAPException(__METHOD__ . ' not connected');
        }
        $this->imapPing(true);

        return imap_body($this->imap, $number);
    }

    /**
     * liefert den Body zu genau einer Mail mit der gegebenen UID
     * @param integer $uid
     * @return string
     */
    public function imapBodyByUID($uid) {
        if ($this->imap === null) {
            throw new IMAPException(__METHOD__ . ' not connected');
        }
        $this->imapPing(true);

        return imap_body($this->imap, $uid, FT_UID );
    }

    /**
     * markiert die Nachricht mit der unique ID zum löschen
     * @param integer $uid
     * return boolean
     */
    public function imapDelete($uid) {
        if ($this->imap === null) {
            throw new IMAPException(__METHOD__ . ' not connected');
        }
        $this->imapPing(true);

        $ret = imap_delete($this->imap, $uid, FT_UID);

        if ($ret !== true) {
            print "imap delete returned false for ".$uid."\n";
        }

        return $ret;
    }

    /**
     * löscht alle zum löschen markierten Nachrichten
     * @return boolean
     */
    public function imapExpunge() {
        if ($this->imap === null) {
            throw new IMAPException(__METHOD__ . ' not connected');
        }
        $this->imapPing(true);

        return imap_expunge($this->imap);
    }

    /**
     * kopiert die Nachricht mit der gegebenen uid in die gegebene Mailbox *auf dem selben Server*
     * @param integer $uid
     * @param string $dest_mbox
     * @return boolean
     */
    public function imapMailCopy($uid, $dest_mbox) {
        if ($this->imap === null) {
            throw new IMAPException(__METHOD__ . ' not connected');
        }
        $this->imapPing(true);

        return imap_mail_copy($this->imap, $uid, $dest_mbox, CP_UID);
    }

    /**
     * verschiebt die Nachricht mit der gegebenen uid in die gegebene Mailbox *auf dem selben Server*
     * @param integer $uid
     * @param string $dest_mbox
     * @return boolean
     */
    public function imapMailMove($uid, $dest_mbox) {
        if ($this->imap === null) {
            throw new IMAPException(__METHOD__ . ' not connected');
        }
        $this->imapPing(true);
        /*
         * dont't add the server part,
         * only the mailbox name works fine
         *
         * $dest_mbox = $this->server.$dest_mbox;
         */
        return imap_mail_move( $this->imap, $uid, $dest_mbox, CP_UID);
    }

    /**
     * legt eine neue Mailbox *auf dem selben Server* an
     * @param string $mbox
     * @return boolean
     */
    public function imapCreateMailbox($mbox) {
        if ($this->imap === null) {
            throw new IMAPException(__METHOD__ . ' not connected');
        }
        $this->imapPing(true);

        return imap_createmailbox($this->imap, $this->server.$mbox);
    }

    /**
     * fragt ab, ob eine mbox unterhalb von mbox_root existiert und liefert true zurück, falls ja
     * Funktion existiert nicht direkt als IMAP Kommando, aus einzelnen Kommando's zusammengebaut
     *
     * @param string $mbox_root
     * @param string $mbox
     * @return boolean
     */
    public function imapMailboxExists($mbox_root, $mbox) {
        if ($this->imap === null) {
            throw new IMAPException(__METHOD__ . ' not connected');
        }
        $this->imapPing(true);

        $folderlist = $this->imapList($mbox_root);
        $foundFolder = false;
        foreach ($folderlist as $folder) {
            if (strpos($folder, $mbox) !== false) {
                return true;
            }
        }

        return false;
    }

    const AR_YYYY = 'Y';
    const AR_YYYYMM = 'Ym';
    const AR_YYYYMMDD = 'Ymd';

    /**
     * erzeugt eine Archivmailbox zur Mailbox $mbox, dabei wird das Archiv unterhalb von $mbox
     * auf dem selben Server angelegt, der Name der Mailbox enthält je nach $mode noch einen Datumsstamp
     * Wenn der Input ($mbox) bereits mehrere Ebenen enthält (NOC3.domain.incoming z.B.), dann
     * wird automatisch nur der am weitesten rechts stehende Teil extrahiert und benutzt.
     * NOC3.domain.incoming => NOC3.domain.incoming.incoming-200705
     * @param string $mbox
     * @param string $mode
     * @param integer $timestamp
     * @param string $delimiter
     * @return string
     */
    public static function imapMakeArchiveName($mbox, $mode, $timestamp = null, $delimiter = '-') {
        if ($timestamp === null)
            $timestamp = time();

        $ar = explode('.', $mbox);

        $sub_mbox = $ar[count($ar) - 1];

        return $mbox.'.'.$sub_mbox.$delimiter.date($mode,$timestamp);
    }

    public static function imapMakePrefixedArchiveName($mbox, $mode, $prefix = '', $timestamp = null, $delimiter = '-') {
        if ($timestamp === null)
            $timestamp = time();

        $ar = explode('.', $mbox);

        $sub_mbox = $ar[count($ar) - 1];

        return $mbox.'.'.$prefix.$delimiter.$sub_mbox.$delimiter.date($mode,$timestamp);
    }

    /**
     * liefert die unique ID der Nachricht mit der laufenden msg_number
     * @param integer $msg_number
     * @return integer
     */
    public function imapUID($msg_number) {
        if ($this->imap === null) {
            throw new IMAPException(__METHOD__ . ' not connected');
        }
        $this->imapPing(true);

        return imap_uid($this->imap, $msg_number);
    }


    /**
     * liefert die laufende msg_number der Nachricht, die die unique ID uid hat
     * @param integer $uid
     * @return integer
     */
    public function imapMsgNo($uid) {
        if ($this->imap === null) {
            throw new IMAPException(__METHOD__ . ' not connected');
        }
        $this->imapPing(true);

        return imap_msgno($this->imap, $uid);
    }


    /**
     * prüft, ob die Connection noch aktiv ist, Exception falls keine Connection definiert ist,
     * oder die Connection geschlossen wurde
     * wenn reconnect = true, dann wird bei einer geschlossenen Connection die Connection neu aufgebaut
     * @param boolean $reconnect
     * @return boolean
     */
    public function imapPing($reconnect = false) {
        if ($this->imap === null) {
            throw new IMAPException(__METHOD__ . ' not connected');
        }

        $ret = imap_ping($this->imap);

        if ($ret === false) {
            if ($reconnect === true) {
                $this->imap = $this->imapOpen($this->server.$this->mbox,
                    $this->config->username,
                    $this->config->password,
                    OP_HALFOPEN);

                $ret = imap_ping($this->imap);

                if ($ret === false) {
                    throw new IMAPException(__METHOD__ . ' reconnect failed');
                }

                $this->reopenedConnection = true;
            }
            else {
                throw new IMAPException(__METHOD__ . ' not connected');
            }
        }

        return true;
    }


    public function __destruct() {
        if ($this->imap !== null) {
            imap_close($this->imap);
            $this->imap = null;
        }
    }


    /**
     * true, wenn imapPing die Connection neu aufgemacht hat
     * Variable wird auf false gesetzt wenn $flush true ist
     * @param boolean $flush
     * @return boolean
     */
    public function connectionReopened($flush = true) {
        $ret = $this->reopenedConnection;
        if ($flush === true) {
            $this->reopenedConnection = false;
        }
        return $ret;
    }


    /**
     * interne IMAP Open Methode
     *
     * @param string $servername
     * @param string $username
     * @param string password
     * @param integer $flags
     * @return resource
     */
    protected function imapOpen($server, $username, $password, $flags) {
        return imap_open($server, $username, $password, $flags);
    }


    /**
     * privater Konstruktor, wird exklusiv von getInstance aufgerufen
     *
     * @param $instanceName
     * @param $config
     */
    protected function __construct($instanceName, $config) {
        $this->instanceName = $instanceName;
        $this->config = $config;

        if (!isset($this->config->mailhost)) {
            throw new IMAPException(__METHOD__ . ' config attribute missing: "mailhost"');
        }
        if (!isset($this->config->username)) {
            throw new IMAPException(__METHOD__ . ' config attribute missing: "username"');
        }
        if (!isset($this->config->password)) {
            throw new IMAPException(__METHOD__ . ' config attribute missing: "password"');
        }
        if (!isset($this->config->port)) {
            throw new IMAPException(__METHOD__ . ' config attribute missing: "port"');
        }

        $this->server = '{'.$this->config->mailhost.':'.$this->config->port.'/imap';
        if( isset($this->config->use_tls) &&
            $this->config->use_tls != 0 ) {
            $this->server .= '/tls';
        }
        $this->server .= '/novalidate-cert}';

        $mbox = '';

        $this->mbox = $mbox;

        $this->imap = null;

        $this->imap = $this->imapOpen($this->server.$mbox,
            $this->config->username,
            $this->config->password,
            OP_HALFOPEN);

        if ($this->imap === false) {
            $this->imap = null;
            throw new IMAPException(__METHOD__ . ' not connected');
        }

        $this->reopenedConnection = false;
    }


    /**
     * sucht nach einer bereits vorhandenen Instanz, wird keine gefunden,
     * dann wird eine neue Instanz angelegt.
     * Man kann die Config-Variable weglassen, wenn man sicher ist, dass
     * bereits eine Instanz mit dem gewünschten instanceName existiert,
     * existiert aber keiner, dann liefert getInstance eine Exception.
     *
     * @param $instance
     * @param $config
     * @return imapConnection
     */
    public static function getInstance($instanceName,$config = null) {
        if (!self::$instances)
            self::$instances = array();

        foreach (self::$instances as $instance) {
            if ($instance->getInstanceName() == $instanceName)
                return $instance;
        }

        /*
        if (!$config instanceof Config) {
            throw new IMAPException(__METHOD__ . ' no config');
        }
        */

        $object = new imapConnection($instanceName, $config);

        self::$instances[] = $object;

        return $object;
    }


    /**
     * Liefert den Namen der aktuellen Instanz
     * @return string
     */
    public function getInstanceName() {
        return $this->instanceName;
    }


}