";
		#$this->icServer->setDebug(true);
		$total=0;
		if ($_thisUIDOnly === null)
		{
			if (($_startMessage || $_numberOfMessages) && !isset($_filter['range']))
			{
				// this will not work we must calculate the range we want to retieve as e.g.: 0:20 retirieves the first 20 mails and sorts them
				// if sort capability is applied to the range fetched, not sort first and fetch the range afterwards
				//$start = $_startMessage-1;
				//$end = $_startMessage-1+$_numberOfMessages;
				//$_filter['range'] ="$start:$end";
				//$_filter['range'] ="$_startMessage:*";
			}
			if (self::$debug) error_log(__METHOD__.' ('.__LINE__.') '."$_folderName, $_sort, $reverse, ".array2string($_filter).", $rByUid");
			if (self::$debug||self::$debugTimes) $starttime = microtime (true);
			//see this example below for a 12 week datefilter (since)
			//$_filter = array('status'=>array('UNDELETED'),'type'=>"SINCE",'string'=> date("d-M-Y", $starttime-(3600*24*7*12)));
			$_sortResult = $this->getSortedList($_folderName, $_sort, $reverse, $_filter, $rByUid, $_cacheResult);
			$sortResult = $_sortResult['match']->ids;
			//$modseq = $_sortResult['modseq'];
			//error_log(__METHOD__.' ('.__LINE__.') '.'Modsequence:'.$modseq);
			if (self::$debug||self::$debugTimes) self::logRunTimes($starttime,null,' call getSortedList for Folder:'.$_folderName.' Filter:'.array2string($_filter).' Ids:'.array2string($_thisUIDOnly),__METHOD__.' ('.__LINE__.') ');

			if (self::$debug) error_log(__METHOD__.' ('.__LINE__.') '.array2string($sortResult));
			#$this->icServer->setDebug(false);
			#print "

, so we rather don't
		//$_html = str_replace("\r\n",' ',$_html);
		//$_html = str_replace("\t",' ',$_html);
		//error_log(__METHOD__.__LINE__.':'.$_html);
		//repair doubleencoded ampersands, and some stuff htmLawed stumbles upon with balancing switched on
		$_html = str_replace(array('&','

',"
 
",'
 
','','
','','','',''),
							 array('&',    '
',           '
',             '
',             '','',    '',         '',           '',  ''),$_html);
		//$_html = str_replace(array('&'),array('&'),$_html);
		if (stripos($_html,'style')!==false) Mail\Html::replaceTagsCompletley($_html,'style'); // clean out empty or pagewide style definitions / left over tags
		if (stripos($_html,'head')!==false) Mail\Html::replaceTagsCompletley($_html,'head'); // Strip out stuff in head
		//if (stripos($_html,'![if')!==false && stripos($_html,'')!==false) Mail\Html::replaceTagsCompletley($_html,'!\[if','',false); // Strip out stuff in ifs
		//if (stripos($_html,'!--[if')!==false && stripos($_html,'')!==false) Mail\Html::replaceTagsCompletley($_html,'!--\[if','',false); // Strip out stuff in ifs
		//error_log(__METHOD__.' ('.__LINE__.') '.$_html);

		if (function_exists('get_magic_quotes_gpc') && get_magic_quotes_gpc() === 1) $_html = stripslashes($_html);
		// Strip out doctype in head, as htmlLawed cannot handle it TODO: Consider extracting it and adding it afterwards
		if (stripos($_html,'!doctype')!==false) Mail\Html::replaceTagsCompletley($_html,'!doctype');
		if (stripos($_html,'?xml:namespace')!==false) Mail\Html::replaceTagsCompletley($_html,'\?xml:namespace','/>',false);
		if (stripos($_html,'?xml version')!==false) Mail\Html::replaceTagsCompletley($_html,'\?xml version','\?>',false);
		if (strpos($_html,'!CURSOR')!==false) Mail\Html::replaceTagsCompletley($_html,'!CURSOR');
		// htmLawed filter only the 'body'
		//preg_match('`(]*>)(.+?)(.*?)`ims', $_html, $matches);
		//if ($matches[2])
		//{
		//	$hasOther = true;
		//	$_html = $matches[2];
		//}
		// purify got switched to htmLawed
		// some testcode to test purifying / htmlawed
		//$_html = "
hi 
 there 
 kram 
 
".$_html;
		$_html = Html\HtmLawed::purify($_html,self::$htmLawed_config,array(),true);
		//if ($hasOther) $_html = $matches[1]. $_html. $matches[3];
		// clean out comments , should not be needed as purify should do the job.
		$search = array(
			'@url\(http:\/\/[^\)].*?\)@si',  // url calls e.g. in style definitions
			'@@',         // Strip multi-line comments including CDATA
		);
		$_html = preg_replace($search,"",$_html);
		// remove non printable chars
		$_html = preg_replace('/([\000-\011])/','',$_html);
		//error_log(__METHOD__.':'.__LINE__.':'.$_html);
	}

	/**
	 * Header and Bodystructure stuff
	 */

	/**
	 * getMimePartCharset - fetches the charset mimepart if it exists
	 * @param $_mimePartObject structure object
	 * @return mixed mimepart or false if no CHARSET is found, the missing charset has to be handled somewhere else,
	 *		as we cannot safely assume any charset as we did earlier
	 */
	function getMimePartCharset($_mimePartObject)
	{
		//$charSet = 'iso-8859-1';//self::$displayCharset; //'iso-8859-1'; // self::displayCharset seems to be asmarter fallback than iso-8859-1
		$CharsetFound=false;
		//echo "#".$_mimePartObject->encoding.'#
';
		if(is_array($_mimePartObject->parameters)) {
			if(isset($_mimePartObject->parameters['CHARSET'])) {
				$charSet = $_mimePartObject->parameters['CHARSET'];
				$CharsetFound=true;
			}
		}
		// this one is dirty, but until I find something that does the trick of detecting the encoding, ....
		//if ($CharsetFound == false && $_mimePartObject->encoding == "QUOTED-PRINTABLE") $charSet = 'iso-8859-1'; //assume quoted-printable to be ISO
		//if ($CharsetFound == false && $_mimePartObject->encoding == "BASE64") $charSet = 'utf-8'; // assume BASE64 to be UTF8
		return ($CharsetFound ? $charSet : $CharsetFound);
	}

	/**
	 * decodeMimePart - fetches the charset mimepart if it exists
	 * @param string $_mimeMessage - the message to be decoded
	 * @param string $_encoding - the encoding used BASE64 and QUOTED-PRINTABLE is supported
	 * @param string $_charset - not used
	 * @return string decoded mimePart
	 */
	function decodeMimePart($_mimeMessage, $_encoding, $_charset = '')
	{
		// decode the part
		if (self::$debug) error_log(__METHOD__."() with $_encoding and $_charset:".print_r($_mimeMessage,true));
		switch (strtoupper($_encoding))
		{
			case 'BASE64':
				// use imap_base64 to decode, not any longer, as it is strict, and fails if it encounters invalid chars
				return base64_decode($_mimeMessage);

			case 'QUOTED-PRINTABLE':
				// use imap_qprint to decode
				return quoted_printable_decode($_mimeMessage);

			case 'WEDONTKNOWTHEENCODING':
				// try base64
				$r = base64_decode($_mimeMessage);
				if (json_encode($r))
				{
					return $r;
				}
				//we do not know the encoding, so we do not decode
			default:
				// it is either not encoded or we don't know about it
				return $_mimeMessage;
		}
	}

	/**
	 * get part of the message, if its stucture is indicating its of multipart alternative style
	 * a wrapper for multipartmixed
	 * @param string/int $_uid the messageuid,
	 * @param Horde_Mime_Part $_structure structure for parsing
	 * @param string $_htmlMode how to display a message, html, plain text, ...
	 * @param boolean $_preserveSeen flag to preserve the seenflag by using body.peek
	 * @param Horde_Mime_Part& $partCalendar =null on return text/calendar part, if one was contained or false
	 * @return array containing the desired part
	 */
	function getMultipartAlternative($_uid, Horde_Mime_Part $_structure, $_htmlMode, $_preserveSeen = false, &$partCalendar=null)
	{
		// a multipart/alternative has exactly 2 parts (text and html  OR  text and something else)
		// sometimes there are 3 parts, when there is an ics/ical attached/included-> we want to show that
		// as attachment AND as abstracted ical information (we use our notification style here).
		$partText = $partCalendar = $partHTML = null;
		if (self::$debug) _debug_array(array("METHOD"=>__METHOD__,"LINE"=>__LINE__,"STRUCTURE"=>$_structure));
		//error_log(__METHOD__.' ('.__LINE__.') ');
		$ignore_first_part = true;
		foreach($_structure->contentTypeMap() as $mime_id => $mime_type)
		{
			//error_log(__METHOD__."($_uid, ".$_structure->getMimeId().") $mime_id: $mime_type"." ignoreFirstPart:".$ignore_first_part);
			if (self::$debug) echo __METHOD__."($_uid, partID=".$_structure->getMimeId().") $mime_id: $mime_type
";

			if ($ignore_first_part)
			{
				$ignore_first_part = false;
				continue;	// ignore multipart/alternative itself
			}

			$mimePart = $_structure->getPart($mime_id);

			switch($mimePart->getPrimaryType())
			{
				case 'text':
					switch($mimePart->getSubType())
					{
						case 'plain':
							if ($mimePart->getBytes() > 0) $partText = $mimePart;
							break;

						case 'html':
							if ($mimePart->getBytes() > 0)  $partHTML = $mimePart;
							break;

						case 'calendar':
							if ($mimePart->getBytes() > 0)  $partCalendar = $mimePart;
							break;
					}
					break;

				case 'multipart':
					switch($mimePart->getSubType())
					{
						case 'related':
						case 'mixed':
							if (count($mimePart->getParts()) > 1)
							{
								// in a multipart alternative we treat the multipart/related as html part
								if (self::$debug) error_log(__METHOD__." process MULTIPART/".$mimePart->getSubType()." with array as subparts");
								$partHTML = $mimePart;
								break 3; // GET OUT OF LOOP, will be processed according to type
							}
							break;
						case 'alternative':
							if (count($mimePart->getParts()) > 1)
							{
								//cascading multipartAlternative structure, assuming only the first one is to be used
								return $this->getMultipartAlternative($_uid, $mimePart, $_htmlMode, $_preserveSeen);
							}
					}
			}
		}

		switch($_htmlMode)
		{
			case 'html_only':
			case 'always_display':
				if ($partHTML)
				{
					switch($partHTML->getSubType())
					{
						case 'related':
							return $this->getMultipartRelated($_uid, $partHTML, $_htmlMode, $_preserveSeen);

						case 'mixed':
							return $this->getMultipartMixed($_uid, $partHTML, $_htmlMode, $_preserveSeen);

						default:
							return $this->getTextPart($_uid, $partHTML, $_htmlMode, $_preserveSeen);
					}
				}
				elseif ($partText && $_htmlMode=='always_display')
				{
					return $this->getTextPart($_uid, $partText, $_htmlMode, $_preserveSeen);
				}
				break;

			case 'only_if_no_text':
				if ($partText)
				{
					return $this->getTextPart($_uid, $partText, $_htmlMode, $_preserveSeen);
				}
				if ($partHTML)
				{
					if ($partHTML->getPrimaryType())
					{
						return $this->getMultipartRelated($_uid, $partHTML, $_htmlMode, $_preserveSeen);
					}
					return $this->getTextPart($_uid, $partHTML, 'always_display', $_preserveSeen);
				}
				break;

			default:
				if ($partText)
				{
					return $this->getTextPart($_uid, $partText, $_htmlMode, $_preserveSeen);
				}
				$bodyPart = array(
					'body'		=> lang("no plain text part found"),
					'mimeType'	=> 'text/plain',
					'charSet'	=> self::$displayCharset,
				);
				break;
		}
		return $bodyPart ?? null;
	}

	/**
	 * Get part of the message, if its stucture is indicating its of multipart mixed style
	 *
	 * @param int $_uid the messageuid,
	 * @param Horde_Mime_Part $_structure = '' if given use structure for parsing
	 * @param string $_htmlMode how to display a message, html, plain text, ...
	 * @param boolean $_preserveSeen flag to preserve the seenflag by using body.peek
	 * @param array& $skipParts - passed by reference to have control/knowledge which parts are already fetched
	 * @param Horde_Mime_Part& $partCalendar =null on return text/calendar part, if one was contained or false
	 * @return array containing the desired part
	 */
	function getMultipartMixed($_uid, Horde_Mime_Part $_structure, $_htmlMode, $_preserveSeen = false, &$skipParts=array(), &$partCalendar=null)
	{
		if (self::$debug) echo __METHOD__."$_uid, $_htmlMode
";
		$bodyPart = array();
		if (self::$debug) _debug_array($_structure);

		$ignore_first_part = true;
		//$skipParts = array();
		//error_log(__METHOD__.__LINE__.array2string($_structure->contentTypeMap()));
		foreach($_structure->contentTypeMap() as $mime_id => $mime_type)
		{
			//error_log(__METHOD__."($_uid, ".$_structure->getMimeId().") $mime_id: $mime_type");
			if (self::$debug) echo __METHOD__."($_uid, partID=".$_structure->getMimeId().") $mime_id: $mime_type
";
			if ($ignore_first_part)
			{
				$ignore_first_part = false;
				//error_log(__METHOD__."($_uid, ".$_structure->getMimeId().") SKIPPED FirstPart $mime_id: $mime_type");
				continue;	// ignore multipart/mixed itself
			}
			if (array_key_exists($mime_id,$skipParts))
			{
				//error_log(__METHOD__."($_uid, ".$_structure->getMimeId().") SKIPPED $mime_id: $mime_type");
				continue;
			}

			$part = $_structure->getPart($mime_id);

			switch($part->getPrimaryType())
			{
				case 'multipart':
					if ($part->getDisposition() == 'attachment') continue 2;	// +1 for switch
					switch($part->getSubType())
					{
						case 'alternative':
							return array($this->getMultipartAlternative($_uid, $part, $_htmlMode, $_preserveSeen, $partCalendar));

						case 'mixed':
						case 'signed':
							$bodyPart = array_merge($bodyPart, $this->getMultipartMixed($_uid, $part, $_htmlMode, $_preserveSeen, $skipParts, $partCalendar));
							break;

						case 'related':
							$bodyPart = array_merge($bodyPart, $this->getMultipartRelated($_uid, $part, $_htmlMode, $_preserveSeen, $partCalendar, $skipParts));
							break;
					}
					break;
				case 'application':
					switch($part->getSubType())
					{
						case 'pgp-encrypted':
							if (($part = $_structure->getPart($mime_id+1)) &&
								$part->getType() == 'application/octet-stream')
							{
								$this->fetchPartContents($_uid, $part);
								$skipParts[$mime_id]=$mime_type;
								$skipParts[$mime_id+1]=$part->getType();
								$bodyPart[] = array(
									'body'		=> $part->getContents(array(
										'stream' => false,
									)),
									'mimeType'  => 'text/plain',
									'charSet'	=> $_structure->getCharset(),
								);
							}
							break;
					}
					break;

				case 'text':
					switch($part->getSubType())
					{
						case 'calendar': // inline ics/ical files
							if($part->getBytes() > 0)
							{
								$partCalendar = $part;
							}
						// Fall through in case user has no calendar access
						case 'plain':
						case 'html':
							if($part->getDisposition() != 'attachment')
							{
								$bodyPart[] = $this->getTextPart($_uid, $part, $_htmlMode, $_preserveSeen);
								$skipParts[$mime_id] = $mime_type;
							}
							//error_log(__METHOD__.' ('.__LINE__.') '.' ->'.$part->type."/".$part->subType.' -> BodyPart:'.array2string($bodyPart[count($bodyPart)-1]));
							break;
					}
					break;

				case 'message':
					//skip attachments
					if($part->getSubType() == 'delivery-status' && $part->getDisposition() != 'attachment')
					{
						$bodyPart[] = $this->getTextPart($_uid, $part, $_htmlMode, $_preserveSeen);
						$skipParts[$mime_id]=$mime_type;
					}
					// do not descend into attached Messages
					if($part->getSubType() == 'rfc822' || $part->getDisposition() == 'attachment')
					{
						$skipParts[$mime_id.'.0'] = $mime_type;
						foreach($part->contentTypeMap() as $sub_id => $sub_type){ $skipParts[$sub_id] = $sub_type;}
						//error_log(__METHOD__.' ('.__LINE__.') '.' Uid:'.$_uid.' Part:'.$mime_id.':'.array2string($skipParts));
						//break 2;
					}
					break;

				default:
					// do nothing
					// the part is a attachment
			}
		}
		return $bodyPart;
	}

	/**
	 * getMultipartRelated
	 * get part of the message, if its stucture is indicating its of multipart related style
	 * a wrapper for multipartmixed
	 * @param string/int $_uid the messageuid,
	 * @param Horde_Mime_Part $_structure if given use structure for parsing
	 * @param string $_htmlMode how to display a message, html, plain text, ...
	 * @param boolean $_preserveSeen flag to preserve the seenflag by using body.peek
	 * @param Horde_Mime_Part& $partCalendar =null on return text/calendar part, if one was contained or false
	 * @param array& $skipParts - passed by reference to have control/knowledge which parts are already fetched
	 * @return array containing the desired part
	 */
	function getMultipartRelated($_uid, Horde_Mime_Part $_structure, $_htmlMode, $_preserveSeen=false, &$partCalendar=null, &$skipParts=array())
	{
		return $this->getMultipartMixed($_uid, $_structure, $_htmlMode, $_preserveSeen, $skipParts, $partCalendar);
	}

	/**
	 * Fetch a body part
	 *
	 * @param int $_uid
	 * @param string $_partID = null
	 * @param string $_folder = null
	 * @param boolean $_preserveSeen = false
	 * @param boolean $_stream = false true return a stream, false return string
	 * @param string &$_encoding = null on return: transfer encoding of returned part
	 * @param boolean $_tryDecodingServerside = true; wether to try to fetch Data with BINARY instead of BODY
	 * @return string|resource
	 */
	function getBodyPart($_uid, $_partID=null, $_folder=null, $_preserveSeen=false, $_stream=false, &$_encoding=null, $_tryDecodingServerside=true)
	{
		if (self::$debug) error_log( __METHOD__.__LINE__."(".array2string($_uid).", $_partID, $_folder, $_preserveSeen, $_stream, $_encoding, $_tryDecodingServerside)");

		if (empty($_folder))
		{
			$_folder = $this->sessionData['mailbox'] ?? $this->icServer->getCurrentMailbox();
		}
		//error_log(__METHOD__.' ('.__LINE__.') '.array2string($_folder).'/'.$this->icServer->getCurrentMailbox().'/'. $this->sessionData['mailbox']);
		// querying contents of body part
		$uidsToFetch = new Horde_Imap_Client_Ids();
		if (!(is_object($_uid) || is_array($_uid))) $_uid = (array)$_uid;
		$uidsToFetch->add($_uid);

		$fquery = new Horde_Imap_Client_Fetch_Query();
		$fetchParams = array(
			'peek' => $_preserveSeen,
			'decode' => true,	// try decode on server, does NOT neccessary work
		);
		if ($_tryDecodingServerside===false)// || ($_tryDecodingServerside&&$this->isDraftFolder($_folder)))
		{
			$_tryDecodingServerside=false;
			$fetchParams = array(
				'peek' => $_preserveSeen,
			);
		}
		$fquery->bodyPart($_partID, $fetchParams);

		$part = $this->icServer->fetch($_folder, $fquery, array(
			'ids' => $uidsToFetch,
		))->first();
		$partToReturn = null;
		if ($part)
		{
			$_encoding = $part->getBodyPartDecode($_partID);
			//error_log(__METHOD__.__LINE__.':'.$_encoding.'#');
			$partToReturn = $part->getBodyPart($_partID, $_stream);
			//error_log(__METHOD__.__LINE__.':'.$partToReturn.'#');
		}
		// if we get an empty result, server may have trouble fetching data with UID FETCH $_uid (BINARY.PEEK[$_partID])
		// thus we trigger a second go with UID FETCH $_uid (BODY.PEEK[$_partID])
		if (empty($partToReturn)&&$_tryDecodingServerside===true)
		{
			error_log(__METHOD__.__LINE__.' failed to fetch bodyPart in  BINARY. Try BODY');
			try {
				$partToReturn = $this->getBodyPart($_uid, $_partID, $_folder, $_preserveSeen, $_stream, $_encoding, false);
			}
			catch(\Exception $e) {
				// mail probably has no text-body
			}
		}
		return $partToReturn ?: null;
	}

	/**
	 * Get Body from message
	 *
	 * @param int $_uid the messageuid
	 * @param Horde_Mime_Part $_structure = null if given use structure for parsing
	 * @param string $_htmlMode how to display a message: 'html_only', 'always_display', 'only_if_no_text' or ''
	 * @param boolean $_preserveSeen flag to preserve the seenflag by using body.peek
	 * @param boolean $_stream = false true return a stream, false return string
	 * @return array containing the desired text part, mimeType and charset
	 */
	function getTextPart($_uid, Horde_Mime_Part $_structure, $_htmlMode='', $_preserveSeen=false, $_stream=false)
	{
		//error_log(__METHOD__.' ('.__LINE__.') '.'->'.$_uid.':'.array2string($_structure).' '.function_backtrace());
		$bodyPart = array();
		if (self::$debug) _debug_array(array($_structure,function_backtrace()));

		if($_structure->getSubType() == 'html' && !in_array($_htmlMode, array('html_only', 'always_display', 'only_if_no_text')))
		{
			$bodyPart = array(
				'error'		=> 1,
				'body'		=> lang("displaying html messages is disabled"),
				'mimeType'	=> 'text/html',
				'charSet'	=> self::$displayCharset,
			);
		}
		elseif ($_structure->getSubType() == 'plain' && $_htmlMode == 'html_only')
		{
			$bodyPart = array(
				'error'		=> 1,
				'body'      => lang("displaying plain messages is disabled"),
				'mimeType'  => 'text/plain', // make sure we do not return mimeType text/html
				'charSet'   => self::$displayCharset,
			);
		}
		else
		{
			// some Servers append PropertyFile___ ; strip that here for display
			// RB: not sure what this is: preg_replace('/PropertyFile___$/','',$this->decodeMimePart($mimePartBody, $_structure->encoding, $this->getMimePartCharset($_structure))),

			// Should not try to fetch if the content is already there (e.g. Smime encrypted message)
			try {
				if (empty($_structure->getContents())) $this->fetchPartContents($_uid, $_structure, $_stream, $_preserveSeen);

				$bodyPart = array(
					'body' => $_structure->getContents(array(
						'stream' => $_stream,
					)),
					'mimeType' => $_structure->getType() == 'text/html' ? 'text/html' : 'text/plain',
					'charSet' => $_structure->getCharset(),
				);
			}
			catch (\Exception $e) {
				$bodyPart = array(
					'error'		=> 1,
					'body'      => lang('Mail probably has no text-body').":\n\n".$e->getMessage(),
					'mimeType'  => 'text/plain', // make sure we do not return mimeType text/html
					'charSet'   => self::$displayCharset,
				);
			}
		}
		return $bodyPart;
	}

	/**
	 * Get Body of message
	 *
	 * @param int $_uid the messageuid,
	 * @param string $_htmlOptions how to display a message, html, plain text, ...
	 * @param string $_partID = null the partID, may be omitted
	 * @param Horde_Mime_Part $_structure = null if given use structure for parsing
	 * @param boolean $_preserveSeen flag to preserve the seenflag by using body.peek
	 * @param string $_folder folder to work on
	 * @param Horde_Mime_part& $calendar_part =null on return calendar-part or null, if there is none
	 * @param bool $output_no_body true: if we have no "real" body, but a PDF or image, output it to display, false: return empty body
	 * @return array containing the message body, mimeType and charset
	 */
	function getMessageBody($_uid, $_htmlOptions='', $_partID=null, Horde_Mime_Part $_structure=null, $_preserveSeen = false,
	                        $_folder = '', &$calendar_part=null, bool $output_no_body=true)
	{
		if (self::$debug) echo __METHOD__."$_uid, $_htmlOptions, $_partID
";
		if($_htmlOptions != '') {
			$this->htmlOptions = $_htmlOptions;
		}
		if (empty($_folder))
		{
			$_folder = $this->sessionData['mailbox'] ?? null;
		}
		if (empty($this->sessionData['mailbox']) && !empty($_folder))
		{
			$this->sessionData['mailbox'] = $_folder;
		}

		if (!isset($_structure))
		{
			$_structure = $this->getStructure($_uid, $_partID, $_folder, $_preserveSeen);
		}
		if (!is_object($_structure))
		{
			return array(
				array(
					'error'		=> 1,
					'body'		=> 'Error: Could not fetch structure on mail:'.$_uid." as $_htmlOptions". 'for Mailprofile'.$this->icServer->ImapServerId.' User:'.$GLOBALS['egw_info']['user']['account_lid'],
					'mimeType'	=> 'text/plain',
					'charSet'	=> self::$displayCharset,
				)
			);
		}
		if (!empty($_partID))
		{
			$_structure->contentTypeMap();
			$_structure = $_structure->getPart($_partID);
			//_debug_array($_structure->getMimeId()); exit;
		}

		// if message is just a pdf, return it to browser to display
		if ($output_no_body && ($_structure->getType() === 'application/pdf' || $_structure->getPrimaryType() === 'image'))
		{
			header('Content-Type: '.$_structure->getType());
			echo $this->getAttachment($_uid, $_partID ?? '1', 0, true, $_folder)->getContents();
			exit();
		}

		switch($_structure->getPrimaryType())
		{
			case 'application':
				return array(
					array(
						'body'		=> '',
						'mimeType'	=> 'text/plain',
						'charSet'	=> 'iso-8859-1',
					)
				);

			case 'multipart':
				switch($_structure->getSubType())
				{
					case 'alternative':
						$bodyParts = array($this->getMultipartAlternative($_uid, $_structure, $this->htmlOptions, $_preserveSeen, $calendar_part));
						break;

					case 'nil': // multipart with no Alternative
					case 'mixed':
					case 'report':
					case 'signed':
					case 'encrypted':
						$skipParts = array();
						$bodyParts = $this->getMultipartMixed($_uid, $_structure, $this->htmlOptions, $_preserveSeen, $skipParts, $calendar_part);
						break;

					case 'related':
						$bodyParts = $this->getMultipartRelated($_uid, $_structure, $this->htmlOptions, $_preserveSeen, $calendar_part);
						break;
				}
				return self::normalizeBodyParts($bodyParts);

			case 'video':
			case 'audio': // some servers send audiofiles and imagesfiles directly, without any stuff surround it
			case 'image': // they are displayed as Attachment NOT INLINE
				return array(
					array(
						'body'      => '',
						'mimeType'  => $_structure->getSubType(),
					),
				);

			case 'text':
				$bodyPart = array();
				if ($_structure->getDisposition() != 'attachment')
				{
					switch($_structure->getSubType())
					{
						case 'calendar':
							$calendar_part = $_structure;
							// fall through in case user has no calendar rights
						case 'html':
						case 'plain':
						default:
							$bodyPart = array($this->getTextPart($_uid, $_structure, $this->htmlOptions, $_preserveSeen));
					}
				} else {
					// what if the structure->disposition is attachment ,...
				}
				return self::normalizeBodyParts($bodyPart);

			case 'attachment':
			case 'message':
				switch($_structure->getSubType())
				{
					case 'rfc822':
						$newStructure = $_structure->getParts();
						if (self::$debug) {echo __METHOD__." Message -> RFC -> NewStructure:"; _debug_array($newStructure[0]);}
						return self::normalizeBodyParts($this->getMessageBody($_uid, $_htmlOptions, $newStructure[0]->getMimeId(), $newStructure[0], $_preserveSeen, $_folder));
				}
				break;

			default:
				if (self::$debug) _debug_array($_structure);
				return array(
					array(
						'body'		=> lang('The mimeparser can not parse this message.').$_structure->getType(),
						'mimeType'	=> 'text/plain',
						'charSet'	=> self::$displayCharset,
					)
				);
		}
	}

	/**
	 * normalizeBodyParts - function to gather and normalize all body Information
	 * as we may receive a bodyParts structure from within getMessageBody nested deeper than expected
	 * so this is used to normalize the output, so we are able to rely on our expectation
	 * @param _bodyParts - Body Array
	 * @return array - a normalized Bodyarray
	 */
	static function normalizeBodyParts($_bodyParts)
	{
		if (is_array($_bodyParts))
		{
			foreach($_bodyParts as $singleBodyPart)
			{
				if (!isset($singleBodyPart['body'])) {
					$buff = self::normalizeBodyParts($singleBodyPart);
					foreach ((array)$buff as $val) { $body2return[] = $val;}
					continue;
				}
				$body2return[] = $singleBodyPart;
			}
		}
		else
		{
			$body2return = $_bodyParts;
		}
		return $body2return ?? null;
	}

	/**
	 * getdisplayableBody - creates the bodypart of the email as textual representation
	 * @param object $mailClass the mailClass object to be used
	 * @param array $bodyParts  with the bodyparts
	 * @param boolean $preserveHTML  switch to preserve HTML
	 * @param boolean $useTidy  switch to use tidy
	 * @return string a preformatted string with the mails converted to text
	 */
	static function &getdisplayableBody(&$mailClass, $bodyParts, $preserveHTML = false,  $useTidy = true)
	{
		$message='';
		for($i=0, $cnt=count($bodyParts ?? []); $i < $cnt; $i++)
		{
			if (!isset($bodyParts[$i]['body'])) {
				$bodyParts[$i]['body'] = self::getdisplayableBody($mailClass, $bodyParts[$i], $preserveHTML, $useTidy);
				$message .= empty($bodyParts[$i]['body'])?'':$bodyParts[$i]['body'];
				continue;
			}
			if (isset($bodyParts[$i]['error'])) continue;
			if (empty($bodyParts[$i]['body'])) continue;
			// some characterreplacements, as they fail to translate
			$sar = array(
				'@(\x84|\x93|\x94)@',
				'@(\x96|\x97|\x1a)@',
				'@(\x82|\x91|\x92)@',
				'@(\x85)@',
				'@(\x86)@',
				'@(\x99)@',
				'@(\xae)@',
			);
			$rar = array(
				'"',
				'-',
				'\'',
				'...',
				'&',
				'(TM)',
				'(R)',
			);

			if(($bodyParts[$i]['mimeType'] == 'text/html' || $bodyParts[$i]['mimeType'] == 'text/plain') &&
				strtoupper($bodyParts[$i]['charSet']) != 'UTF-8')
			{
				$bodyParts[$i]['body'] = preg_replace($sar,$rar,$bodyParts[$i]['body']);
			}

			if ($bodyParts[$i]['charSet']===false) $bodyParts[$i]['charSet'] = Translation::detect_encoding($bodyParts[$i]['body']);
			// add line breaks to $bodyParts
			//error_log(__METHOD__.' ('.__LINE__.') '.' Charset:'.$bodyParts[$i]['charSet'].'->'.$bodyParts[$i]['body']);
			$newBody  = Translation::convert_jsonsafe($bodyParts[$i]['body'], $bodyParts[$i]['charSet']);
			//error_log(__METHOD__.' ('.__LINE__.') '.' MimeType:'.$bodyParts[$i]['mimeType'].'->'.$newBody);
			$mailClass->activeMimeType = 'text/plain';
			if ($bodyParts[$i]['mimeType'] == 'text/html') {
				$mailClass->activeMimeType = $bodyParts[$i]['mimeType'];
				if (!$preserveHTML)
				{
					$alreadyHtmlLawed=false;
					// as Translation::convert reduces \r\n to \n and purifier eats \n -> peplace it with a single space
					$newBody = str_replace("\n"," ",$newBody);
					// convert HTML to text, as we dont want HTML in infologs
					if ($useTidy && extension_loaded('tidy'))
					{
						$tidy = new tidy();
						$cleaned = $tidy->repairString($newBody, self::$tidy_config,'utf8');
						// Found errors. Strip it all so there's some output
						if($tidy->getStatus() == 2)
						{
							error_log(__METHOD__.' ('.__LINE__.') '.' ->'.$tidy->errorBuffer);
						}
						else
						{
							$newBody = $cleaned;
						}
						if (!$preserveHTML)
						{
							// filter only the 'body', as we only want that part, if we throw away the html
							$matches = array();
							preg_match('`(]*>)(.+?)(.*?)`ims', $newBody, $matches);
							if ($matches[2])
							{
								$hasOther = true;
								$newBody = $matches[2];
							}
						}
					}
					else
					{
						// htmLawed filter only the 'body'
						$matches = array();
						preg_match('`(]*>)(.+?)(.*?)`ims', $newBody, $matches);
						if ($matches[2])
						{
							$hasOther = true;
							$newBody = $matches[2];
						}
						$htmLawed = new Html\HtmLawed();
						// the next line should not be needed, but produces better results on HTML 2 Text conversion,
						// as we switched off HTMLaweds tidy functionality
						$newBody = str_replace(array('&amp;','

',"
 
",'
 
'),array('&','
','
','
'),$newBody);
						$newBody = $htmLawed->run($newBody,self::$htmLawed_config);
						if ($hasOther && $preserveHTML) $newBody = $matches[1]. $newBody. $matches[3];
						$alreadyHtmlLawed=true;
					}
					//error_log(__METHOD__.' ('.__LINE__.') '.' after purify:'.$newBody);
					if ($preserveHTML==false) $newBody = Mail\Html::convertHTMLToText($newBody,self::$displayCharset,true,true);
					//error_log(__METHOD__.' ('.__LINE__.') '.' after convertHTMLToText:'.$newBody);
					if ($preserveHTML==false) $newBody = nl2br($newBody); // we need this, as htmLawed removes \r\n
					/*if (!$alreadyHtmlLawed) */ $mailClass->getCleanHTML($newBody); // remove stuff we regard as unwanted
					if ($preserveHTML==false) $newBody = str_replace("
","\r\n",$newBody);
					//error_log(__METHOD__.' ('.__LINE__.') '.' after getClean:'.$newBody);
				}
				$message .= $newBody;
				continue;
			}
			//error_log(__METHOD__.' ('.__LINE__.') '.' Body(after specialchars):'.$newBody);
			//use Mail\Html::convertHTMLToText instead of strip_tags, (even message is plain text) as strip_tags eats away too much
			//$newBody = strip_tags($newBody); //we need to fix broken tags (or just stuff like "<800 USD/p" )
			$newBody = Mail\Html::convertHTMLToText($newBody,self::$displayCharset,false,false);
			//error_log(__METHOD__.' ('.__LINE__.') '.' Body(after strip tags):'.$newBody);
			$newBody = htmlspecialchars_decode($newBody,ENT_QUOTES);
			//error_log(__METHOD__.' ('.__LINE__.') '.' Body (after hmlspc_decode):'.$newBody);
			$message .= $newBody;
			//continue;
		}
		return $message;
	}

	static function wordwrap($str, $cols, $cut, $dontbreaklinesstartingwith=false)
	{
		$lines = explode("\n", $str);
		$newStr = '';
		foreach($lines as $line)
		{
			// replace tabs by 8 space chars, or any tab only counts one char
			//$line = str_replace("\t","        ",$line);
			//$newStr .= wordwrap($line, $cols, $cut);
			$allowedLength = $cols-strlen($cut);
			//dont try to break lines with links, chance is we mess up the text is way too big
			if (strlen($line) > $allowedLength && stripos($line,'href=')===false &&
				($dontbreaklinesstartingwith==false ||
				 ($dontbreaklinesstartingwith &&
				  strlen($dontbreaklinesstartingwith)>=1 &&
				  substr($line,0,strlen($dontbreaklinesstartingwith)) != $dontbreaklinesstartingwith
				 )
				)
			   )
			{
				$s=explode(" ", $line);
				$line = "";
				$linecnt = 0;
				foreach ($s as &$v) {
					$cnt = strlen($v);
					// only break long words within the wordboundaries,
					// but it may destroy links, so we check for href and dont do it if we find one
					// we check for any html within the word, because we do not want to break html by accident
					if($cnt > $allowedLength && stripos($v,'href=')===false && stripos($v,'onclick=')===false && $cnt == strlen(html_entity_decode($v)))
					{
						$v=wordwrap($v, $allowedLength, $cut, true);
					}
					// the rest should be broken at the start of the new word that exceeds the limit
					if ($linecnt+$cnt > $allowedLength) {
						$v=$cut.$v;
						#$linecnt = 0;
						$linecnt =strlen($v)-strlen($cut);
					} else {
						$linecnt += $cnt;
					}
					if (strlen($v)) $line .= (strlen($line) ? " " : "").$v;
				}
			}
			$newStr .= $line . "\n";
		}
		return $newStr;
	}

	/**
	 * getMessageEnvelope
	 * get parsed headers from message
	 * @param string/int $_uid the messageuid,
	 * @param string/int $_partID = '' , the partID, may be omitted
	 * @param boolean $decode flag to do the decoding on the fly
	 * @param string $_folder folder to work on
	 * @param boolean $_useHeaderInsteadOfEnvelope - force getMessageHeader method to be used for fetching Envelope Information
	 * @return array the message header
	 */
	function getMessageEnvelope($_uid, $_partID = '',$decode=false, $_folder='', $_useHeaderInsteadOfEnvelope=false)
	{
		//error_log(__METHOD__.' ('.__LINE__.') '.":$_uid,$_partID,$decode,$_folder".function_backtrace());
		if (empty($_folder)) $_folder = $this->sessionData['mailbox'] ?? $this->icServer->getCurrentMailbox();
		//error_log(__METHOD__.' ('.__LINE__.') '.":$_uid,$_partID,$decode,$_folder");
		if((empty($_partID)||$_partID=='null')&&$_useHeaderInsteadOfEnvelope===false) {
			$uidsToFetch = new Horde_Imap_Client_Ids();
			if (!(is_object($_uid) || is_array($_uid))) $_uid = (array)$_uid;
			$uidsToFetch->add($_uid);

			$fquery = new Horde_Imap_Client_Fetch_Query();
			$envFields = new Horde_Mime_Headers();
			$fquery->envelope();
			$fquery->size();
			$headersNew = $this->icServer->fetch($_folder, $fquery, array(
				'ids' => $uidsToFetch,
			));
			if (is_object($headersNew)) {
				foreach($headersNew as &$_headerObject) {
					$env = $_headerObject->getEnvelope();
					//_debug_array($envFields->singleFields());
					$singleFields = $envFields->singleFields();
					foreach ($singleFields as &$v)
					{
						switch ($v)
						{
							case 'to':
							case 'reply-to':
							case 'from':
							case 'cc':
							case 'bcc':
							case 'sender':
								//error_log(__METHOD__.' ('.__LINE__.') '.$v.'->'.array2string($env->$v->addresses));
								$envelope[$v]=$env->$v->addresses;
								$address = array();
								if (!is_array($envelope[$v])) break;
								foreach ($envelope[$v] as $k => $ad)
								{
									if (stripos($ad,'@')===false)
									{
										$remember=$k;
									}
									else
									{
										$address[] = (isset($remember)?$envelope[$v][$remember].' ':'').$ad;
										$remember=null;
									}
								}
								$envelope[$v] = $address;
								break;
							case 'date':
								$envelope[$v]=DateTime::to($env->$v);
								break;
							default:
								$envelope[$v]=$env->$v;
						}
					}
					$envelope['size']=$_headerObject->getSize();
				}
			}
			$envelope = array_change_key_case($envelope,CASE_UPPER);
			//if ($decode) _debug_array($envelope);
			//error_log(__METHOD__.' ('.__LINE__.') '.array2string($envelope));
			if ($decode)
			{
				foreach ($envelope as $key => $rvV)
				{
					//try idn conversion only on 'FROM', 'TO', 'CC', 'BCC', 'SENDER', 'REPLY-TO'
					$envelope[$key]=self::decode_header($rvV,in_array($key,array('FROM', 'TO', 'CC', 'BCC', 'SENDER', 'REPLY-TO')));
				}
			}
			return $envelope;
		} else {

			$headers = $this->getMessageHeader($_uid, $_partID, true,true,$_folder);

			//error_log(__METHOD__.' ('.__LINE__.') '.':'.array2string($headers));
			//_debug_array($headers);
			$newData = array(
				'DATE'		=> $headers['DATE'],
				'SUBJECT'	=> ($decode ? self::decode_header($headers['SUBJECT']):$headers['SUBJECT']),
				'MESSAGE_ID'	=> $headers['MESSAGE-ID']
			);
			if (isset($headers['IN-REPLY-TO'])) $newData['IN-REPLY-TO'] = $headers['IN-REPLY-TO'];
			if (isset($headers['REFERENCES'])) $newData['REFERENCES'] = $headers['REFERENCES'];
			if (isset($headers['THREAD-TOPIC'])) $newData['THREAD-TOPIC'] = $headers['THREAD-TOPIC'];
			if (isset($headers['THREAD-INDEX'])) $newData['THREAD-INDEX'] = $headers['THREAD-INDEX'];
			if (isset($headers['LIST-ID'])) $newData['LIST-ID'] = $headers['LIST-ID'];
			if (isset($headers['SIZE'])) $newData['SIZE'] = $headers['SIZE'];
			//_debug_array($newData);
			$recepientList = array('FROM', 'TO', 'CC', 'BCC', 'SENDER', 'REPLY-TO');
			foreach($recepientList as $recepientType) {
				if(isset($headers[$recepientType])) {
					if ($decode) $headers[$recepientType] =  self::decode_header($headers[$recepientType],true);
					//error_log(__METHOD__.__LINE__." ".$recepientType."->".array2string($headers[$recepientType]));
					foreach(self::parseAddressList($headers[$recepientType]) as $singleAddress) {
						$addressData = array(
							'PERSONAL_NAME'		=> $singleAddress->personal ? $singleAddress->personal : 'NIL',
							'AT_DOMAIN_LIST'	=> $singleAddress->adl ? $singleAddress->adl : 'NIL',
							'MAILBOX_NAME'		=> $singleAddress->mailbox ? $singleAddress->mailbox : 'NIL',
							'HOST_NAME'		=> $singleAddress->host ? $singleAddress->host : 'NIL',
							'EMAIL'			=> $singleAddress->host ? $singleAddress->mailbox.'@'.$singleAddress->host : $singleAddress->mailbox,
						);
						if($addressData['PERSONAL_NAME'] != 'NIL') {
							$addressData['RFC822_EMAIL'] = imap_rfc822_write_address($singleAddress->mailbox, $singleAddress->host, $singleAddress->personal);
						} else {
							$addressData['RFC822_EMAIL'] = 'NIL';
						}
						$newData[$recepientType][] = ($addressData['RFC822_EMAIL']!='NIL'?$addressData['RFC822_EMAIL']:$addressData['EMAIL']);//$addressData;
					}
				} else {
					if($recepientType == 'SENDER' || $recepientType == 'REPLY-TO') {
						$newData[$recepientType] = $newData['FROM'];
					} else {
						$newData[$recepientType] = array();
					}
				}
			}
			//if ($decode) _debug_array($newData);
			return $newData;
		}
	}

	/**
	 * Get parsed headers from message
	 *
	 * @param string/int $_uid the messageuid,
	 * @param string/int $_partID ='' , the partID, may be omitted
	 * @param boolean|string $decode flag to do the decoding on the fly or "object"
	 * @param boolean $preserveUnSeen flag to preserve the seen flag where applicable
	 * @param string $_folder folder to work on
	 * @return array|Horde_Mime_Headers message header as array or object
	 */
	function getMessageHeader($_uid, $_partID = '',$decode=false, $preserveUnSeen=false, $_folder='')
	{
		//error_log(__METHOD__.' ('.__LINE__.') '.':'.$_uid.', '.$_partID.', '.$decode.', '.$preserveUnSeen.', '.$_folder);
		if (empty($_folder)) $_folder = $this->sessionData['mailbox'] ?? $this->icServer->getCurrentMailbox();
		$uidsToFetch = new Horde_Imap_Client_Ids();
		if (!(is_object($_uid) || is_array($_uid))) $_uid = (array)$_uid;
		$uidsToFetch->add($_uid);

		$fquery = new Horde_Imap_Client_Fetch_Query();
		if ($_partID != '')
		{
			$fquery->headerText(array('id'=>$_partID,'peek'=>$preserveUnSeen));
			$fquery->structure();
		}
		else
		{
			$fquery->headerText(array('peek'=>$preserveUnSeen));
			$fquery->structure();
		}
		$fquery->size();

		$headersNew = $this->icServer->fetch($_folder, $fquery, array(
			'ids' => $uidsToFetch,
		));
		if (is_object($headersNew)) {
			foreach($headersNew as $_fetchObject)
			{
				$headers = $_fetchObject->getHeaderText(0,Horde_Imap_Client_Data_Fetch::HEADER_PARSE);
				$mailStructureObject = $_fetchObject->getStructure();
				if ($_partID != '')
				{
					foreach ($mailStructureObject->contentTypeMap() as $mime_id => $mime_type)
					{
						if ($mime_id==$_partID)
						{
							//error_log(__METHOD__.' ('.__LINE__.') '."$mime_id == $_partID".array2string($_headerObject->getHeaderText($mime_id,Horde_Imap_Client_Data_Fetch::HEADER_PARSE)->toArray()));
							$headers = $_fetchObject->getHeaderText($mime_id,Horde_Imap_Client_Data_Fetch::HEADER_PARSE);
							break;
						}
					}
				}
				$size = $_fetchObject->getSize();
				//error_log(__METHOD__.__LINE__.'#'.$size);
			}
			if ($decode === 'object')
			{
				if (is_object($headers)) $headers->setUserAgent('EGroupware API '.$GLOBALS['egw_info']['server']['versions']['phpgwapi']);
				return $headers;
			}
			$retValue = is_object($headers) ? $headers->toArray():array();
			if ($size) $retValue['size'] = $size;
			$retValue['smimeType']		= Mail\Smime::getSmimeType($mailStructureObject);
		}
		$retValue = array_change_key_case($retValue,CASE_UPPER);
		//error_log(__METHOD__.' ('.__LINE__.') '.array2string($retValue));
		// if SUBJECT is an array, use thelast one, as we assume something with the unfolding for the subject did not work
		if (is_array($retValue['SUBJECT']))
		{
			$retValue['SUBJECT'] = $retValue['SUBJECT'][count($retValue['SUBJECT'])-1];
		}
		//error_log(__METHOD__.' ('.__LINE__.') '.':'.array2string($decode ? self::decode_header($retValue,true):$retValue));
		if ($decode)
		{
			foreach ($retValue as $key => $rvV)
			{
				//try idn conversion only on 'FROM', 'TO', 'CC', 'BCC', 'SENDER', 'REPLY-TO'
				$retValue[$key]=self::decode_header($rvV,in_array($key,array('FROM', 'TO', 'CC', 'BCC', 'SENDER', 'REPLY-TO')));
			}
		}
		return $retValue;
	}

	/**
	 * getMessageRawHeader
	 * get messages raw header data
	 * @param string/int $_uid the messageuid,
	 * @param string/int $_partID = '' , the partID, may be omitted
	 * @param string $_folder folder to work on
	 * @return string the message header
	 */
	function getMessageRawHeader($_uid, $_partID = '', $_folder = '')
	{
		static $rawHeaders;
		if (empty($_folder)) $_folder = $this->sessionData['mailbox'] ?? $this->icServer->getCurrentMailbox();
		//error_log(__METHOD__.' ('.__LINE__.') '." Try Using Cache for raw Header $_uid, $_partID in Folder $_folder");

		if (!isset($rawHeaders)||!is_array($rawHeaders)) $rawHeaders = Cache::getCache(Cache::INSTANCE,'email','rawHeadersCache'.trim($GLOBALS['egw_info']['user']['account_id']),null,array(),60*60*1);
		if (isset($rawHeaders[$this->icServer->ImapServerId][(string)$_folder][$_uid][(empty($_partID)?'NIL':$_partID)]))
		{
			//error_log(__METHOD__.' ('.__LINE__.') '." Using Cache for raw Header $_uid, $_partID in Folder $_folder");
			return $rawHeaders[$this->icServer->ImapServerId][(string)$_folder][$_uid][(empty($_partID)?'NIL':$_partID)];
		}
		$uidsToFetch = new Horde_Imap_Client_Ids();
		$uid = $_uid;
		if (!(is_object($_uid) || is_array($_uid))) $uid = (array)$_uid;
		$uidsToFetch->add($uid);

		$fquery = new Horde_Imap_Client_Fetch_Query();
		if ($_partID != '')
		{
			$fquery->headerText(array('id'=>$_partID,'peek'=>true));
			$fquery->structure();
		}
		else
		{
			$fquery->headerText(array('peek'=>true));
		}
		$headersNew = $this->icServer->fetch($_folder, $fquery, array(
			'ids' => $uidsToFetch,
		));
		if (is_object($headersNew)) {
			foreach($headersNew as &$_headerObject) {
				$retValue = $_headerObject->getHeaderText();
				if ($_partID != '')
				{
					$mailStructureObject = $_headerObject->getStructure();
					foreach ($mailStructureObject->contentTypeMap() as $mime_id => $mime_type)
					{
						if ($mime_id==$_partID)
						{
							$retValue = $_headerObject->getHeaderText($mime_id);
						}
					}
				}
			}
		}
		$rawHeaders[$this->icServer->ImapServerId][(string)$_folder][$_uid][(empty($_partID)?'NIL':$_partID)]=$retValue;
		Cache::setCache(Cache::INSTANCE,'email','rawHeadersCache'.trim($GLOBALS['egw_info']['user']['account_id']),$rawHeaders,60*60*1);
		return $retValue;
	}

	/**
	 * getStyles - extracts the styles from the given bodyparts
	 * @param array $_bodyParts  with the bodyparts
	 * @return string a preformatted string with the mails converted to text
	 */
	static function &getStyles($_bodyParts)
	{
		$style = $ret = '';
		if (empty($_bodyParts)) return $ret;
		foreach((array)$_bodyParts as $singleBodyPart) {
			if (!isset($singleBodyPart['body'])) {
				$singleBodyPart['body'] = self::getStyles($singleBodyPart);
				$style .= $singleBodyPart['body'];
				continue;
			}

			if (empty($singleBodyPart['charSet'])) $singleBodyPart['charSet'] = Translation::detect_encoding($singleBodyPart['body']);
			$singleBodyPart['body'] = Translation::convert(
				$singleBodyPart['body'],
				strtolower($singleBodyPart['charSet'])
			);
			$ct = 0;
			$newStyle=array();
			if (stripos($singleBodyPart['body'],'(.+)#isU', $singleBodyPart['body'], $newStyle);
			if ($ct>0)
			{
				//error_log(__METHOD__.' ('.__LINE__.') '.'#'.$ct.'#'.array2string($newStyle));
				$style2buffer = implode('',$newStyle[0]);
			}
			if (!empty($style2buffer) && strtoupper(self::$displayCharset) == 'UTF-8')
			{
				//error_log(__METHOD__.' ('.__LINE__.') '.array2string($style2buffer));
				$test = json_encode($style2buffer);
				//error_log(__METHOD__.' ('.__LINE__.') '.'#'.$test.'# ->'.strlen($style2buffer).' Error:'.json_last_error());
				//if (json_last_error() != JSON_ERROR_NONE && strlen($style2buffer)>0)
				if ($test=="null" && strlen($style2buffer)>0)
				{
					// this should not be needed, unless something fails with charset detection/ wrong charset passed
					error_log(__METHOD__.' ('.__LINE__.') '.' Found Invalid sequence for utf-8 in CSS:'.$style2buffer.' Charset Reported:'.$singleBodyPart['charSet'].' Carset Detected:'.Translation::detect_encoding($style2buffer));
					$style2buffer = utf8_encode($style2buffer);
				}
			}
			$style .= $style2buffer ?? '';
		}
		// clean out comments and stuff
		$search = array(
			'@url\(http:\/\/[^\)].*?\)@si',  // url calls e.g. in style definitions
//			'@@',   // Strip multi-line comments including CDATA
//			'@ in stylesheet are outdated, and ck-editor does not understand it, we remove it
		$css = str_replace(array(':',''),array(': ','',''),$css);
		//error_log(__METHOD__.' ('.__LINE__.') '.$css);

		// check if the outlook style fix is there then set the initial line-height, since the fix is setting it to line-height:0
		// which breaks all tr lines in the content.
		if (preg_match('/Outlook 2016 Height Fix/i', $css)) $css .='';

		// TODO: we may have to strip urls and maybe comments and ifs
		return $css;
	}

	/**
	 * getMessageRawBody
	 * get the message raw body
	 * @param string/int $_uid the messageuid,
	 * @param string/int $_partID = '' , the partID, may be omitted
	 * @param string $_folder folder to work on
	 * @param boolean $_stream =false true: return a stream, false: return string, stream suppresses any caching
	 * @return ?string the message body or null if $_uid or $_partID not found
	 */
	function getMessageRawBody($_uid, $_partID = '', $_folder='', $_stream=false)
	{
		static $rawBody;
		$body = null;
		if (empty($_folder)) $_folder = $this->sessionData['mailbox']?? $this->icServer->getCurrentMailbox();
		$_uid = !(is_object($_uid) || is_array($_uid)) ? (array)$_uid : $_uid;

		if (!$_stream && isset($rawBody[$this->icServer->ImapServerId][(string)$_folder][$_uid[0]][(empty($_partID)?'NIL':$_partID)]))
		{
			//error_log(__METHOD__.' ('.__LINE__.') '." Using Cache for raw Body $_uid, $_partID in Folder $_folder");
			return $rawBody[$this->icServer->ImapServerId][(string)$_folder][$_uid[0]][(empty($_partID)?'NIL':$_partID)];
		}

		$uidsToFetch = new Horde_Imap_Client_Ids();

		$uidsToFetch->add($_uid);

		$fquery = new Horde_Imap_Client_Fetch_Query();
		$fquery->fullText(array('peek'=>true));
		if ($_partID != '')
		{
			$fquery->structure();
			$fquery->bodyPart($_partID,array('peek'=>true));
		}
		$headersNew = $this->icServer->fetch($_folder, $fquery, array(
			'ids' => $uidsToFetch,
		));
		if (is_object($headersNew)) {
			foreach($headersNew as &$_headerObject) {
				$body = $_headerObject->getFullMsg($_stream);
				if ($_partID != '')
				{
					$mailStructureObject = $_headerObject->getStructure();
					foreach ($mailStructureObject->contentTypeMap() as $mime_id => $mime_type)
					{
						if ($mime_id==$_partID)
						{
							$body = $_headerObject->getBodyPart($mime_id, $_stream);
						}
					}
				}
			}
		}

		if (!$_stream)
		{
			//error_log(__METHOD__.' ('.__LINE__.') '."[{$this->icServer->ImapServerId}][$_folder][$_uid][".(empty($_partID)?'NIL':$_partID)."]");
			$rawBody[$this->icServer->ImapServerId][(string)$_folder][$_uid[0]][(empty($_partID)?'NIL':$_partID)] = $body;
		}
		return $body;
	}

	/**
	 * Get structure of a mail or part of a mail
	 *
	 * @param int $_uid
	 * @param string $_partID = null
	 * @param string $_folder = null
	 * @param boolean $_preserveSeen = false flag to preserve the seenflag by using body.peek
	 * @param Horde_Imap_Client_Fetch_Query $fquery=null default query just structure
	 * @return Horde_Mime_Part
	 */
	function getStructure($_uid, $_partID=null, $_folder=null, $_preserveSeen=false)
	{
		if (self::$debug) error_log( __METHOD__.' ('.__LINE__.') '.":$_uid, $_partID");

		if (empty($_folder))
		{
			$_folder = $this->sessionData['mailbox'] ?? $this->icServer->getCurrentMailbox();
		}
		$uidsToFetch = new Horde_Imap_Client_Ids();

		$uidsToFetch->add($_uid);

		try
		{
			$_fquery = new Horde_Imap_Client_Fetch_Query();
	// not sure why Klaus add these, seem not necessary
	//		$fquery->envelope();
	//		$fquery->size();
			$_fquery->structure();
			if ($_partID) $_fquery->bodyPart($_partID, array('peek' => $_preserveSeen));

			$mail = $this->icServer->fetch($_folder, $_fquery, array(
				'ids' => $uidsToFetch,
			))->first();
			if (is_object($mail))
			{
				$structure = $mail->getStructure();
				$isSmime = Mail\Smime::isSmime(($mimeType = $structure->getType())) || Mail\Smime::isSmime(($protocol=$structure->getContentTypeParameter('protocol')));
				if ($isSmime && !class_exists('mail_zpush', false))
				{
					return $this->resolveSmimeMessage($structure, array(
						'uid' => $_uid,
						'mailbox' => $_folder,
						'mimeType' => Mail\Smime::isSmime($protocol) ? $protocol: $mimeType
					));
				}
				return $mail->getStructure();
			}
			else
			{
				return null;
			}
		}
		catch (Mail\Smime\PassphraseMissing $e)
		{
			// re-throw the exception to be caught on UI
			throw $e;
		}
		catch (Exception $e)
		{
			error_log(__METHOD__.' ('.__LINE__.') '.' Could not fetch structure on mail:'.$_uid.' Serverprofile->'.$this->icServer->ImapServerId.' Message:'.$e->getMessage().' Stack:'.function_backtrace());
			return null;
		}
	}

	/**
	 * Parse the structure for attachments
	 *
	 * Returns not the attachments itself, but an array of information about the attachment
	 *
	 * @param int $_uid the messageuid,
	 * @param string $_partID = null , the partID, may be omitted
	 * @param Horde_Mime_Part $_structure = null if given use structure for parsing
	 * @param boolean $fetchEmbeddedImages = true,
	 * @param boolean $fetchTextCalendar = false,
	 * @param boolean $resolveTNEF = true
	 * @param string $_folder folder to work on
	 * @return array  an array of information about the attachment: array of array(name, size, mimeType, partID, encoding)
	 */
	function getMessageAttachments($_uid, $_partID=null, Horde_Mime_Part $_structure=null, $fetchEmbeddedImages=true, $fetchTextCalendar=false, $resolveTNEF=true, $_folder='')
	{
		if (self::$debug) error_log( __METHOD__.":$_uid, $_partID");
		if (empty($_folder)) $_folder = $this->sessionData['mailbox'] ?? $this->icServer->getCurrentMailbox();
		$attachments = array();
		if (!isset($_structure))
		{
			$_structure = $this->getStructure($_uid, $_partID,$_folder,true);
			//error_log(__METHOD__.' ('.__LINE__.') '.':'.print_r($_structure->contentTypeMap(),true));
		}
		if (!$_structure || !$_structure->contentTypeMap()) return array();
		if (!empty($_partID)) $_structure = $_structure->getPart($_partID);
		$skipParts = array();
		$tnefParts = array();
		$skip = 0;
		foreach($_structure->contentTypeMap() as $mime_id => $mime_type)
		{
			// skip multipart/encrypted incl. its two sub-parts, as we show 2. sub-part as body to be decrypted client-side
			if ($mime_type == 'multipart/encrypted')
			{
				$skip = 2;
				continue;
			}
			elseif($skip)
			{
				$skip--;
				continue;
			}
			$part = $_structure->getPart($mime_id);
			//error_log(__METHOD__.' ('.__LINE__.') '.':'.' Uid:'.$uid.' Part:'.$_partID.'->'.array2string($part->getMimeId()));
			//error_log(__METHOD__.' ('.__LINE__.') '.':'.' Uid:'.$uid.' Part:'.$_partID.'->'.$part->getPrimaryType().'/'.$part->getSubType().'->'.$part->getDisposition());
			//error_log(__METHOD__.' ('.__LINE__.') '.':'.' Uid:'.$uid.' Part:'.$_partID.'->'.array2string($part->getAllDispositionParameters()));
			//error_log(__METHOD__.' ('.__LINE__.') '.':'.' Uid:'.$uid.' Part:'.$_partID.'->'.array2string($part->getAllContentTypeParameters()));
			$partDisposition = $part->getDisposition();
			$partPrimaryType = $part->getPrimaryType();
			// we only want to retrieve the attachments of the current mail, not those of possible
			// attached mails
			if ($mime_type=='message/rfc822' && $_partID!=$mime_id)
			{
				//error_log(__METHOD__.' ('.__LINE__.') '.' Uid:'.$uid.'->'.$mime_id.':'.array2string($part->contentTypeMap()));
				foreach($part->contentTypeMap() as $sub_id => $sub_type) {if ($sub_id != $mime_id) $skipParts[$sub_id] = $sub_type;}
			}
			if (empty($partDisposition) && $partPrimaryType != 'multipart' && $partPrimaryType != 'text')
			{
				// the absence of an partDisposition does not necessarily indicate there is no attachment. it may be an
				// attachment with no link to show the attachment inline.
				// Considering this: we "list" everything that matches the above criteria
				// as attachment in order to not loose/miss information on our data
				$partDisposition='attachment';
			}
			//error_log(__METHOD__.' ('.__LINE__.') '.' Uid:'.$uid.' Part:'.$_partID.'->'.$mime_id.':'.array2string($skipParts));
			if (array_key_exists($mime_id,$skipParts)) continue;

			if ($partDisposition == 'attachment' ||
				(($partDisposition == 'inline' || empty($partDisposition)) && $partPrimaryType == 'image' && $part->getContentId()=='') ||
				(($partDisposition == 'inline' || empty($partDisposition)) && $partPrimaryType != 'image' && $partPrimaryType != 'text' && $partPrimaryType != 'multipart') ||
				($mime_type=='image/tiff') || //always fetch. even if $fetchEmbeddedImages is false. as we cannot display tiffs
				($fetchEmbeddedImages && ($partDisposition == 'inline' || empty($partDisposition)) && $partPrimaryType == 'image') ||
				($fetchTextCalendar && $partPrimaryType == 'text' && $part->getSubType() == 'calendar'))
			{
				// if type is message/rfc822 and _partID is given, and MimeID equals partID
				// we attempt to fetch "ourselves"
				if ($_partID==$part->getMimeId() && $part->getPrimaryType()=='message') continue;
				$attachment = $part->getAllDispositionParameters();
				$attachment['disposition'] = $part->getDisposition();
				$attachment['mimeType'] = $mime_type;
				$attachment['uid'] = $_uid;
				$attachment['partID'] = $mime_id;
				if (!isset($attachment['name'])||empty($attachment['name'])) $attachment['name'] = $part->getName() ? $part->getName() : ($mime_type == "message/rfc822" ? lang('forwarded message') : lang('attachment'));;
				if ($fetchTextCalendar)
				{
					//error_log(__METHOD__.' ('.__LINE__.') '.array2string($part->getAllContentTypeParameters()));
					$method = $part->getContentTypeParameter('method');
					if ($method) $attachment['method'] = $method;
					if (!isset($attachment['name'])) $attachment['name'] = 'event.ics';
				}
				$attachment['size'] = $part->getBytes();
				if (($cid = $part->getContentId())) $attachment['cid'] = $cid;
				if (empty($attachment['name'])) $attachment['name'] = (isset($attachment['cid'])&&!empty($attachment['cid'])?$attachment['cid']:lang("unknown").'_Uid'.$_uid.'_Part'.$mime_id).'.'.MimeMagic::mime2ext($mime_type);
				//error_log(__METHOD__.' ('.__LINE__.') '.' Uid:'.$uid.' Part:'.$_partID.'->'.$mime_id.':'.array2string($attachment));
				//typical winmail.dat attachment is
				//Array([size] => 1462762[filename] => winmail.dat[mimeType] => application/ms-tnef[uid] => 100[partID] => 2[name] => winmail.dat)
				if ($resolveTNEF && ($attachment['mimeType']=='application/ms-tnef' || !strcasecmp($attachment['name'],'winmail.dat')))
				{
					$tnefParts[] = $attachment;
				}
				else
				{
					$attachments[] = $attachment;
				}
			}
		}
		if ($resolveTNEF && !empty($tnefParts))
		{
			//error_log(__METHOD__.__LINE__.array2string($tnefParts));
			foreach ($tnefParts as $k => $tnp)
			{
				$tnefResolved=false;
				$tnef_data = $this->getAttachment($tnp['uid'],$tnp['partID'],$k,false);
				$myTnef = $this->tnef_decoder($tnef_data['attachment']);
				//error_log(__METHOD__.__LINE__.array2string($myTnef->getParts()));
				// Note: MimeId starts with 0, almost always, we cannot use that as winmail_id
				// we need to build Something that meets the needs
				if ($myTnef)
				{
					foreach($myTnef->getParts() as $mime_id => $part)
					{
						$tnefResolved=true;
						$attachment = $part->getAllDispositionParameters();
						$attachment['disposition'] = $part->getDisposition();
						$attachment['mimeType'] = $part->getType();
						$attachment['uid'] = $tnp['uid'];
						$attachment['partID'] = $tnp['partID'];
						$attachment['is_winmail'] = $tnp['uid'].'@'.$tnp['partID'].'@'.$mime_id;
						if (!isset($attachment['name'])||empty($attachment['name'])) $attachment['name'] = $part->getName();
						$attachment['size'] = $part->getBytes();
						if (($cid = $part->getContentId())) $attachment['cid'] = $cid;
						if (empty($attachment['name'])) $attachment['name'] = (isset($attachment['cid'])&&!empty($attachment['cid'])?$attachment['cid']:lang("unknown").'_Uid'.$_uid.'_Part'.$mime_id).'.'.MimeMagic::mime2ext($attachment['mimeType']);
						$attachments[] = $attachment;
					}
				}
				if ($tnefResolved===false) $attachments[]=$tnp;
			}
		}
		//error_log(__METHOD__.__LINE__.array2string($attachments));
		return $attachments;
	}

	/**
	 * Decode TNEF type attachment into Multipart/mixed attachment
	 *
	 * @param MIME object $data Mime part object
	 *
	 * @return boolean|Horde_Mime_part Multipart/Mixed part decoded attachments |
	 *	return false if there's no attachments or failure
	 */
	public function tnef_decoder( $data )
	{
		foreach(array('Horde_Compress', 'Horde_Icalendar', 'Horde_Mapi') as $class)
		{
			if (!class_exists($class))
			{
				error_log(__METHOD__."() missing required PEAR package $class --> aborting");
				return false;
			}
		}
		$parts_obj = new Horde_Mime_part;
		$parts_obj->setType('multipart/mixed');

		$tnef_object = Horde_Compress::factory('tnef');
		try
		{
			$tnef_data = $tnef_object->decompress($data);
		}
		catch (Horde_Exception $ex)
		{
			error_log(__METHOD__."() ".$ex->getMessage().' --> aborting');
			_egw_log_exception($ex);
			return false;
		}
		if (is_array($tnef_data))
		{
			foreach ($tnef_data as &$data)
			{
				$tmp_part = new Horde_Mime_part;

				$tmp_part->setName($data['name']);
				$tmp_part->setContents($data['stream']);
				$tmp_part->setDescription($data['name']);

				$type = $data['type'] . '/' . $data['subtype'];
				if (in_array($type, array('application/octet-stream', 'application/base64')))
				{
					$type = Horde_Mime_Magic::filenameToMIME($data['name']);
				}
				$tmp_part->setType($type);
				//error_log(__METHOD__.__LINE__.array2string($tmp_part));
				$parts_obj->addPart($tmp_part);
			}
			$parts_obj->buildMimeIds();
			return $parts_obj;
		}
		return false;
	}

	/**
	 * Get attachment data as string, to be used with Link::(get|set)_data()
	 *
	 * @param int $acc_id
	 * @param string $_mailbox
	 * @param int $_uid
	 * @param string $_partID
	 * @param int $_winmail_nr
	 * @return resource stream with attachment content
	 */
	public static function getAttachmentAccount($acc_id, $_mailbox, $_uid, $_partID, $_winmail_nr)
	{
		$bo = self::getInstance(false, $acc_id);

		$attachment = $bo->getAttachment($_uid, $_partID, $_winmail_nr, false, true, $_mailbox);

		return $attachment['attachment'];
	}

	/**
	 * Retrieve tnef attachments
	 *
	 * @param int $_uid the uid of the message
	 * @param string $_partID the id of the part, which holds the attachment
	 * @param boolean $_stream =false flag to indicate if the attachment is to be fetched or returned as filepointer
	 * @param string $_folder =null folder to use if not current folder
	 *
	 * @return array returns an array of all resolved embeded attachments from winmail.dat
	 */
	function getTnefAttachments ($_uid, $_partID, $_stream=false, $_folder=null)
	{
		$tnef_data = $this->getAttachment($_uid, $_partID,0,false, false , $_folder);
		$tnef_parts = $this->tnef_decoder($tnef_data['attachment']);
		$attachments = array();
		if ($tnef_parts)
		{
			foreach($tnef_parts->getParts() as $mime_id => $part)
			{

				$attachment = $part->getAllDispositionParameters();
				$attachment['mimeType'] = $part->getType();
				if (!isset($attachment['filename'])||empty($attachment['filename'])) $attachment['filename'] = $part->getName();
				if (($cid = $part->getContentId())) $attachment['cid'] = $cid;
				if (empty($attachment['filename']))
				{
					$attachment['filename'] = (isset($attachment['cid'])&&!empty($attachment['cid'])?
						$attachment['cid']:lang("unknown").'_Uid'.$_uid.'_Part'.$mime_id).'.'.MimeMagic::mime2ext($attachment['mimeType']);
				}

				$attachment['attachment'] = $part->getContents(array('stream'=>$_stream));

				$attachments[$_uid.'@'.$_partID.'@'.$mime_id] = $attachment;
			}
		}
		if (!is_array($attachments)) return false;
		return $attachments;
	}

	/**
	 * Retrieve a attachment
	 *
	 * @param int $_uid the uid of the message
	 * @param string $_partID the id of the part, which holds the attachment
	 * @param int $_winmail_nr = 0 winmail.dat attachment nr.
	 * @param boolean $_returnPart =true flag to indicate if the attachment is to be returned as horde mime part object
	 * @param boolean $_stream =false flag to indicate if the attachment is to be fetched or returned as filepointer
	 * @param string $_folder =null folder to use if not current folder
	 *
	 * @return array
	 */
	function getAttachment($_uid, $_partID, $_winmail_nr=0, $_returnPart=true, $_stream=false, $_folder=null)
	{
		//error_log(__METHOD__.__LINE__."Uid:$_uid, PartId:$_partID, WinMailNr:$_winmail_nr, ReturnPart:$_returnPart, Stream:$_stream, Folder:$_folder".function_backtrace());
		if (!isset($_folder)) $_folder = $this->sessionData['mailbox'] ?? $this->icServer->getCurrentMailbox();

		$uidsToFetch = new Horde_Imap_Client_Ids();
		if (!(is_object($_uid) || is_array($_uid))) $_uid = (array)$_uid;
		$uidsToFetch->add($_uid);

		$fquery = new Horde_Imap_Client_Fetch_Query();
		$fquery->structure();
		$fquery->bodyPart($_partID, array('peek'=>true));
		$headersNew = $this->icServer->fetch($_folder, $fquery, array(
			'ids' => $uidsToFetch,
		));
		if (is_object($headersNew)) {
			foreach($headersNew as $id=>$_headerObject) {
				$body = $_headerObject->getFullMsg();
				if ($_partID != '')
				{
					$mailStructureObject = $_headerObject->getStructure();
					if (!class_exists('mail_zpush', false) && (Mail\Smime::isSmime(($mimeType = $mailStructureObject->getType())) ||
							Mail\Smime::isSmime(($protocol=$mailStructureObject->getContentTypeParameter('protocol')))))
					{
						$mailStructureObject = $this->resolveSmimeMessage($mailStructureObject, array(
							'uid' => $_uid,
							'mailbox' => $_folder,
							'mimeType' => Mail\Smime::isSmime($protocol) ? $protocol : $mimeType

						));
					}
					$mailStructureObject->contentTypeMap();
					$part = $mailStructureObject->getPart($_partID);
					$partDisposition = ($part?$part->getDisposition():'failed');
					if ($partDisposition=='failed')
					{
						error_log(__METHOD__.'('.__LINE__.'):'.array2string($_uid).','.$_partID.' ID:'.$id.' HObject:'.array2string($_headerObject).' StructureObject:'.array2string($mailStructureObject->contentTypeMap()).'->'.function_backtrace());
					}
					// if $partDisposition is empty, we assume attachment, and hope that the function
					// itself is only triggered to fetch attachments
					if (empty($partDisposition)) $partDisposition='attachment';
					if ($part && ($partDisposition=='attachment' || $partDisposition=='inline' || ($part->getPrimaryType() == 'text' && $part->getSubType() == 'calendar')))
					{
						//$headerObject=$part->getAllDispositionParameters();//not used anywhere around here
						$structure_mime = $part->getType();
						$filename = $part->getName();
						$charset = $part->getContentTypeParameter('charset');
						//$structure_bytes = $part->getBytes(); $structure_partID=$part->getMimeId(); error_log(__METHOD__.__LINE__." fetchPartContents(".array2string($_uid).", $structure_partID, $_stream, $_preserveSeen,$structure_mime)" );
						if (empty($part->getContents())) $this->fetchPartContents($_uid, $part, $_stream, $_preserveSeen=true,$structure_mime);
						if ($_returnPart) return $part;
					}
				}
			}
		}
		$ext = MimeMagic::mime2ext($structure_mime);
		if ($ext && stripos($filename,'.')===false && stripos($filename,$ext)===false) $filename = trim($filename).'.'.$ext;
		if (!$part)
		{
			throw new Exception\WrongParameter("Error: Could not fetch attachment for Uid=".array2string($_uid).", PartId=$_partID, WinMailNr=$_winmail_nr, folder=$_folder");
		}
		$attachmentData = array(
			'type'		=> $structure_mime,
			'charset' => $charset,
			'filename'	=> $filename,
			'attachment'	=> $part->getContents(array(
				// tnef_decode needs strings not a stream
				'stream' => $_stream && !($filename == 'winmail.dat' && $_winmail_nr)
			)),
		);

		// try guessing the mimetype, if we get the application/octet-stream
		if (strtolower($attachmentData['type']) == 'application/octet-stream') $attachmentData['type'] = MimeMagic::filename2mime($attachmentData['filename']);
		# if the attachment holds a winmail number and is a winmail.dat then we have to handle that.
		if ( $filename == 'winmail.dat' && $_winmail_nr)
		{
			//by now _uid is of type array
			$tnefResolved=false;
			$wantedPart=$_uid[0].'@'.$_partID;
			$myTnef = $this->tnef_decoder($attachmentData['attachment']);
			//error_log(__METHOD__.__LINE__.array2string($myTnef->getParts()));
			// Note: MimeId starts with 0, almost always, we cannot use that as winmail_id
			// we need to build Something that meets the needs
			if ($myTnef)
			{
				foreach($myTnef->getParts() as $mime_id => $part)
				{
					$tnefResolved=true;
					$attachment = $part->getAllDispositionParameters();
					$attachment['mimeType'] = $part->getType();
					//error_log(__METHOD__.__LINE__.'#'.$mime_id.'#'.$filename.'#'.array2string($attachment));
					//error_log(__METHOD__.__LINE__." $_winmail_nr == $wantedPart@$mime_id");
					if ($_winmail_nr == $wantedPart.'@'.$mime_id)
					{
						//error_log(__METHOD__.__LINE__.'#'.$structure_mime.'#'.$filename.'#'.array2string($attachment));
						if (!isset($attachment['filename'])||empty($attachment['filename'])) $attachment['filename'] = $part->getName();
						if (($cid = $part->getContentId())) $attachment['cid'] = $cid;
						if (empty($attachment['filename'])) $attachment['filename'] = (isset($attachment['cid'])&&!empty($attachment['cid'])?$attachment['cid']:lang("unknown").'_Uid'.$_uid.'_Part'.$mime_id).'.'.MimeMagic::mime2ext($attachment['mimeType']);
						$wmattach = $attachment;
						$wmattach['attachment'] = $part->getContents(array('stream'=>$_stream));

					}
				}
			}
			if ($tnefResolved)
			{
				$ext = MimeMagic::mime2ext($wmattach['mimeType']);
				if ($ext && stripos($wmattach['filename'],'.')===false && stripos($wmattach['filename'],$ext)===false) $wmattach['filename'] = trim($wmattach['filename']).'.'.$ext;
				$attachmentData = array(
					'type'       => $wmattach['mimeType'],
					'filename'   => $wmattach['filename'],
					'attachment' => $wmattach['attachment'],
				);
			}
		}
		return $attachmentData;
	}

	/**
	 * Fetch a specific attachment from a message by it's cid
	 *
	 * this function is based on a on "Building A PHP-Based Mail Client"
	 * http://www.devshed.com
	 *
	 * @param string|int $_uid
	 * @param string $_cid
	 * @param string $_part
	 * @param boolean $_stream = null null do NOT fetch content, use fetchPartContents later
	 *	true:
	 * @return Horde_Mime_Part|false false on error / not found
	 */
	function getAttachmentByCID($_uid, $_cid, $_part, $_stream=null)
	{
		// some static variables to avoid fetching the same mail multiple times
		static $uid=null, $part=null, $structure=null;
		//error_log(__METHOD__.' ('.__LINE__.') '.":$_uid, $_cid, $_part");

		if(empty($_cid)) return false;

		if ($_uid != $uid || $_part != $part)
		{
			$structure = $this->getStructure($uid=$_uid, $part=$_part);
		}
		if (!$structure) return false;

		/** @var Horde_Mime_Part */
		$attachment = null;
		foreach($structure->contentTypeMap() as $mime_id => $mime_type)
		{
			$part = $structure->getPart($mime_id);

			if ($part->getPrimaryType() == 'image' &&
				(($cid = $part->getContentId()) &&
				// RB: seem a bit fague to search for inclusion in both ways
				(strpos($cid, $_cid) !== false || strpos($_cid, $cid) !== false)) ||
				(($name = $part->getName()) &&
				(strpos($name, $_cid) !== false || strpos($_cid, $name) !== false)))
			{
				// if we have a direct match, dont search any further
				if ($cid == $_cid)
				{
					$attachment = $part;
				}
				// everything else we only consider after we checked all
				if (!isset($attachment)) $attachment = $part;
				// do we want content fetched, can be done later, if not needed
				if (isset($_stream) && empty($structure->getMetadata('X-EGroupware-Smime')))
				{
					$this->fetchPartContents($_uid, $attachment, $_stream);
				}
				if (isset($attachment)) break;
			}
		}
		// set name as filename, if not set
		if ($attachment && !$attachment->getDispositionParameter('filename'))
		{
			$attachment->setDispositionParameter('filename', $attachment->getName());
		}
		// guess type, if not set
		if ($attachment && $attachment->getType() == 'application/octet-stream')
		{
			$attachment->setType(MimeMagic::filename2mime($attachment->getDispositionParameter('filename')));
		}
		//error_log(__METHOD__."($_uid, '$_cid', '$_part') returning ".array2string($attachment));
		return $attachment;
	}

	/**
	 * Check if part is binary e.g. a PDF or an image and claims not to be transfer-encoded --> fix it
	 *
	 * This works under the assumption, that no one really sends binary data unencoded through mail!
	 * Therefore, we assume it must be already base64 encoded, just the header was forgotten.
	 *
	 * This violates the mime-rfc, which states explicit that no Content-Transfer-Encoding header means "binary"!
	 * Horde_Mime_Part does NOT allow to check if we have no Content-Transfer-Type header, or it has the value "binary".
	 *
	 * Another approach would be to check the data-stream, if it is really base64 encoded or not ...
	 *
	 * Some broken clients e.g. SAP Netweaver sends mails containing only a base64 decoded PDF, but set NO Content-Transfer-Type: base64.
	 *
	 * @param Horde_Mime_Part $part
	 * @return bool true: part needed fixing AND is base64 encoded, false: no need to fix the part
	 */
	public static function fixBinaryPart(Horde_Mime_Part $part)
	{
		// if we have no text body, but only a PDF or an image AND transfer-encoding is NOT base64,
		// set binary, as it's already base64 transfer-encoded but lacks the necessary header
		if (($part->getType() === 'application/pdf' || $part->getPrimaryType() === 'image') &&
			// hack to read protected $structure->_transfer_encoding
			!in_array(unserialize($part->serialize())[9],  ['base64', 'quoted-printable']))
		{
			$part->setTransferEncoding('binary', ['send' => true]);
			return true;
		}
		return false;
	}

	/**
	 * Fetch and add contents to a part
	 *
	 * To get contents you use $part->getContents();
	 *
	 * @param int $_uid
	 * @param Horde_Mime_Part $part
	 * @param boolean $_stream = false true return a stream, false a string
	 * @param boolean $_preserveSeen flag to preserve the seenflag by using body.peek
	 * @param string  $_mimetype to decide wether to try to fetch part as binary or not
	 * @return Horde_Mime_Part
	 */
	public function fetchPartContents($_uid, Horde_Mime_Part $part=null, $_stream=false, $_preserveSeen=false, $_mimetype=null)
	{
		if (!isset($part)) return null;//new Horde_Mime_Part;
		$encoding = null;
		$fetchAsBinary = true;
		if ($_mimetype && strtolower($_mimetype)=='message/rfc822') $fetchAsBinary = false;

		$need_base64 = self::fixBinaryPart($part);

		// we need to set content on structure to decode transfer encoding
		$part->setContents(
			$this->getBodyPart($_uid, $part->getMimeId(), null, $_preserveSeen, $_stream, $encoding, $fetchAsBinary),
				array('encoding' => $need_base64 ? 'base64' : (!$fetchAsBinary&&!$encoding?'8bit':$encoding)));

		return $part;
	}

	/**
	 * save a message in folder
	 *	throws exception on failure
	 * @todo set flags again
	 *
	 * @param string _folderName the foldername
	 * @param string|resource _header header part of message or resource with hole message
	 * @param string _body body part of message, only used if _header is NO resource
	 * @param string _flags = '\\Recent'the imap flags to set for the saved message
	 *
	 * @return int id of the message appended or exception
	 * @throws Exception\WrongUserinput
	 */
	function appendMessage($_folderName, $_header, $_body, $_flags='\\Recent')
	{
		if (!is_resource($_header))
		{
			if (stripos($_header,'message-id:')===false)
			{
				$_header = 'Message-ID: <'.self::getRandomString().'@localhost>'."\n".$_header;
			}
			//error_log(__METHOD__.' ('.__LINE__.') '."$_folderName, $_header, $_body, $_flags");
			$_header = ltrim(str_replace("\n","\r\n",$_header));
			$_header .= str_replace("\n","\r\n",$_body);
		}
		// the recent flag is the default enforced here ; as we assume the _flags is always set,
		// we default it to hordes default (Recent) (, other wise we should not pass the parameter
		// for flags at all)
		if (empty($_flags)) $_flags = '\\Recent';
		//if (!is_array($_flags) && stripos($_flags,',')!==false) $_flags=explode(',',$_flags);
		//if (!is_array($_flags)) $_flags = (array) $_flags;
		try
		{
			$dataNflags = array();
			// both methods below are valid for appending a message to a mailbox.
			// the commented version fails in retrieving the uid of the created message if the server
			// is not returning the uid upon creation, as the method in append for detecting the uid
			// expects data to be a string. this string is parsed for message-id, and the mailbox
			// searched for the message-id then returning the uid found
			//$dataNflags[] = array('data'=>array(array('t'=>'text','v'=>"$header"."$body")), 'flags'=>array($_flags));
			$dataNflags[] = array('data' => $_header, 'flags'=>array($_flags));
			$messageid = $this->icServer->append($_folderName,$dataNflags);
		}
		catch (\Exception $e)
		{
			if (self::$debug) error_log("Could not append Message: ".$e->getMessage());
			throw new Exception\WrongUserinput(lang("Could not append Message:").' '.$e->getMessage().': '.$e->details);
			//return false;
		}
		//error_log(__METHOD__.' ('.__LINE__.') '.' appended UID:'.$messageid);
		//$messageid = true; // for debug reasons only
		if ($messageid === true || empty($messageid)) // try to figure out the message uid
		{
			$list = $this->getHeaders($_folderName, $_startMessage=1, 1, 'INTERNALDATE', true, array(),null, false);
			if ($list)
			{
				if (self::$debug) error_log(__METHOD__.' ('.__LINE__.') '.' MessageUid:'.$messageid.' but found:'.array2string($list));
				$messageid = $list['header'][0]['uid'];
			}
		}
		return $messageid;
	}

	/**
	 * Get a random string of 32 chars
	 *
	 * @return string
	 */
	static function getRandomString()
	{
		return Auth::randomstring(32);
	}

	/**
	 * functions to allow access to mails through other apps to fetch content
	 * used in infolog, tracker
	 */

	/**
	 * get_mailcontent - fetches the actual mailcontent, and returns it as well defined array
	 * @param object mailClass the mailClassobject to be used
	 * @param uid the uid of the email to be processed
	 * @param partid the partid of the email
	 * @param mailbox the mailbox, that holds the message
	 * @param preserveHTML flag to pass through to getdisplayableBody, null for both text and HTML
	 * @param addHeaderSection flag to be able to supress headersection
	 * @param includeAttachments flag to be able to supress possible attachments
	 * @return array/bool with 'mailaddress'=>$mailaddress,
	 *				'subject'=>$subject,
	 *				'message'=>$message,
	 *				'attachments'=>$attachments,
	 *				'headers'=>$headers,; boolean false on failure
	 */
	static function get_mailcontent(&$mailClass,$uid,$partid='',$mailbox='', $preserveHTML = false, $addHeaderSection=true, $includeAttachments=true)
	{
			//echo __METHOD__." called for $uid,$partid 
";
			$headers = $mailClass->getMessageHeader($uid,$partid,true,false,$mailbox);
			if (empty($headers)) return false;
			// dont force retrieval of the textpart, let mailClass preferences decide
			$bodyParts = $mailClass->getMessageBody($uid,($preserveHTML?'always_display':'only_if_no_text'),$partid,null,false,$mailbox);
			if(!isset($preserveHTML))
			{
				$html = static::getdisplayablebody(
						$mailClass,
						$mailClass->getMessageBody($uid,'always_display',$partid,null,false,$mailbox),
						true
				);

			}
			// if we do not want HTML but there is no TextRepresentation with the message itself, try converting
			if ( !$preserveHTML && $bodyParts[0]['mimeType']=='text/html')
			{
				foreach($bodyParts as $i => $part)
				{
					if ($bodyParts[$i]['mimeType']=='text/html')
					{
						$bodyParts[$i]['body'] = Mail\Html::convertHTMLToText($bodyParts[$i]['body'],$bodyParts[$i]['charSet'],true,$stripalltags=true);
						$bodyParts[$i]['mimeType']='text/plain';
					}
				}
			}
			//error_log(array2string($bodyParts));
			$attachments = $includeAttachments?$mailClass->getMessageAttachments($uid,$partid,null,true,false,true,$mailbox):array();

			if ($mailClass->isSentFolder($mailbox)) $mailaddress = $headers['TO'];
			elseif (isset($headers['FROM'])) $mailaddress = $headers['FROM'];
			elseif (isset($headers['SENDER'])) $mailaddress = $headers['SENDER'];
			if (isset($headers['CC'])) $mailaddress .= ','.$headers['CC'];
			//_debug_array(array($headers,$mailaddress));
			$subject = $headers['SUBJECT'];

			$message = self::getdisplayableBody($mailClass, $bodyParts, $preserveHTML);
			if ($preserveHTML && $mailClass->activeMimeType == 'text/plain') $message = '
'.$message.'
';
			$headdata = ($addHeaderSection ? self::createHeaderInfoSection($headers, '',$preserveHTML) : '');
			$message = $headdata.$message;
			//echo __METHOD__.'
';
			//_debug_array($attachments);
			if (is_array($attachments))
			{
				// For dealing with multiple files of the same name
				$dupe_count = $file_list = array();

				foreach ($attachments as $num => $attachment)
				{
					if ($attachment['mimeType'] == 'MESSAGE/RFC822')
					{
						//_debug_array($mailClass->getMessageHeader($uid, $attachment['partID']));
						//_debug_array($mailClass->getMessageBody($uid,'', $attachment['partID']));
						//_debug_array($mailClass->getMessageAttachments($uid, $attachment['partID']));
						$mailcontent = self::get_mailcontent($mailClass,$uid,$attachment['partID'],$mailbox);
						$headdata ='';
						if ($mailcontent['headers'])
						{
							$headdata = self::createHeaderInfoSection($mailcontent['headers'],'',$preserveHTML);
						}
						if ($mailcontent['message'])
						{
							$tempname =tempnam($GLOBALS['egw_info']['server']['temp_dir'],$GLOBALS['egw_info']['flags']['currentapp']."_");
							$attachedMessages[] = array(
								'type' => 'TEXT/PLAIN',
								'name' => $mailcontent['subject'].'.txt',
								'tmp_name' => $tempname,
							);
							$tmpfile = fopen($tempname,'w');
							fwrite($tmpfile,$headdata.$mailcontent['message']);
							fclose($tmpfile);
						}
						foreach($mailcontent['attachments'] as &$tmpval)
						{
							$attachedMessages[] = $tmpval;
						}
						unset($attachments[$num]);
					}
					else
					{
						$attachments[$num] = array_merge($attachments[$num],$mailClass->getAttachment($uid, $attachment['partID'],0,false,false));

						if (empty($attachments[$num]['attachment'])&&$attachments[$num]['cid'])
						{
							$c = $mailClass->getAttachmentByCID($uid, $attachment['cid'], $attachment['partID'],true);
							$attachments[$num]['attachment'] = $c->getContents();
						}
						// no attempt to convert, if we dont know about the charset
						if (isset($attachments[$num]['charset'])&&!empty($attachments[$num]['charset'])) {
							// we do not try guessing the charset, if it is not set
							//if ($attachments[$num]['charset']===false) $attachments[$num]['charset'] = Translation::detect_encoding($attachments[$num]['attachment']);
							Translation::convert($attachments[$num]['attachment'],$attachments[$num]['charset']);
						}
						if(in_array($attachments[$num]['name'], $file_list))
						{
							$dupe_count[$attachments[$num]['name']]++;
							$attachments[$num]['name'] = pathinfo($attachments[$num]['name'], PATHINFO_FILENAME) .
								' ('.($dupe_count[$attachments[$num]['name']] + 1).')' . '.' .
								pathinfo($attachments[$num]['name'], PATHINFO_EXTENSION);
						}
						$attachments[$num]['type'] = $attachments[$num]['mimeType'];
						$attachments[$num]['tmp_name'] = tempnam($GLOBALS['egw_info']['server']['temp_dir'],$GLOBALS['egw_info']['flags']['currentapp']."_");
						$tmpfile = fopen($attachments[$num]['tmp_name'],'w');
						fwrite($tmpfile,$attachments[$num]['attachment']);
						fclose($tmpfile);
						$file_list[] = $attachments[$num]['name'];
						unset($attachments[$num]['attachment']);
					}
				}
				if (is_array($attachedMessages)) $attachments = array_merge($attachments,$attachedMessages);
			}
			$return = array(
					'mailaddress'=>$mailaddress,
					'subject'=>$subject,
					'message'=>$message,
					'attachments'=>$attachments,
					'headers'=>$headers,
			);
			if($html)
			{
				$return['html_message'] = $html;
			}

			return $return;
	}

	/**
	 * getStandardIdentityForProfile
	 * get either the first identity out of the given identities or the one matching the profile_id
	 * @param object/array $_identities identity iterator object or array with identities from Mail\Account
	 * @param integer $_profile_id the acc_id/profileID the identity with the matching key is the standard one
	 * @return array the identity
	 */
	static function getStandardIdentityForProfile($_identities, $_profile_id)
	{
		$c = 0;
		// use the standardIdentity
		foreach($_identities as $key => $acc) {
			if ($c==0) $identity = $acc;
			//error_log(__METHOD__.__LINE__." $key == $_profile_id ");
			if ($key==$_profile_id) $identity = $acc;
			$c++;
		}
		return $identity;
	}
	/**
	 * createHeaderInfoSection - creates a textual headersection from headerobject
	 * @param array header headerarray may contain SUBJECT,FROM,SENDER,TO,CC,BCC,DATE,PRIORITY,IMPORTANCE
	 * @param string headline Text tom use for headline, if SUPPRESS, supress headline and footerline
	 * @param bool createHTML do it with HTML breaks
	 * @return string a preformatted string with the information of the header worked into it
	 */
	static function createHeaderInfoSection($header,$headline='', $createHTML = false)
	{
		$headdata = null;
		//error_log(__METHOD__.' ('.__LINE__.') '.array2string($header).function_backtrace());
		if ($header['SUBJECT']) $headdata = lang('subject').': '.$header['SUBJECT'].($createHTML?"
":"\n");
		if ($header['FROM']) $headdata .= lang('from').': '.self::convertAddressArrayToString($header['FROM'], $createHTML).($createHTML?"
":"\n");
		if ($header['SENDER']) $headdata .= lang('sender').': '.self::convertAddressArrayToString($header['SENDER'], $createHTML).($createHTML?"
":"\n");
		if ($header['TO']) $headdata .= lang('to').': '.self::convertAddressArrayToString($header['TO'], $createHTML).($createHTML?"
":"\n");
		if ($header['CC']) $headdata .= lang('cc').': '.self::convertAddressArrayToString($header['CC'], $createHTML).($createHTML?"
":"\n");
		if ($header['BCC']) $headdata .= lang('bcc').': '.self::convertAddressArrayToString($header['BCC'], $createHTML).($createHTML?"
":"\n");
		if ($header['DATE']) $headdata .= lang('date').': '.$header['DATE'].($createHTML?"
":"\n");
		if ($header['PRIORITY'] && $header['PRIORITY'] != 'normal') $headdata .= lang('priority').': '.$header['PRIORITY'].($createHTML?"
":"\n");
		if ($header['IMPORTANCE'] && $header['IMPORTANCE'] !='normal') $headdata .= lang('importance').': '.$header['IMPORTANCE'].($createHTML?"
":"\n");
		//if ($mailcontent['headers']['ORGANIZATION']) $headdata .= lang('organization').': '.$mailcontent['headers']['ORGANIZATION']."\
		if (!empty($headdata))
		{
			if (!empty($headline) && $headline != 'SUPPRESS') $headdata = "---------------------------- $headline ----------------------------".($createHTML?"
":"\n").$headdata;
			if (empty($headline)) $headdata = ($headline != 'SUPPRESS'?"--------------------------------------------------------".($createHTML?"
":"\n"):'').$headdata;
			$headdata .= ($headline != 'SUPPRESS'?"--------------------------------------------------------".($createHTML?"
":"\n"):'');
		}
		else
		{
			$headdata = ($headline != 'SUPPRESS'?"--------------------------------------------------------".($createHTML?"
":"\n"):'');
		}
		return $headdata;
	}

	/**
	 * Make the provided filename safe to store in the VFS
	 *
	 * Some characters found in subjects that cause problems if we try to put
	 * them as filenames (Windows) so we remove any characters that might result
	 * in additional directories, or issues on Windows.
	 *
	 * Under Windows the characters < > ? " : | \ / * are not allowed.
	 * % causes problems with VFS UI
	 *
	 * 4-byte unicode is also unwanted, as our current MySQL collation can store it
	 *
	 * We also dont want empty filenames, using lang('empty') instead.
	 *
	 * @param string $filename
	 * @return Cleaned filename, with problematic characters replaced with ' '.
	 */
	static function clean_subject_for_filename($filename)
	{
		static $filter_pattern = '$[\f\n\t\x0b\:*#?<>%"\|/\x{10000}-\x{10FFFF}\\\\]$u';
		$file = substr(trim(preg_replace($filter_pattern, ' ', $filename)), 0, 200);
		if (empty($file)) $file = lang('empty');
		return $file;
	}

	/**
	 * adaptSubjectForImport - strips subject from unwanted Characters, and does some normalization
	 * to meet expectations
	 * @param string $subject string to process
	 * @return string
	 */
	static function adaptSubjectForImport($subject)
	{
		$subject = str_replace('$$','__',($subject?$subject:lang('(no subject)')));
		$subject = str_ireplace(array('[FWD]','[',']','{','}','<','>'),array('Fwd:',' ',' ',' ',' ',' ',' '),trim($subject));
		return $subject;
	}

	/**
	 * convertAddressArrayToString - converts an mail envelope Address Array To String
	 * @param array $rfcAddressArray  an addressarray as provided by mail retieved via egw_pear....
	 * @return string a comma separated string with the mailaddress(es) converted to text
	 */
	static function convertAddressArrayToString($rfcAddressArray)
	{
		//error_log(__METHOD__.' ('.__LINE__.') '.array2string($rfcAddressArray));
		$returnAddr ='';
		if (is_array($rfcAddressArray))
		{
			foreach((array)$rfcAddressArray as $addressData) {
				//error_log(__METHOD__.' ('.__LINE__.') '.array2string($addressData));
				if($addressData['MAILBOX_NAME'] == 'NIL') {
					continue;
				}
				if(strtolower($addressData['MAILBOX_NAME']) == 'undisclosed-recipients') {
					continue;
				}
				if ($addressData['RFC822_EMAIL'])
				{
					$addressObjectA = self::parseAddressList($addressData['RFC822_EMAIL']);
				}
				else
				{
					$emailaddress = ($addressData['PERSONAL_NAME']?$addressData['PERSONAL_NAME'].' <'.$addressData['EMAIL'].'>':$addressData['EMAIL']);
					$addressObjectA = self::parseAddressList($emailaddress);
				}
				$addressObject = $addressObjectA[0];
				//error_log(__METHOD__.' ('.__LINE__.') '.array2string($addressObject));
				if (!$addressObject->valid) continue;
				//$mb =(string)$addressObject->mailbox;
				//$h = (string)$addressObject->host;
				//$p = (string)$addressObject->personal;
				$returnAddr .= (strlen($returnAddr)>0?',':'');
				//error_log(__METHOD__.' ('.__LINE__.') '.$p.' <'.$mb.'@'.$h.'>');
				try {
					$buff = imap_rfc822_write_address($addressObject->mailbox, Horde_Idna::decode($addressObject->host), $addressObject->personal);
				}
				// if Idna conversation fails, leave address unchanged
				catch (\Exception $e) {
					unset($e);
					$buff = imap_rfc822_write_address($addressObject->mailbox, $addressObject->host, $addressObject->personal);
				}
				$returnAddr .= str_replace(array('<','>','"\'','\'"'),array('[',']','"','"'),$buff);
				//error_log(__METHOD__.' ('.__LINE__.') '.' Address: '.$returnAddr);
			}
		}
		else
		{
			// do not mess with strings, return them untouched /* ToDo: validate string as Address */
			$rfcAddressArray = self::decode_header($rfcAddressArray,true);
			$rfcAddressArray = str_replace(array('<','>','"\'','\'"'),array('[',']','"','"'),$rfcAddressArray);
			if (is_string($rfcAddressArray)) return $rfcAddressArray;
		}
		return $returnAddr;
	}

	/**
	 * Merges a given content with contact data
	 *
	 * @param string $content
	 * @param array $ids array with contact id(s)
	 * @param string &$err error-message on error
	 * @return string/boolean merged content or false on error
	 */
	static function merge($content,$ids,$mimetype='')
	{
		$mergeobj = new Contacts\Merge();

		if (empty($mimetype)) $mimetype = (strlen(strip_tags($content)) == strlen($content) ?'text/plain':'text/html');
		$err = '';
		$rv = $mergeobj->merge_string($content,$ids,$err, $mimetype, array(), self::$displayCharset);
		if (empty($rv) && !empty($content) && !empty($err)) $rv = $content;
		if (!empty($err) && !empty($content) && !empty($ids)) error_log(__METHOD__.' ('.__LINE__.') '.' Merge failed for Ids:'.array2string($ids).' ContentType:'.$mimetype.' Content:'.$content.' Reason:'.array2string($err));
		return $rv;
	}

	/**
	 * Returns a string showing the size of the message/attachment
	 *
	 * @param integer $bytes
	 * @return string formatted string
	 */
	static function show_readable_size($bytes)
	{
		$bytes /= 1024;
		$type = 'k';

		if ($bytes / 1024 > 1)
		{
			$bytes /= 1024;
			$type = 'M';

			if ($bytes / 1024 > 1)
			{
				$bytes *= 10;
				settype($bytes, 'integer');
				$bytes /= 10;
				$bytes /= 1024;
				$type = 'G';
			}

		}

		if ($bytes < 10)
		{
			$bytes *= 10;
			settype($bytes, 'integer');
			$bytes /= 10;
		}
		else
			settype($bytes, 'integer');

		return $bytes . ' ' . $type ;
	}

	static function detect_qp($string)
	{
		return preg_match('/(=[0-9][A-F])|(=[A-F][0-9])|(=[A-F][A-F])|(=[0-9][0-9])[\s|=]/', $string);
	}

	/**
	 * logRunTimes
	 *	logs to the error log all parameters given; output only if self::$debugTimes is true
	 *
	 * @param int $_starttime starttime of the action measured based on microtime(true)
	 * @param int $_endtime endtime of the action measured, if not given microtime(true) is used
	 * @param string $_message message to output details or params, whatever seems neccesary
	 * @param string $_methodNline - Information where the log was taken
	 * @return void
	 */
	static function logRunTimes($_starttime,$_endtime=null,$_message='',$_methodNline='')
	{
		if (!isset($_endtime)) $_endtime = microtime(true);
		$usagetime = microtime(true) - $_starttime;
		if (self::$debugTimes) error_log($_methodNline.' took:'.number_format($usagetime,5).'(s) '.($_message?'Details:'.$_message:''));
	}

	/**
	 * check if formdata meets basic restrictions (in tmp dir, or vfs, mimetype, etc.)
	 *
	 * @param array $_formData passed by reference Array with information of name, type, file and size, mimetype may be adapted
	 * @param string $IDtoAddToFileName id to enrich the returned tmpfilename
	 * @param string $reqMimeType /(default message/rfc822, if set to false, mimetype check will not be performed
	 * @return mixed $fullPathtoFile or exception
	 *
	 * @throws Exception\WrongUserinput
	 */
	static function checkFileBasics(&$_formData, $IDtoAddToFileName='', $reqMimeType='message/rfc822')
	{
		if (parse_url($_formData['file'],PHP_URL_SCHEME) == 'egw-data') return $_formData['file'];

		//error_log(__METHOD__.__FILE__.array2string($_formData).' Id:'.$IDtoAddToFileName.' ReqMimeType:'.$reqMimeType);
		$importfailed = $tmpFileName = false;
		// ignore empty files, but allow to share vfs directories (which can have 0 size)
		if ($_formData['size'] == 0 && parse_url($_formData['file'], PHP_URL_SCHEME) != 'vfs' && is_dir($_formData['file']))
		{
			$importfailed = true;
			$alert_msg = lang("Empty file %1 ignored.", $_formData['name']);
		}
		elseif (parse_url($_formData['file'],PHP_URL_SCHEME) == 'vfs' || is_uploaded_file($_formData['file']) ||
			realpath(dirname($_formData['file'])) == realpath($GLOBALS['egw_info']['server']['temp_dir']))
		{
			// ensure existance of eGW temp dir
			// note: this is different from apache temp dir,
			// and different from any other temp file location set in php.ini
			if (!file_exists($GLOBALS['egw_info']['server']['temp_dir']))
			{
				@mkdir($GLOBALS['egw_info']['server']['temp_dir'],0700);
			}

			// if we were NOT able to create this temp directory, then make an ERROR report
			if (!file_exists($GLOBALS['egw_info']['server']['temp_dir']))
			{
				$alert_msg = 'Error:'.'
'
					.'Server is unable to access EGroupware tmp directory'.'
'
					.$GLOBALS['egw_info']['server']['temp_dir'].'
'
					.'Please check your configuration'.'
'
					.'
';
			}

			// sometimes PHP is very clue-less about MIME types, and gives NO file_type
			// rfc default for unknown MIME type is:
			if ($reqMimeType == 'message/rfc822')
			{
				$mime_type_default = 'message/rfc';
			}
			else
			{
				$mime_type_default = $reqMimeType;
			}
			// check the mimetype by extension. as browsers seem to report crap
			// maybe its application/octet-stream -> this may mean that we could not determine the type
			// so we check for the suffix too
			// trust vfs mime-types, trust the mimetype if it contains a method
			if ((substr($_formData['file'],0,6) !== 'vfs://' || $_formData['type'] == 'application/octet-stream') && stripos($_formData['type'],'method=')===false)
			{
				$buff = explode('.',$_formData['name']);
				$suffix = '';
				if (is_array($buff)) $suffix = array_pop($buff); // take the last extension to check with ext2mime
				if (!empty($suffix)) $sfxMimeType = MimeMagic::ext2mime($suffix);
				if (!empty($suffix) && !empty($sfxMimeType) &&
					(strlen(trim($_formData['type']))==0 || (strtolower(trim($_formData['type'])) != $sfxMimeType)))
				{
					error_log(__METHOD__.' ('.__LINE__.') '.' Data:'.array2string($_formData));
					error_log(__METHOD__.' ('.__LINE__.') '.' Form reported Mimetype:'.$_formData['type'].' but seems to be:'.$sfxMimeType);
					$_formData['type'] = $sfxMimeType;
				}
			}
			if (trim($_formData['type']) == '')
			{
				$_formData['type'] = 'application/octet-stream';
			}
			// if reqMimeType is set to false do not test for that
			if ($reqMimeType)
			{
				// so if PHP did not pass any file_type info, then substitute the rfc default value
				if (substr(strtolower(trim($_formData['type'])),0,strlen($mime_type_default)) != $mime_type_default)
				{
					if (!(strtolower(trim($_formData['type'])) == "application/octet-stream" && $sfxMimeType == $reqMimeType))
					{
						//error_log("Message rejected, no message/rfc. Is:".$_formData['type']);
						$importfailed = true;
						$alert_msg .= lang("File rejected, no %2. Is:%1",$_formData['type'],$reqMimeType);
					}
					if ((strtolower(trim($_formData['type'])) != $reqMimeType && $sfxMimeType == $reqMimeType))
					{
						$_formData['type'] = MimeMagic::ext2mime($suffix);
					}
				}
			}
			// as FreeBSD seems to have problems with the generated temp names we append some more random stuff
			$randomString = chr(rand(65,90)).chr(rand(48,57)).chr(rand(65,90)).chr(rand(48,57)).chr(rand(65,90));
			$tmpFileName = $GLOBALS['egw_info']['user']['account_id'].
				trim($IDtoAddToFileName).basename($_formData['file']).'_'.$randomString;

			if (parse_url($_formData['file'],PHP_URL_SCHEME) == 'vfs')
			{
				$tmpFileName = $_formData['file'];	// no need to store it somewhere
			}
			elseif (is_uploaded_file($_formData['file']))
			{
				move_uploaded_file($_formData['file'], $GLOBALS['egw_info']['server']['temp_dir'].'/'.$tmpFileName);	// requirement for safe_mode!
			}
			else
			{
				rename($_formData['file'], $GLOBALS['egw_info']['server']['temp_dir'].'/'.$tmpFileName);
			}
		} else {
			//error_log("Import of message ".$_formData['file']." failes to meet basic restrictions");
			$importfailed = true;
			$alert_msg = lang("Processing of file %1 failed. Failed to meet basic restrictions.",$_formData['name']);
		}
		if ($importfailed == true)
		{
			throw new Exception\WrongUserinput($alert_msg);
		}
		else
		{
			if (parse_url($tmpFileName,PHP_URL_SCHEME) == 'vfs')
			{
				Vfs::load_wrapper('vfs');
			}
			return $tmpFileName;
		}
	}

	/**
	 * Parses a html text for images, and adds them as inline attachment
	 *
	 * Images can be data-urls, own VFS webdav.php urls or absolute path.
	 *
	 * @param Mailer $_mailObject instance of the Mailer Object to be used
	 * @param string $_html2parse the html to parse and to be altered, if conditions meet
	 * @param $mail_bo mail bo object
	 * @return array|null return inline images stored as tmp file in vfs as array of attachments otherwise null
	 */
	static function processURL2InlineImages(Mailer $_mailObject, &$_html2parse, $mail_bo)
	{
		//error_log(__METHOD__."()");
		$imageC = 0;
		$images = null;
		$attachments = null;

		if (preg_match_all("/(src|background)=\"(.*)\"/Ui", $_html2parse, $images) && isset($images[2]))
		{
			foreach($images[2] as $i => $url)
			{
				//$isData = false;
				$basedir = $data = '';
				$needTempFile = true;
				$attachmentData = ['name' => '', 'type' => '', 'file' => '', 'tmp_name' => ''];
				try
				{
					// do not change urls for absolute images (thanks to corvuscorax)
					if (!str_starts_with($url, 'data:'))
					{
						$attachmentData['name'] = basename($url); // need to resolve all sort of url
						if (($directory = dirname($url)) == '.') $directory = '';
						$ext = pathinfo($attachmentData['name'], PATHINFO_EXTENSION);
						$attachmentData['type'] = MimeMagic::ext2mime($ext);
						if ( strlen($directory) > 1 && !str_ends_with($directory, '/')) { $directory .= '/'; }

						//decode entities because tinymce encodes (e.g. Umlautes) them otherwise file can't be found.
						$myUrl = html_entity_decode($directory.$attachmentData['name']);

						if ($myUrl[0]=='/') // local path -> we only allow path's that are available via http/https (or vfs)
						{
							$basedir = Framework::getUrl('/');
						}
						// use vfs instead of url containing webdav.php
						// ToDo: we should test if the webdav url is of our own scope, as we cannot handle foreign
						// webdav.php urls as vfs
						if (str_contains($myUrl, '/webdav.php')) // we have a webdav link, so we build a vfs/sqlfs link of it.
						{
							Vfs::load_wrapper('vfs');
							list(,$myUrl) = explode('/webdav.php',$myUrl,2);
							$basedir = 'vfs://default';
							$needTempFile = false;
						}

						// If it is an inline image url, we need to fetch the actuall attachment
						// content and later on to be able to store its content as temp file
						if ($mail_bo && str_contains($myUrl, '/index.php?menuaction=mail.mail_ui.displayImage'))
						{
							$URI_params = array();
							// Strips the url and store it into a temp for further procss
							$tmp_url = html_entity_decode($myUrl);

							parse_str(parse_url($tmp_url, PHP_URL_QUERY),$URI_params);
							if ($URI_params['mailbox'] && $URI_params['uid'] && $URI_params['cid'])
							{
								$mail_bo->reopen(base64_decode($URI_params['mailbox']));
								$attachment = $mail_bo->getAttachmentByCID(base64_decode($URI_params['uid']), base64_decode($URI_params['cid']),base64_decode($URI_params['partID']),true);
								$mail_bo->closeConnection();
								if ($attachment)
								{
									$data = $attachment->getContents();
									$attachmentData['type'] = $attachment->getType();
									$attachmentData['name'] = $attachment->getDispositionParameter('filename');
								}
							}
						}

						if ( $myUrl[0]!='/' && strlen($basedir) > 1 && !str_ends_with($basedir, '/')) { $basedir .= '/'; }
						if ($needTempFile && empty($attachment) && !str_starts_with($myUrl, "http")) $data = file_get_contents($basedir.urldecode($myUrl));
					}
					if (str_starts_with($url, 'data:'))
					{
						//error_log(__METHOD__.' ('.__LINE__.') '.' -> '.$i.': '.array2string($images[$i]));
						// we only support base64 encoded data
						$tmp = substr($url,strlen('data:'));
						list($attachmentData['type'],$data_base64) = explode(';base64,',$tmp);
						$data = base64_decode($data_base64);
						// FF currently does NOT add any mime-type
						if (strtolower(substr($attachmentData['type'], 0, 6)) != 'image/')
						{
							$attachmentData['type'] = MimeMagic::analyze_data($data);
						}
						list($what,$exactly) = explode('/',$attachmentData['type']);
						$needTempFile = true;
						$attachmentData['name'] = ($what ?: 'data').$imageC++.'.'.$exactly;
					}
					if ($data || $needTempFile === false)
					{
						if ($needTempFile)
						{
							$attachmentData['file'] =tempnam($GLOBALS['egw_info']['server']['temp_dir'],$GLOBALS['egw_info']['flags']['currentapp']."_");
							$tmpfile = fopen($attachmentData['file'],'w');
							fwrite($tmpfile,$data);
							fclose($tmpfile);
						}
						else
						{
							$attachmentData['file'] = $basedir.urldecode($myUrl);
						}
						// we use $attachmentData['file'] as base for cid instead of filename, as it may be image.png
						// (or similar) in all cases (when cut&paste). This may lead to more attached files, in case
						// we use the same image multiple times, but, if we do this, we should try to detect that
						// on upload. filename itself is not sufficient to determine the sameness of images
						$cid = 'cid:' . md5($attachmentData['file']);
						if ($_mailObject->AddEmbeddedImage($attachmentData['file'], substr($cid, 4), urldecode($attachmentData['file']), $attachmentData['type']) !== null)
						{
							//$_html2parse = preg_replace("/".$images[1][$i]."=\"".preg_quote($url, '/')."\"/Ui", $images[1][$i]."=\"".$cid."\"", $_html2parse);
							$_html2parse = str_replace($images[0][$i], $images[1][$i].'="'.$cid.'"', $_html2parse);
						}
					}
				}
				catch(\Exception $e)
				{
					// Something went wrong with this attachment.  Skip it.
					error_log("Error adding inline attachment.  " . $e->getMessage());
					error_log($e->getTraceAsString());
				}
				$attachmentData['tmp_name'] = $attachmentData['file'];
				$attachments [] = $attachmentData;
			}
			return is_array($attachments) ? $attachments : null;
		}
	}

	/**
	 * importMessageToMergeAndSend
	 *
	 * @param Storage\Merge Storage\Merge bo_merge object
	 * @param string $document the full filename
	 * @param array $SendAndMergeTocontacts array of contact ids
	 * @param string&|false $_folder (passed by reference) will set the folder used. must be set with a folder, but will hold modifications if
	 *					folder is modified.  Set to false to not keep the message.
	 * @param string& $importID ID for the imported message, used by attachments to identify them unambiguously
	 * @param string[] $attachments Files attached to the email - the same files for every email
	 * @return mixed array of messages with success and failed messages or exception
	 */
	function importMessageToMergeAndSend(Storage\Merge $bo_merge, $document, $SendAndMergeTocontacts, &$_folder, &$importID = '', $attachments = [])
	{
		$importfailed = false;
		$processStats = array('success'=>array(),'failed'=>array());
		if (empty($SendAndMergeTocontacts))
		{
			$importfailed = true;
			$alert_msg = lang("Import of message %1 failed. No Contacts to merge and send to specified.", '');
		}

		// check if formdata meets basic restrictions (in tmp dir, or vfs, mimetype, etc.)
		/* as the file is provided by Storage\Merge, we do not check
		try
		{
			$tmpFileName = Mail::checkFileBasics($_formData,$importID);
		}
		catch (\Exception\WrongUserinput $e)
		{
			$importfailed = true;
			$alert_msg .= $e->getMessage();
		}
		*/
		$tmpFileName = $document;
		// -----------------------------------------------------------------------
		if ($importfailed === false)
		{
			$mailObject = new Mailer($this->profileID);
			try
			{
				$this->parseFileIntoMailObject($mailObject, $tmpFileName);
			}
			catch (Exception\AssertionFailed $e)
			{
				$importfailed = true;
				$alert_msg .= $e->getMessage();
			}

			//_debug_array($Body);
			$this->openConnection();
			if (empty($_folder) && $_folder !== FALSE)
			{
				$_folder = $this->getSentFolder();
			}
			$delimiter = $this->getHierarchyDelimiter();
			if($_folder=='INBOX'.$delimiter) $_folder='INBOX';
			if ($importfailed === false)
			{
				$Subject = $mailObject->getHeader('Subject');
				//error_log(__METHOD__.' ('.__LINE__.') '.' Subject:'.$Subject);
				$Body = ($text_body = $mailObject->findBody('plain')) ? $text_body->getContents() : null;
				//error_log(__METHOD__.' ('.__LINE__.') '.' Body:'.$Body);
				//error_log(__METHOD__.' ('.__LINE__.') '.' BodyContentType:'.$mailObject->BodyContentType);
				$AltBody = ($html_body = $mailObject->findBody('html')) ? $html_body->getContents() : null;
				//error_log(__METHOD__.' ('.__LINE__.') '.' AltBody:'.$AltBody);
				//error_log(__METHOD__.' ('.__LINE__.') '.array2string($mailObject->GetReplyTo()));

				if(!$Body && !$AltBody)
				{
					throw new Exception\NotFound('No mail body in template "'.$document.'"');
				}

				// Fetch ReplyTo - Address if existing to check if we are to replace it
				$replyTo = $mailObject->getReplyTo();
				if (isset($replyTo['replace@import.action']))
				{
					$mailObject->clearReplyTos();
					$activeMailProfiles = $this->mail->getAccountIdentities($this->profileID);
					$activeMailProfile = self::getStandardIdentityForProfile($activeMailProfiles,$this->profileID);

					$mailObject->addReplyTo(Horde_Idna::encode($activeMailProfile['ident_email']),Mail::generateIdentityString($activeMailProfile,false));
				}
				foreach($attachments as $file)
				{
					$mailObject->addAttachment($file);
				}
				if(count($SendAndMergeTocontacts) > 1)
				{
					foreach(Mailer::$type2header as $type => $h)
					{
						$header = $mailObject->getHeader(Mailer::$type2header[$type]);
						if(is_array($header)) $header = implode(', ',$header);
						$headers[$type] = $header;
					}
				}
				foreach ($SendAndMergeTocontacts as $k => $val)
				{
					$errorInfo = $email = '';
					$sendOK = $openComposeWindow = $openAsDraft = null;
					//error_log(__METHOD__.' ('.__LINE__.') '.' Id To Merge:'.$val);
					if (/*$GLOBALS['egw_info']['flags']['currentapp'] == 'addressbook' &&*/
						(count($SendAndMergeTocontacts) > 1 || $_folder === FALSE) && $val &&
						(is_numeric($val) || $GLOBALS['egw']->accounts->name2id($val))) // do the merge
					{
						//error_log(__METHOD__.' ('.__LINE__.') '.array2string($mailObject));

						// Parse destinations for placeholders
						foreach(Mailer::$type2header as $type => $h)
						{
							//error_log('ID ' . $val . ' ' .$type . ': ' . $mailObject->getHeader(Mailer::$type2header[$type]) . ' -> ' .$bo_merge->merge_string($mailObject->getHeader(Mailer::$type2header[$type]),$val,$e,'text/plain',array(),self::$displayCharset));
							$merged = $bo_merge->merge_string($headers[$type],$val,$e,'text/plain',array(),self::$displayCharset);
							$mailObject->clearAddresses($type);
							$mailObject->addAddress($merged,'',$type);
							if($type == 'to')
							{
								$email = $merged;
							}
						}

						// No addresses from placeholders?  Treat it as just a contact ID
						if (!$email)
						{
							$contact = $bo_merge->contacts->read($val);
							//error_log(__METHOD__.' ('.__LINE__.') '.' ID:'.$val.' Data:'.array2string($contact));
							$email = ($contact['email'] ? $contact['email'] : $contact['email_home']);
							$nfn = ($contact['n_fn'] ? $contact['n_fn'] : $contact['n_given'].' '.$contact['n_family']);
							if($email)
							{
								$mailObject->addAddress(Horde_Idna::encode($email), $nfn);
							}
						}

						$activeMailProfiles = $this->getAccountIdentities($this->profileID);
						$activeMailProfile = self::getStandardIdentityForProfile($activeMailProfiles,$this->profileID);
						//error_log(__METHOD__.' ('.__LINE__.') '.array2string($activeMailProfile));
						$mailObject->setFrom($activeMailProfile['ident_email'],
							self::generateIdentityString($activeMailProfile,false));

						$mailObject->removeHeader('Message-ID');
						$mailObject->removeHeader('Date');
						$mailObject->clearCustomHeaders();
						$mailObject->addHeader('Subject', $bo_merge->merge_string($Subject, $val, $e, 'text/plain', array(), self::$displayCharset));
						//error_log(__METHOD__.' ('.__LINE__.') '.' ContentType:'.$mailObject->BodyContentType);
						if($text_body) $text_body->setContents($bo_merge->merge_string($Body, $val, $e, 'text/plain', array(), self::$displayCharset),array('encoding'=>Horde_Mime_Part::DEFAULT_ENCODING));
						//error_log(__METHOD__.' ('.__LINE__.') '.' Result:'.$mailObject->Body.' error:'.array2string($e));
						if($html_body) $html_body->setContents($bo_merge->merge_string($AltBody, $val, $e, 'text/html', array(), self::$displayCharset),array('encoding'=>Horde_Mime_Part::DEFAULT_ENCODING));

						//error_log(__METHOD__.' ('.__LINE__.') '.array2string($mailObject));
						// set a higher timeout for big messages
						@set_time_limit(120);
						$sendOK = true;
						try {
							$mailObject->send();
							$message_id = $mailObject->getHeader('Message-ID');
							if($_folder)
							{
								$id = $this->appendMessage($_folder, $mailObject->getRaw(), '');
								$importID = $id->current();
							}
						}
						catch(Exception $e) {
							$sendOK = false;
							$errorInfo = $e->getMessage();
							//error_log(__METHOD__.' ('.__LINE__.') '.array2string($errorInfo));
						}
					}
					elseif (!$k)	// 1. entry, further entries will fail for apps other then addressbook
					{
						$openAsDraft = true;
						$mailObject->removeHeader('Message-ID');
						$mailObject->removeHeader('Date');
						$mailObject->clearCustomHeaders();

						// Parse destinations for placeholders
						foreach(Mailer::$type2header as $type => $h)
						{
							$header = $mailObject->getHeader(Mailer::$type2header[$type]);
							if(is_array($header)) $header = implode(', ',$header);
							$mailObject->clearAddresses($type);
							$merged = $bo_merge->merge_string($header,$val,$e,'text/plain',array(),self::$displayCharset);
							//error_log($type . ': ' . $mailObject->getHeader(Mailer::$type2header[$type]) . ' -> ' .$merged);
							$mailObject->addAddress(trim($merged,'"'),'',$type);
						}
						$mailObject->forceBccHeader();

						// No addresses from placeholders?  Treat it as just a contact ID
						if (count($mailObject->getAddresses('to',true)) == 0 &&
							is_numeric($val) || $GLOBALS['egw']->accounts->name2id($val)) // do the merge
						{
							$contact = $bo_merge->contacts->read($val);
							//error_log(__METHOD__.' ('.__LINE__.') '.array2string($contact));
							$email = ($contact['email'] ? $contact['email'] : $contact['email_home']);
							$nfn = ($contact['n_fn'] ? $contact['n_fn'] : $contact['n_given'].' '.$contact['n_family']);
							if($email)
							{
								$mailObject->addAddress(Horde_Idna::encode($email), $nfn);
							}
						}
						$mailObject->addHeader('Subject', $bo_merge->merge_string($Subject, $val, $e, 'text/plain', array(), self::$displayCharset));
						//error_log(__METHOD__.' ('.__LINE__.') '.' ContentType:'.$mailObject->BodyContentType);
						if (!empty($Body)) $text_body->setContents($bo_merge->merge_string($Body, $val, $e, 'text/plain', array(), self::$displayCharset),array('encoding'=>Horde_Mime_Part::DEFAULT_ENCODING));
						//error_log(__METHOD__.' ('.__LINE__.') '.' Result:'.$mailObject->Body.' error:'.array2string($e));
						if (!empty($AltBody)) $html_body->setContents($bo_merge->merge_string($AltBody, $val, $e, 'text/html', array(), self::$displayCharset),array('encoding'=>Horde_Mime_Part::DEFAULT_ENCODING));
						if(!$_folder !== false)
						{
							$_folder = $this->getDraftFolder();
						}
					}
					if ($sendOK || $openAsDraft)
					{
						if ($openAsDraft)
						{
							if($this->folderExists($_folder,true))
							{
								if($this->isSentFolder($_folder))
								{
									$flags = '\\Seen';
								} elseif($this->isDraftFolder($_folder)) {
									$flags = '\\Draft';
								} else {
									$flags = '';
								}
								$savefailed = false;
								try
								{
									$messageUid =$this->appendMessage($_folder,
										$mailObject->getRaw(),
										null,
										$flags);
								}
								catch (\Exception\WrongUserinput $e)
								{
									$savefailed = true;
									$alert_msg .= lang("Save of message %1 failed. Could not save message to folder %2 due to: %3",$Subject,$_folder,$e->getMessage());
								}
								// no send, save successful, and message_uid present
								if ($savefailed===false && $messageUid && !isset($sendOK))
								{
									$importID = $messageUid;
									$openComposeWindow = true;
								}
							}
							else if ($_folder !== FALSE)
							{
								$savefailed = true;
								$alert_msg .= lang("Saving of message %1 failed. Destination Folder %2 does not exist.",$Subject,$_folder);
							}
						}
						if ($sendOK)
						{
							$processStats['success'][$val] = 'Send succeeded to '.$nfn.'<'.$email.'>'.($savefailed?' but failed to store to Folder:'.$_folder:'');
						}
						else
						{
							if (!$openComposeWindow) $processStats['failed'][$val] = $errorInfo?$errorInfo:'Send failed to '.$nfn.'<'.$email.'> See error_log for details';
						}
					}
					if (isset($sendOK) && $sendOK===false && !isset($openComposeWindow))
					{
						$processStats['failed'][$val] = $errorInfo?$errorInfo:'Send failed to '.$nfn.'<'.$email.'> See error_log for details';
					}
				}
			}
			unset($mailObject);
		}
		// set the url to open when refreshing
		if ($importfailed == true)
		{
			throw new Exception\WrongUserinput($alert_msg);
		}
		else
		{
			//error_log(__METHOD__.' ('.__LINE__.') '.array2string($processStats));
			return $processStats;
		}
	}

	/**
	 * functions to allow the parsing of message/rfc files
	 * used in felamimail to import mails, or parsev a message from file enrich it with addressdata (merge) and send it right away.
	 */

	/**
	 * Parses a message/rfc mail from file to the mailobject
	 *
	 * @param object $mailer instance of the SMTP Mailer Object
	 * @param string $tmpFileName string that points/leads to the file to be imported
	 * @throws Exception\NotFound if $fle is not found
	 */
	function parseFileIntoMailObject(Mailer $mailer, $tmpFileName)
	{
		switch (parse_url($tmpFileName, PHP_URL_SCHEME))
		{
			case 'vfs':
				break;
			case 'egw-data':
				$message = ($host = parse_url($tmpFileName, PHP_URL_HOST)) ? Link::get_data($host, true) : false;
				break;
			default:
				$tmpFileName = $GLOBALS['egw_info']['server']['temp_dir'].'/'.basename($tmpFileName);
				break;
		}
		if (!isset($message)) $message = fopen($tmpFileName, 'r');

		if (!$message)
		{
			throw new Exception\NotFound("File '$tmpFileName' not found!");
		}
		$this->parseRawMessageIntoMailObject($mailer, $message);

		fclose($message);
	}

	/**
	 * Check and fix headers of raw message for headers with line width
	 * more than 998 chars per line, as none folding long headers might
	 * break the mail content. RFC 2822 (2.2.3 Long Header fields)
	 * https://www.ietf.org/rfc/rfc2822.txt
	 *
	 * @param string|resource $message
	 * @return string
	 */
	static private function _checkAndfixLongHeaderFields($message)
	{
		$eol = Horde_Mime_Part::RFC_EOL.Horde_Mime_Part::RFC_EOL;
		$needsFix = false;
		if (is_resource($message))
		{
			fseek($message, 0, SEEK_SET);
			$m = '';
			while (!feof($message)) {
				$m .= fread($message, 8192);
			}
			$message = $m;
		}

		if (is_string($message))
		{
			$start = substr($message,0, strpos($message, $eol));
			$body = substr($message, strlen($start));
			$hlength = strpos($start, $eol) ? strpos($start, $eol) : strlen($start);
			$headers = Horde_Mime_Headers::parseHeaders(substr($start, 0,$hlength));
			foreach($headers->toArray() as $header => $value)
			{
				$needsReplacement = false;
				foreach((array)$value as $val)
				{
					if (strlen($val)+ strlen($header) > 900)
					{
						$needsReplacement = $needsFix = true;
					}
				}
				if ($needsReplacement) {
					$headers->removeHeader($header);
					$headers->addHeader($header, $value);
				}
			}
		}
		return $needsFix ? ($headers->toString(array('canonical'=>true)).$body) : $message;
	}

	/**
	 * Parses a message/rfc mail from file to the mailobject
	 *
	 * @param Mailer $mailer instance of SMTP Mailer object
	 * @param string|ressource|Horde_Mime_Part $message string or resource containing the RawMessage / object Mail_mimeDecoded message (part))
	 * @param boolean $force8bitOnPrimaryPart (default false. force transferEncoding and charset to 8bit/utf8 if we have a textpart as primaryPart)
	 * @throws Exception\WrongParameter when the required Horde_Mail_Part not found
	 */
	function parseRawMessageIntoMailObject(Mailer $mailer, $message, $force8bitOnPrimaryPart=false)
	{
		if (is_string($message) || is_resource($message))
		{
			// Check and fix long header fields
			$message = self::_checkAndfixLongHeaderFields($message);

			// Default charset to utf-8, not us-ascii which Horde chooses
			Horde_Mime_Part::$defaultCharset = 'utf-8';

			$structure = Horde_Mime_Part::parseMessage($message);
			//error_log(__METHOD__.__LINE__.'#'.$structure->getPrimaryType().'#');
			if ($force8bitOnPrimaryPart&&$structure->getPrimaryType()=='text')
			{
				$structure->setTransferEncoding('8bit');
				$structure->setCharset('utf-8');
			}
			self::fixBinaryPart($structure);

			$mailer->setBasePart($structure);
			//error_log(__METHOD__.__LINE__.':'.array2string($structure));

			// unfortunately parseMessage does NOT return parsed headers (we assume header is shorter then 8k)
			// *** increase the header size limit to 32k to make sure most of the mails even with huge headers are
			// covered. TODO: Not sure if we even need to cut of the header parts and not just passing the whole
			// message to be parsed in order to get all headers, it needs more invetigation.
			$start = is_string($message) ? substr($message, 0, 32768) :
				(fseek($message, 0, SEEK_SET) == -1 ? '' : fread($message, 32768));

			$length = strpos($start, Horde_Mime_Part::RFC_EOL.Horde_Mime_Part::RFC_EOL);
			if ($length===false) $length = strlen($start);
			$headers = Horde_Mime_Headers::parseHeaders(substr($start, 0,$length));

			foreach($headers->toArray(array('nowrap' => true)) as $header => $value)
			{
				foreach((array)$value as $n => $val)
				{
					$overwrite = !$n;
					switch($header)
					{
						case 'Content-Transfer-Encoding':
							//as we parse the message and this sets the part with a Content-Transfer-Encoding, we
							//should not overwrite it with the header-values of the source-message as the encoding
							//may be altered when retrieving the message e.g. from server
							//error_log(__METHOD__.__LINE__.':'.$header.'->'.$val.'<->'.$mailer->getHeader('Content-Transfer-Encoding'));
							break;
						case 'Bcc':
						case 'bcc':
							//error_log(__METHOD__.__LINE__.':'.$header.'->'.$val);
							$mailer->addBcc($val);
							break;
						default:
							//error_log(__METHOD__.__LINE__.':'.$header.'->'.$val);
							$mailer->addHeader($header, $val, $overwrite);
							//error_log(__METHOD__.__LINE__.':'.'getHeader('.$header.')'.array2string($mailer->getHeader($header)));
					}
				}
			}
		}
		elseif (is_a($message, 'Horde_Mime_Part'))
		{
			$mailer->setBasePart($message);
		}
		else
		{
			if (($type = gettype($message)) == 'object') $type = get_class ($message);
			throw new Exception\WrongParameter('Wrong parameter type for message: '.$type);
		}
	}

	/**
	 * Parse an address-list
	 *
	 * Replaces imap_rfc822_parse_adrlist, which fails for utf-8, if not our replacement in common_functions is used!
	 *
	 * @param string $addresses
	 * @param string $default_domain
	 * @return Horde_Mail_Rfc822_List iteratable Horde_Mail_Rfc822_Address objects with attributes mailbox, host, personal and valid
	 */
	public static function parseAddressList($addresses, $default_domain=null)
	{
		$rfc822 = new Horde_Mail_Rfc822();
		$ret = $rfc822->parseAddressList($addresses, $default_domain ? array('default_domain' => $default_domain) : array());
		//error_log(__METHOD__.__LINE__.'#'.array2string($addresses).'#'.array2string($ret).'#'.$ret->count().'#'.$ret->count.function_backtrace());
		if ((empty($ret) || $ret->count()==0)&& is_string($addresses) && strlen($addresses)>0)
		{
			$matches = array();
			preg_match_all("/[\w\.,-.,_.,0-9.]+@[\w\.,-.,_.,0-9.]+/",$addresses,$matches);
			//error_log(__METHOD__.__LINE__.array2string($matches));
			foreach ($matches[0] as &$match) {$match = trim($match,', ');}
			$addresses = implode(',',$matches[0]);
			//error_log(__METHOD__.__LINE__.array2string($addresses));
			$ret = $rfc822->parseAddressList($addresses, $default_domain ? array('default_domain' => $default_domain) : array());
			//error_log(__METHOD__.__LINE__.'#'.array2string($addresses).'#'.array2string($ret).'#'.$ret->count().'#'.$ret->count);
		}
		$previousFailed=false;
		$ret2 = new Horde_Mail_Rfc822_List();
		// handle known problems on emailaddresses
		foreach($ret as $i => $adr)
		{
			//mailaddresses enclosed in single quotes like 'me@you.com' show up as 'me as mailbox and you.com' as host
			if ($adr->mailbox && stripos($adr->mailbox,"'")== 0 &&
					$adr->host && stripos($adr->host,"'")== (strlen($adr->host) -1))
			{
				$adr->mailbox = str_replace("'","",$adr->mailbox);
				$adr->host = str_replace("'","",$adr->host);
			}


			// try to strip extra quoting or slashes from personal part
			$adr->personal = stripslashes($adr->personal);
			if ($adr->personal && (stripos($adr->personal, '"') == 0 &&
					substr($adr->personal, -1) == '"') ||
					(substr($adr->personal, -2) == '""'))
			{
				$adr->personal = str_replace('"', "", $adr->personal);
			}


			// no mailbox or host part as 'Xr\xc3\xa4hlyz, User ' is parsed as 2 addresses separated by ','
			//#'Xr\xc3\xa4hlyz, User '
			//#Horde_Mail_Rfc822_List Object([_data:protected] => Array(
			//[0] => Horde_Mail_Rfc822_Address Object([comment] => Array()[mailbox] => Xr\xc3\xa4hlyz[_host:protected] => [_personal:protected] => )
			//[1] => Horde_Mail_Rfc822_Address Object([comment] => Array()[mailbox] => mailboxpart1.mailboxpart2[_host:protected] => youthost.com[_personal:protected] => User))[_filter:protected] => Array()[_ptr:protected] => )#2#,
			if (strlen($adr->mailbox)==0||strlen($adr->host)==0)
			{
				$remember = ($adr->mailbox?$adr->mailbox:($adr->host?$adr->host:''));
				$previousFailed=true;
				//error_log(__METHOD__.__LINE__."('$addresses', $default_domain) parsed $i: mailbox=$adr->mailbox, host=$adr->host, personal=$adr->personal");
			}
			else
			{
				if ($previousFailed && $remember) $adr->personal = $remember. ' ' . $adr->personal;
				$remember = '';
				$previousFailed=false;
				//error_log(__METHOD__.__LINE__."('$addresses', $default_domain) parsed $i: mailbox=$adr->mailbox, host=$adr->host, personal=$adr->personal");
				$ret2->add($adr);
			}
		}
		//error_log(__METHOD__.__LINE__.'#'.array2string($addresses).'#'.array2string($ret2).'#'.$ret2->count().'#'.$ret2->count);
		return $ret2;
	}

	/**
	 * Send a read notification
	 *
	 * @param string $uid
	 * @param string $_folder
	 * @return boolean
	 */
	function sendMDN($uid,$_folder)
	{
		$acc = Mail\Account::read($this->profileID);
		$identity = Mail\Account::read_identity($acc['ident_id'], true, null, $acc);
		if (self::$debug) error_log(__METHOD__.__LINE__.array2string($identity));
		$headers = $this->getMessageHeader($uid, '', 'object', true, $_folder);

		// check we have an email to send the mdn to (otherwise Horde_Mime_Mdn throws a RuntimeException)
		if (empty($mdn_to = $headers[strtoupper('Disposition-Notification-To')]) || strpos($mdn_to, '@') === false)
		{
			return false;
		}

		// Override Horde's translation with our own
		Horde_Translation::setHandler('Horde_Mime', new Horde_Translation_Handler_Gettext('Horde_Mime', EGW_SERVER_ROOT.'/api/lang/locale'));
		Preferences::setlocale();

		$mdn = new Horde_Mime_Mdn($headers);
		$mdn->generate(true, true, 'displayed', php_uname('n'), $acc->smtpTransport(), array(
			'charset' => 'utf-8',
			'from_addr' => self::generateIdentityString($identity),
		));

		return true;
	}

	/**
	 * Hook stuff
	 */

	/**
	 * hook to add account
	 *
	 * this function is a wrapper function for emailadmin
	 *
	 * @param _hookValues contains the hook values as array
	 * @return nothing
	 */
	function addAccount($_hookValues)
	{
		error_log(__METHOD__.' ('.__LINE__.') '.' NOT DONE YET!' . ' hookValue = '. $_hookValues);

	}

	/**
	 * hook to delete account
	 *
	 * this function is a wrapper function for emailadmin
	 *
	 * @param _hookValues contains the hook values as array
	 * @return nothing
	 */
	function deleteAccount($_hookValues)
	{
		error_log(__METHOD__.' ('.__LINE__.') '.' NOT DONE YET!' . ' hookValue = '. $_hookValues);

	}

	/**
	 * hook to update account
	 *
	 * this function is a wrapper function for emailadmin
	 *
	 * @param _hookValues contains the hook values as array
	 * @return nothing
	 */
	function updateAccount($_hookValues)
	{
		error_log(__METHOD__.' ('.__LINE__.') '.' NOT DONE YET!' . ' hookValue = '. $_hookValues);

	}

	/**
	 * This function gets array of email addresses in RFC822 format
	 * and tries to normalize the addresses into only email addresses.
	 *
	 * @param array $_addresses Addresses
	 */
	static function stripRFC822Addresses ($_addresses)
	{
		$matches = array();
		foreach ($_addresses as &$address)
		{
			preg_match("/<([^\'\" <>]+)>$/", $address, $matches);
			if (!empty($matches[1])) $address = $matches[1];
		}
		return $_addresses;
	}



	/**
	 * Resolve certificate and encrypted message from smime attachment
	 *
	 * @param Horde_Mime_Part $_mime_part
	 * @param array $_params
	 *		params = array (
	 *			mimeType			=> (string) // message mime type
	 *			uid					=> (string) // message uid
	 *			mailbox				=> (string) // the mailbox where message is stored
	 *			passphrase			=> (string) // smime private key passphrase
	 *		)
	 *
	 * @return Horde_Mime_Part returns a resolved mime part
	 * @throws PassphraseMissing if private key passphrase is not provided
	 * @throws Horde_Crypt_Exception if decryption fails
	 */
	function resolveSmimeMessage(Horde_Mime_Part $_mime_part, $_params)
	{
		// default params
		$params = array_merge(array(
 			'passphrase'	=> ''
		), $_params);

		$metadata = array (
			 'mimeType' => $params['mimeType']?$params['mimeType']:$_mime_part->getType()
		);
		$this->smime = new Mail\Smime;
		$message = $this->getMessageRawBody($params['uid'], null, $params['mailbox']);
		if (!Mail\Smime::isSmimeSignatureOnly(Mail\Smime::getSmimeType($_mime_part)))
		{
			try{
				$message = $this->_decryptSmimeBody($message, $params['passphrase'] !='' ?
						$params['passphrase'] : Api\Cache::getSession('mail', 'smime_passphrase'));
			}
			catch(\Horde_Crypt_Exception $e)
			{
				throw new Mail\Smime\PassphraseMissing(lang('Could not decrypt '.
						'S/MIME data. This message may not be encrypted by your '.
						'public key and not being able to find corresponding private key.'));
			}
			$metadata['encrypted'] = true;
		}

		try {
			$cert = $this->smime->verifySignature($message);
		} catch (\Exception $ex) {
			// passphrase is required to decrypt the message
			if (isset($message['password_required']))
			{
				throw new Mail\Smime\PassphraseMissing($message['msg']);
			}
			// verifivation failure either message has been tempered,
			// signature is not valid or message has not ben signed
			// but encrypted only.
			else
			{
				$metadata['verify'] = false;
				$metadata['signed'] = true;
				$metadata['msg'] = $ex->getMessage();
			}
		}

		if ($cert) // signed message, it might be encrypted too
		{
			$envelope = $this->getMessageEnvelope($params['uid'], '', false, $params['mailbox']);
			$from = $this->stripRFC822Addresses($envelope['FROM']);
			$message_parts = $this->smime->extractSignedContents($message);
			$cert_email = strtolower($cert->email);
			//$f = $message_parts->_headers->getHeader('from');
			$metadata = array_merge ($metadata, array (
				'verify'		=> $cert->verify,
				'cert'			=> $cert->cert,
				'certDetails'	=> $this->smime->parseCert($cert->cert),
				'msg'			=> $cert->msg,
				'certHtml'		=> $this->smime->certToHTML($cert->cert),
				'email'			=> $cert_email,
				'signed'		=> true
			));
			// check for email address if both signer email address and
			// email address of sender are the same. It also takes  subjectAltName emails into account.
			if (is_array($from) && strcasecmp($from[0], $cert_email) != 0
					&& stripos($metadata['certDetails']['extensions']['subjectAltName'],$from[0]) === false)
			{
				$metadata['unknownemail'] = true;
				$metadata['msg'] .= ' '.lang('Email address of signer is different from the email address of sender!');
			}

			$AB_bo   = new \addressbook_bo();
			$certkey = $AB_bo->get_smime_keys($cert_email);
			if (!is_array($certkey) || strcasecmp(trim($certkey[$cert_email]), trim($cert->cert)) != 0) $metadata['addtocontact'] = true;
		}
		else // only encrypted message
		{
			$message_parts = Horde_Mime_Part::parseMessage($message, array('forcemime' => true));
		}
		$message_parts->setMetadata('X-EGroupware-Smime', $metadata);
		return $message_parts;
	}

	/**
	 * decrypt given smime encrypted message
	 *
	 * @param string $_message
	 * @param string $_passphrase
	 * @return array|string return
	 * @throws Horde_Crypt_Exception
	 */
	private function _decryptSmimeBody ($_message, $_passphrase = '')
	{
		$AB_bo   = new \addressbook_bo();
		$acc_smime = Mail\Smime::get_acc_smime($this->profileID, $_passphrase);
		$certkey = $AB_bo->get_smime_keys($acc_smime['acc_smime_username']);
		if (!$this->smime->verifyPassphrase($acc_smime['pkey'], $_passphrase))
		{
			return array (
				'password_required' => true,
				'msg' => 'Authentication failure!'
			);
		}

		$params  = array (
			'type'      => 'message',
			'pubkey'    => $certkey[strtolower($acc_smime['acc_smime_username'])],
			'privkey'   => $acc_smime['pkey'],
			'passphrase'=> $_passphrase
		);
		return $this->smime->decrypt($_message, $params);
	}
}