class.meetingrequest.php

<?php

/*
 * SPDX-License-Identifier: AGPL-3.0-only
 * SPDX-FileCopyrightText: Copyright 2005-2016 Zarafa Deutschland GmbH
 * SPDX-FileCopyrightText: Copyright 2020-2025 grommunio GmbH
 */

class Meetingrequest {
	/*
	 * NOTE
	 *
	 * This class is designed to modify and update meeting request properties
	 * and to search for linked appointments in the calendar. It does not
	 * - set standard properties like subject or location
	 * - commit property changes through savechanges() (except in accept() and decline())
	 *
	 * To set all the other properties, just handle the item as any other appointment
	 * item. You aren't even required to set those properties before or after using
	 * this class. If you update properties before REsending a meeting request (ie with
	 * a time change) you MUST first call updateMeetingRequest() so the internal counters
	 * can be updated. You can then submit the message any way you like.
	 *
	 */

	/*
	 * How to use
	 * ----------
	 *
	 * Sending a meeting request:
	 * - Create appointment item as normal, but as 'tentative'
	 *   (this is the state of the item when the receiving user has received but
	 *    not accepted the item)
	 * - Set recipients as normally in e-mails
	 * - Create Meetingrequest class instance
	 * - Call checkCalendarWriteAccess(), to check for write permissions on calendar folder
	 * - Call setMeetingRequest(), this turns on all the meeting request properties in the
	 *   calendar item
	 * - Call sendMeetingRequest(), this sends a copy of the item with some extra properties
	 *
	 * Updating a meeting request:
	 * - Create Meetingrequest class instance
	 * - Call checkCalendarWriteAccess(), to check for write permissions on calendar folder
	 * - Call updateMeetingRequest(), this updates the counters
	 * - Call checkSignificantChanges(), this will check for significant changes and if needed will clear the
	 *   existing recipient responses
	 * - Call sendMeetingRequest()
	 *
	 * Clicking on a an e-mail:
	 * - Create Meetingrequest class instance
	 * - Check isMeetingRequest(), if true:
	 *   - Check isLocalOrganiser(), if true then ignore the message
	 *   - Check isInCalendar(), if not call doAccept(true, false, false). This adds the item in your
	 *     calendar as tentative without sending a response
	 *   - Show Accept, Tentative, Decline buttons
	 *   - When the user presses Accept, Tentative or Decline, call doAccept(false, true, true),
	 *     doAccept(true, true, true) or doDecline(true) respectively to really accept or decline and
	 *     send the response. This will remove the request from your inbox.
	 * - Check isMeetingRequestResponse, if true:
	 *   - Check isLocalOrganiser(), if not true then ignore the message
	 *   - Call processMeetingRequestResponse()
	 *     This will update the trackstatus of all recipients, and set the item to 'busy'
	 *     when all the recipients have accepted.
	 * - Check isMeetingCancellation(), if true:
	 *   - Check isLocalOrganiser(), if true then ignore the message
	 *   - Check isInCalendar(), if not, then ignore
	 *     Call processMeetingCancellation()
	 *   - Show 'Remove From Calendar' button to user
	 *   - When userpresses button, call doRemoveFromCalendar(), which removes the item from your
	 *     calendar and deletes the message
	 * - Check isMeetingForwardNotification(), if true:
	 *   - Call processMeetingForwardNotification()
	 *     This adds the attendees an attendee forwarded the meeting to.
	 *
	 * Cancelling a meeting request:
	 *   - Call doCancelInvitation, which will send cancellation mails to attendees and will remove
	 *     meeting object from calendar
	 *
	 * Forwarding a meeting request:
	 *   - Call forwardMeetingRequest(), which sends the meeting to further attendees in the name
	 *     of the organizer and notifies the organizer
	 */

	// All properties for a recipient that are interesting
	public $recipprops = [
		PR_ENTRYID,
		PR_DISPLAY_NAME,
		PR_EMAIL_ADDRESS,
		PR_RECIPIENT_ENTRYID,
		PR_RECIPIENT_TYPE,
		PR_SEND_INTERNET_ENCODING,
		PR_SEND_RICH_INFO,
		PR_RECIPIENT_DISPLAY_NAME,
		PR_ADDRTYPE,
		PR_DISPLAY_TYPE,
		PR_DISPLAY_TYPE_EX,
		PR_RECIPIENT_TRACKSTATUS,
		PR_RECIPIENT_TRACKSTATUS_TIME,
		PR_RECIPIENT_FLAGS,
		PR_ROWID,
		PR_OBJECT_TYPE,
		PR_SEARCH_KEY,
		PR_SMTP_ADDRESS,
	];

	/**
	 * Indication whether the setting of resources in a Meeting Request is success (false) or if it
	 * has failed (integer).
	 *
	 * @var null|false|int
	 *
	 * @psalm-var 1|3|4|false|null
	 */
	public $errorSetResource;

	public $proptags;

	private false|string $meetingTimeInfo;
	private $mti_html;

	/**
	 * @var null|bool
	 */
	private $includesResources;
	private $nonAcceptingResources;
	private $recipientDisplayname;

	// the address book of the session, opened once per request
	private mixed $addressBook = null;

	// SMTP addresses by address book entryid, looked up once per request
	private array $smtpAddresses = [];

	// response prepared by createResponse() and sent once the meeting is stored
	private mixed $pendingResponse = null;

	/**
	 * Constructor.
	 *
	 * Takes a store and a message. The message is an appointment item
	 * that should be converted into a meeting request or an incoming
	 * e-mail message that is a meeting request.
	 *
	 * The $session variable is optional, but required if the following features
	 * are to be used:
	 *
	 * - Sending meeting requests for meetings that are not in your own store
	 * - Sending meeting requests to resources, resource availability checking and resource freebusy updates
	 *
	 * $removeRequestOnResponse is opt-in; leaving the request mail alone is the
	 * default.
	 *
	 * @param mixed $store
	 * @param mixed $message
	 * @param mixed $session
	 * @param mixed $enableDirectBooking
	 * @param mixed $removeRequestOnResponse
	 */
	public function __construct(private $store, public $message, private $session = false, private $enableDirectBooking = true, private $removeRequestOnResponse = false) {
		// This variable string saves time information for the MR.
		$this->meetingTimeInfo = false;

		$properties = [];
		$properties['goid'] = 'PT_BINARY:PSETID_Meeting:0x3';
		$properties['goid2'] = 'PT_BINARY:PSETID_Meeting:0x23';
		$properties['type'] = 'PT_STRING8:PSETID_Meeting:0x24';
		$properties['meetingrecurring'] = 'PT_BOOLEAN:PSETID_Meeting:0x5';
		$properties['unknown2'] = 'PT_BOOLEAN:PSETID_Meeting:0xa';
		$properties['attendee_critical_change'] = 'PT_SYSTIME:PSETID_Meeting:0x1';
		$properties['owner_critical_change'] = 'PT_SYSTIME:PSETID_Meeting:0x1a';
		$properties['meetingstatus'] = 'PT_LONG:PSETID_Appointment:' . PidLidAppointmentStateFlags;
		$properties['responsestatus'] = 'PT_LONG:PSETID_Appointment:0x8218';
		$properties['unknown6'] = 'PT_LONG:PSETID_Meeting:0x4';
		$properties['replytime'] = 'PT_SYSTIME:PSETID_Appointment:0x8220';
		$properties['usetnef'] = 'PT_BOOLEAN:PSETID_Common:0x8582';
		$properties['recurrence_data'] = 'PT_BINARY:PSETID_Appointment:' . PidLidAppointmentRecur;
		$properties['reminderminutes'] = 'PT_LONG:PSETID_Common:' . PidLidReminderDelta;
		$properties['reminderset'] = 'PT_BOOLEAN:PSETID_Common:' . PidLidReminderSet;
		$properties['sendasical'] = 'PT_BOOLEAN:PSETID_Appointment:0x8200';
		$properties['updatecounter'] = 'PT_LONG:PSETID_Appointment:' . PidLidAppointmentSequence;					// AppointmentSequenceNumber
		$properties['unknown7'] = 'PT_LONG:PSETID_Appointment:0x8202';
		$properties['last_updatecounter'] = 'PT_LONG:PSETID_Appointment:0x8203';			// AppointmentLastSequence
		$properties['busystatus'] = 'PT_LONG:PSETID_Appointment:' . PidLidBusyStatus;
		$properties['intendedbusystatus'] = 'PT_LONG:PSETID_Appointment:' . PidLidIntendedBusyStatus;
		$properties['start'] = 'PT_SYSTIME:PSETID_Appointment:' . PidLidAppointmentStartWhole;
		$properties['responselocation'] = 'PT_STRING8:PSETID_Meeting:0x2';
		$properties['location'] = 'PT_STRING8:PSETID_Appointment:' . PidLidLocation;
		$properties['requestsent'] = 'PT_BOOLEAN:PSETID_Appointment:0x8229';		// PidLidFInvited, MeetingRequestWasSent
		$properties['startdate'] = 'PT_SYSTIME:PSETID_Appointment:' . PidLidAppointmentStartWhole;
		$properties['duedate'] = 'PT_SYSTIME:PSETID_Appointment:' . PidLidAppointmentEndWhole;
		$properties['flagdueby'] = 'PT_SYSTIME:PSETID_Common:' . PidLidReminderSignalTime;
		$properties['commonstart'] = 'PT_SYSTIME:PSETID_Common:0x8516';
		$properties['commonend'] = 'PT_SYSTIME:PSETID_Common:0x8517';
		$properties['recurring'] = 'PT_BOOLEAN:PSETID_Appointment:' . PidLidRecurring;
		$properties['clipstart'] = 'PT_SYSTIME:PSETID_Appointment:' . PidLidClipStart;
		$properties['clipend'] = 'PT_SYSTIME:PSETID_Appointment:' . PidLidClipEnd;
		$properties['start_recur_date'] = 'PT_LONG:PSETID_Meeting:0xD';				// StartRecurTime
		$properties['start_recur_time'] = 'PT_LONG:PSETID_Meeting:0xE';				// StartRecurTime
		$properties['end_recur_date'] = 'PT_LONG:PSETID_Meeting:0xF';				// EndRecurDate
		$properties['end_recur_time'] = 'PT_LONG:PSETID_Meeting:0x10';				// EndRecurTime
		$properties['is_exception'] = 'PT_BOOLEAN:PSETID_Meeting:0xA';				// LID_IS_EXCEPTION
		$properties['apptreplyname'] = 'PT_STRING8:PSETID_Appointment:0x8230';
		// Propose new time properties
		$properties['proposed_start_whole'] = 'PT_SYSTIME:PSETID_Appointment:' . PidLidAppointmentProposedStartWhole;
		$properties['proposed_end_whole'] = 'PT_SYSTIME:PSETID_Appointment:' . PidLidAppointmentProposedEndWhole;
		$properties['proposed_duration'] = 'PT_LONG:PSETID_Appointment:0x8256';
		$properties['counter_proposal'] = 'PT_BOOLEAN:PSETID_Appointment:' . PidLidAppointmentCounterProposal;
		$properties['recurring_pattern'] = 'PT_STRING8:PSETID_Appointment:' . PidLidRecurrencePattern;
		$properties['basedate'] = 'PT_SYSTIME:PSETID_Appointment:' . PidLidExceptionReplaceTime;
		$properties['meetingtype'] = 'PT_LONG:PSETID_Meeting:0x26';
		$properties['timezone_data'] = 'PT_BINARY:PSETID_Appointment:' . PidLidTimeZoneStruct;
		$properties['timezone'] = 'PT_STRING8:PSETID_Appointment:' . PidLidTimeZoneDescription;
		$properties['categories'] = 'PT_MV_STRING8:PS_PUBLIC_STRINGS:Keywords';
		$properties['private'] = 'PT_BOOLEAN:PSETID_Common:' . PidLidPrivate;
		$properties['alldayevent'] = 'PT_BOOLEAN:PSETID_Appointment:' . PidLidAppointmentSubType;
		$properties['toattendeesstring'] = 'PT_STRING8:PSETID_Appointment:0x823B';
		$properties['ccattendeesstring'] = 'PT_STRING8:PSETID_Appointment:0x823C';
		$properties['allattendeesstring'] = 'PT_STRING8:PSETID_Appointment:0x8238';
		$properties['auxiliary_flags'] = 'PT_LONG:PSETID_Appointment:0x8207';
		$properties['forward_instance'] = 'PT_BOOLEAN:PSETID_Appointment:0x820A';
		$properties['tzdefstart'] = 'PT_BINARY:PSETID_Appointment:0x825E';
		$properties['forward_notification_recipients'] = 'PT_BINARY:PSETID_Appointment:0x8261';

		$this->proptags = getPropIdsFromStrings($this->store, $properties);
	}

	/**
	 * Sets the direct booking property. This is an alternative to the setting of the direct booking
	 * property through the constructor. However, setting it in the constructor is preferred.
	 *
	 * @param bool $directBookingSetting
	 */
	public function setDirectBooking($directBookingSetting): void {
		$this->enableDirectBooking = $directBookingSetting;
	}

	/**
	 * Returns TRUE if the message pointed to is an incoming meeting request and should
	 * therefore be replied to with doAccept or doDecline().
	 *
	 * @param false|string $messageClass message class to use for checking
	 *
	 * @return bool returns true if this is a meeting request else false
	 */
	public function isMeetingRequest(false|string $messageClass = false): bool {
		if ($messageClass === false) {
			$messageClass = mapi_getprops($this->message, [PR_MESSAGE_CLASS])[PR_MESSAGE_CLASS] ?? false;
		}

		return $messageClass !== false && stripos($messageClass, 'ipm.schedule.meeting.request') === 0;
	}

	/**
	 * Returns TRUE if the message pointed to is a returning meeting request response.
	 *
	 * @param false|string $messageClass message class to use for checking
	 *
	 * @return bool returns true if this is a meeting request else false
	 */
	public function isMeetingRequestResponse(false|string $messageClass = false): bool {
		if ($messageClass === false) {
			$messageClass = mapi_getprops($this->message, [PR_MESSAGE_CLASS])[PR_MESSAGE_CLASS] ?? false;
		}

		return $messageClass !== false && stripos($messageClass, 'ipm.schedule.meeting.resp') === 0;
	}

	/**
	 * Returns TRUE if the message pointed to is a cancellation request.
	 *
	 * @param false|string $messageClass message class to use for checking
	 *
	 * @return bool returns true if this is a meeting request else false
	 */
	public function isMeetingCancellation(false|string $messageClass = false): bool {
		if ($messageClass === false) {
			$messageClass = mapi_getprops($this->message, [PR_MESSAGE_CLASS])[PR_MESSAGE_CLASS] ?? false;
		}

		return $messageClass !== false && stripos($messageClass, 'ipm.schedule.meeting.canceled') === 0;
	}

	/**
	 * Returns TRUE if the message pointed to is a meeting forward notification.
	 *
	 * @param false|string $messageClass message class to use for checking
	 *
	 * @return bool returns true if this is a meeting forward notification else false
	 */
	public function isMeetingForwardNotification(false|string $messageClass = false): bool {
		if ($messageClass === false) {
			$messageClass = mapi_getprops($this->message, [PR_MESSAGE_CLASS])[PR_MESSAGE_CLASS] ?? false;
		}

		return $messageClass !== false && stripos($messageClass, 'ipm.schedule.meeting.notification.forward') === 0;
	}

	/**
	 * Function is used to get the last update counter of meeting request.
	 *
	 * @return false|int false when last_updatecounter not found else return last_updatecounter
	 */
	public function getLastUpdateCounter(): false|int {
		$calendarItemProps = mapi_getprops($this->message, [$this->proptags['last_updatecounter']]);

		return $calendarItemProps[$this->proptags['last_updatecounter']] ?? false;
	}

	/**
	 * Process an incoming meeting request response. This updates the appointment
	 * in your calendar to show whether the user has accepted or declined.
	 */
	public function processMeetingRequestResponse(): void {
		if (!$this->isMeetingRequestResponse()) {
			return;
		}

		if (!$this->isLocalOrganiser()) {
			return;
		}

		// Get information we need from the response message
		$messageprops = mapi_getprops($this->message, [
			$this->proptags['goid'],
			$this->proptags['goid2'],
			PR_OWNER_APPT_ID,
			PR_SENT_REPRESENTING_EMAIL_ADDRESS,
			PR_SENT_REPRESENTING_NAME,
			PR_SENT_REPRESENTING_ADDRTYPE,
			PR_SENT_REPRESENTING_ENTRYID,
			PR_SENT_REPRESENTING_SEARCH_KEY,
			PR_MESSAGE_DELIVERY_TIME,
			PR_MESSAGE_CLASS,
			PR_PROCESSED,
			PR_RCVD_REPRESENTING_ENTRYID,
			$this->proptags['proposed_start_whole'],
			$this->proptags['proposed_end_whole'],
			$this->proptags['proposed_duration'],
			$this->proptags['counter_proposal'],
			$this->proptags['attendee_critical_change'],
		]);

		$goid2 = $messageprops[$this->proptags['goid2']];

		if (!isset($goid2) || !isset($messageprops[PR_SENT_REPRESENTING_EMAIL_ADDRESS])) {
			return;
		}

		// Find basedate in GlobalID(0x3), this can be a response for an occurrence
		$basedate = $this->getBasedateFromGlobalID($messageprops[$this->proptags['goid']]);

		$userStore = $this->store;
		// check if delegate is processing the response
		if (isset($messageprops[PR_RCVD_REPRESENTING_ENTRYID])) {
			$delegatorStore = $this->getDelegatorStore($messageprops[PR_RCVD_REPRESENTING_ENTRYID], [PR_IPM_APPOINTMENT_ENTRYID]);
			if (!empty($delegatorStore['store'])) {
				$userStore = $delegatorStore['store'];
			}
		}

		// check for calendar access
		$this->ensureCalendarWriteAccess($userStore);

		$calendarItem = $this->getCorrespondentCalendarItem(true);

		// Open the calendar items, and update all the recipients of the calendar item that match
		// the email address of the response.
		if ($calendarItem !== false) {
			$this->processResponse($userStore, $calendarItem, $basedate, $messageprops);
		}
	}

	/**
	 * Process every incoming MeetingRequest response.This updates the appointment
	 * in your calendar to show whether the user has accepted or declined.
	 *
	 * @param resource  $store        contains the userStore in which the meeting is created
	 * @param mixed     $calendarItem resource of the calendar item for which this response has arrived
	 * @param false|int $basedate     if present the create an exception
	 * @param array     $messageprops contains message properties
	 */
	public function processResponse(mixed $store, mixed $calendarItem, mixed $basedate, array $messageprops): ?false {
		$senderentryid = $messageprops[PR_SENT_REPRESENTING_ENTRYID];
		$messageclass = $messageprops[PR_MESSAGE_CLASS];
		$deliverytime = $messageprops[PR_MESSAGE_DELIVERY_TIME];
		$recurringItem = false;

		// Open the calendar item, find the sender in the recipient table and update all the recipients of the calendar item that match
		// the email address of the response.
		$calendarItemProps = mapi_getprops($calendarItem, [$this->proptags['recurring'], PR_STORE_ENTRYID, PR_PARENT_ENTRYID, PR_ENTRYID, $this->proptags['updatecounter']]);

		// check if meeting response is already processed
		if (isset($messageprops[PR_PROCESSED]) && $messageprops[PR_PROCESSED] === true) {
			// meeting is already processed
			return null;
		}
		mapi_setprops($this->message, [PR_PROCESSED => true]);
		mapi_savechanges($this->message);

		// if meeting is updated in organizer's calendar then we don't need to process
		// old response
		if ($this->isMeetingUpdated($basedate)) {
			return null;
		}

		// If basedate is found, then create/modify exception msg and do processing
		if (!empty($basedate) && !empty($calendarItemProps[$this->proptags['recurring']])) {
			$attach = $this->saveResponseException($store, $calendarItem, $basedate);
			if ($attach) {
				$recurringItem = $calendarItem;
				$calendarItem = mapi_attach_openobj($attach, MAPI_MODIFY);
			}
			else {
				return false;
			}
		}

		$this->updateResponseRecipients($calendarItem, $messageprops, $senderentryid, $messageclass, $deliverytime);

		// TODO: Update counter proposal number property on message
		/*
		If it is the first time this attendee has proposed a new date/time, increment the value of the PidLidAppointmentProposalNumber property on the organizer's meeting object, by 0x00000001. If this property did not previously exist on the organizer's meeting object, it MUST be set with a value of 0x00000001.
		*/
		// If this is a counter proposal, set the counter proposal indicator boolean
		if (isset($messageprops[$this->proptags['counter_proposal']])) {
			$props = [$this->proptags['counter_proposal'] => (bool) $messageprops[$this->proptags['counter_proposal']]];
			mapi_setprops($calendarItem, $props);
		}

		mapi_savechanges($calendarItem);
		if (isset($attach) && $recurringItem !== false) {
			mapi_savechanges($attach);
			mapi_savechanges($recurringItem);
		}

		return null;
	}

	private function saveResponseException(mixed $store, mixed $calendarItem, mixed $basedate): mixed {
		$recurr = new Recurrence($store, $calendarItem);

		// Copy properties from meeting request
		$exception_props = mapi_getprops($this->message, [
			PR_OWNER_APPT_ID,
			$this->proptags['proposed_start_whole'],
			$this->proptags['proposed_end_whole'],
			$this->proptags['proposed_duration'],
			$this->proptags['counter_proposal'],
		]);

		// Create/modify exception
		if ($recurr->isException($basedate)) {
			$recurr->modifyException($exception_props, $basedate);
		}
		else {
			// When we are creating an exception we need copy recipients from main recurring item
			$recips = $this->getMessageRecipients($calendarItem);

			// Retrieve actual start/due dates from calendar item.
			$exception_props[$this->proptags['startdate']] = $recurr->getOccurrenceStart($basedate);
			$exception_props[$this->proptags['duedate']] = $recurr->getOccurrenceEnd($basedate);

			$recurr->createException($exception_props, $basedate, false, $recips);
		}

		mapi_savechanges($calendarItem);

		return $recurr->getExceptionAttachment($basedate);
	}

	private function updateResponseRecipients(mixed $calendarItem, array $messageprops, mixed $senderentryid, mixed $messageclass, mixed $deliverytime): void {
		// Get the recipients of the calendar item
		$recipients = $this->getMessageRecipients($calendarItem);

		// FIXME we should look at the updatecounter property and compare it
		// to the counter in the recipient to see if this update is actually
		// newer than the status in the calendar item
		$found = false;

		foreach ($recipients as $recipient) {
			// external recipients might not have entryid
			if (!isset($recipient[PR_ENTRYID]) &&
				$recipient[PR_EMAIL_ADDRESS] == $messageprops[PR_SENT_REPRESENTING_EMAIL_ADDRESS]) {
				$recipient[PR_ENTRYID] = $senderentryid;
			}
			if (isset($recipient[PR_ENTRYID]) && $this->compareABEntryIDs($recipient[PR_ENTRYID], $senderentryid)) {
				$found = true;

				/*
				 * If value of attendee_critical_change on meeting response mail is less than PR_RECIPIENT_TRACKSTATUS_TIME
				 * on the corresponding recipientRow of meeting then we ignore this response mail.
				 */
				if (isset($recipient[PR_RECIPIENT_TRACKSTATUS_TIME]) && ($messageprops[$this->proptags['attendee_critical_change']] < $recipient[PR_RECIPIENT_TRACKSTATUS_TIME])) {
					continue;
				}

				$recipient = $this->getResponseRecipientProperties($recipient, $messageprops, $messageclass);

				// Update the recipient information
				mapi_message_modifyrecipients($calendarItem, MODRECIP_REMOVE, [$recipient]);
				mapi_message_modifyrecipients($calendarItem, MODRECIP_ADD, [$recipient]);
			}
		}

		// If the recipient was not found in the original calendar item,
		// then add the recpient as a new optional recipient
		if (!$found) {
			$recipient = $this->getNewResponseRecipient($messageprops, $messageclass, $deliverytime);

			mapi_message_modifyrecipients($calendarItem, MODRECIP_ADD, [$recipient]);
		}
	}

	private function getResponseRecipientProperties(array $recipient, array $messageprops, mixed $messageclass): array {
		// The email address matches, update the row
		$recipient[PR_RECIPIENT_TRACKSTATUS] = $this->getTrackStatus($messageclass);
		if (isset($messageprops[$this->proptags['attendee_critical_change']])) {
			$recipient[PR_RECIPIENT_TRACKSTATUS_TIME] = $messageprops[$this->proptags['attendee_critical_change']];
		}

		// If this is a counter proposal, set the proposal properties in the recipient row
		if (isset($messageprops[$this->proptags['counter_proposal']]) && $messageprops[$this->proptags['counter_proposal']]) {
			$recipient[PR_RECIPIENT_PROPOSEDSTARTTIME] = $messageprops[$this->proptags['proposed_start_whole']];
			$recipient[PR_RECIPIENT_PROPOSEDENDTIME] = $messageprops[$this->proptags['proposed_end_whole']];
			$recipient[PR_RECIPIENT_PROPOSED] = $messageprops[$this->proptags['counter_proposal']];
		}

		return $recipient;
	}

	private function getNewResponseRecipient(array $messageprops, mixed $messageclass, mixed $deliverytime): array {
		$recipient = [];
		$recipient[PR_ENTRYID] = $messageprops[PR_SENT_REPRESENTING_ENTRYID];
		$recipient[PR_EMAIL_ADDRESS] = $messageprops[PR_SENT_REPRESENTING_EMAIL_ADDRESS];
		$recipient[PR_DISPLAY_NAME] = $messageprops[PR_SENT_REPRESENTING_NAME];
		$recipient[PR_ADDRTYPE] = $messageprops[PR_SENT_REPRESENTING_ADDRTYPE];
		$recipient[PR_RECIPIENT_TYPE] = MAPI_CC;
		$recipient[PR_SEARCH_KEY] = $messageprops[PR_SENT_REPRESENTING_SEARCH_KEY];
		$recipient[PR_RECIPIENT_TRACKSTATUS] = $this->getTrackStatus($messageclass);
		$recipient[PR_RECIPIENT_TRACKSTATUS_TIME] = $deliverytime;

		// If this is a counter proposal, set the proposal properties in the recipient row
		if (isset($messageprops[$this->proptags['counter_proposal']])) {
			$recipient[PR_RECIPIENT_PROPOSEDSTARTTIME] = $messageprops[$this->proptags['proposed_start_whole']];
			$recipient[PR_RECIPIENT_PROPOSEDENDTIME] = $messageprops[$this->proptags['proposed_end_whole']];
			$recipient[PR_RECIPIENT_PROPOSED] = $messageprops[$this->proptags['counter_proposal']];
		}

		return $recipient;
	}

	/**
	 * Process an incoming meeting request cancellation. This updates the
	 * appointment in your calendar to show that the meeting has been cancelled.
	 */
	public function processMeetingCancellation(): void {
		if (!$this->isMeetingCancellation()) {
			return;
		}

		if ($this->isLocalOrganiser()) {
			return;
		}

		if (!$this->isInCalendar()) {
			return;
		}

		$listProperties = $this->proptags;
		$listProperties['subject'] = PR_SUBJECT;
		$listProperties['sent_representing_name'] = PR_SENT_REPRESENTING_NAME;
		$listProperties['sent_representing_address_type'] = PR_SENT_REPRESENTING_ADDRTYPE;
		$listProperties['sent_representing_email_address'] = PR_SENT_REPRESENTING_EMAIL_ADDRESS;
		$listProperties['sent_representing_entryid'] = PR_SENT_REPRESENTING_ENTRYID;
		$listProperties['sent_representing_search_key'] = PR_SENT_REPRESENTING_SEARCH_KEY;
		$listProperties['rcvd_representing_name'] = PR_RCVD_REPRESENTING_NAME;
		$listProperties['rcvd_representing_address_type'] = PR_RCVD_REPRESENTING_ADDRTYPE;
		$listProperties['rcvd_representing_email_address'] = PR_RCVD_REPRESENTING_EMAIL_ADDRESS;
		$listProperties['rcvd_representing_entryid'] = PR_RCVD_REPRESENTING_ENTRYID;
		$listProperties['rcvd_representing_search_key'] = PR_RCVD_REPRESENTING_SEARCH_KEY;
		$messageProps = mapi_getprops($this->message, $listProperties);

		$goid = $messageProps[$this->proptags['goid']];	// GlobalID (0x3)
		if (!isset($goid)) {
			return;
		}

		$store = $this->store;
		// get delegator store, if delegate is processing this cancellation
		if (isset($messageProps[PR_RCVD_REPRESENTING_ENTRYID])) {
			$delegatorStore = $this->getDelegatorStore($messageProps[PR_RCVD_REPRESENTING_ENTRYID], [PR_IPM_APPOINTMENT_ENTRYID]);
			if (!empty($delegatorStore['store'])) {
				$store = $delegatorStore['store'];
			}
		}

		// check for calendar access
		$this->ensureCalendarWriteAccess($store);

		$calendarItem = $this->getCorrespondentCalendarItem(true);
		$basedate = $this->getBasedateFromGlobalID($goid);

		if ($calendarItem !== false) {
			// if basedate is provided and we could not find the item then it could be that we are processing
			// an exception so get the exception and process it
			if (!empty($basedate)) {
				$calendarItemProps = mapi_getprops($calendarItem, [$this->proptags['recurring']]);
				if ($calendarItemProps[$this->proptags['recurring']] === true) {
					$recurr = new Recurrence($store, $calendarItem);

					// Set message class
					$messageProps[PR_MESSAGE_CLASS] = 'IPM.Appointment';

					if ($recurr->isException($basedate)) {
						$recurr->modifyException($messageProps, $basedate);
					}
					else {
						$recurr->createException($messageProps, $basedate);
					}
				}
			}
			else {
				// set the properties of the cancellation object
				mapi_setprops($calendarItem, $messageProps);
			}

			mapi_savechanges($calendarItem);
		}
	}

	/**
	 * Process an incoming meeting forward notification (MS-OXOCAL v22.1 §3.1.4.10.2). This adds
	 * the attendees the meeting was forwarded to as optional attendees of the meeting in
	 * the organizer's calendar.
	 *
	 * @return bool true if attendees were added
	 */
	public function processMeetingForwardNotification(): bool {
		if (!$this->isMeetingForwardNotification()) {
			return false;
		}

		$messageprops = mapi_getprops($this->message, [
			$this->proptags['goid'],
			$this->proptags['forward_notification_recipients'],
			PR_PARENT_ENTRYID,
			PR_PROCESSED,
			PR_RCVD_REPRESENTING_ENTRYID,
		]);

		if (!$this->isForwardNotificationToProcess($messageprops)) {
			return false;
		}

		$calendarItem = $this->getCorrespondentCalendarItem(true);
		if ($calendarItem === false) {
			return false;
		}
		$calendarItemProps = mapi_getprops($calendarItem, [$this->proptags['responsestatus'], $this->proptags['recurring']]);
		if (($calendarItemProps[$this->proptags['responsestatus']] ?? null) !== olResponseOrganized) {
			return false;
		}

		$store = $this->resolveDelegateStoreAndCalendar($messageprops)['store'];
		$this->ensureCalendarWriteAccess($store);

		$basedate = $this->getBasedateFromGlobalID($messageprops[$this->proptags['goid']]);
		$recurringItem = false;
		$attach = false;
		if (!empty($basedate) && !empty($calendarItemProps[$this->proptags['recurring']])) {
			$attach = $this->getForwardedOccurrenceAttachment($store, $calendarItem, $basedate);
			if (!$attach) {
				return false;
			}
			$recurringItem = $calendarItem;
			$calendarItem = mapi_attach_openobj($attach, MAPI_MODIFY);
		}

		$added = $this->addForwardedAttendees($calendarItem, $recurringItem, $attach, $messageprops);
		$this->setProcessed();

		return $added;
	}

	/**
	 * Whether a meeting forward notification is still to be processed: not once it was,
	 * not without the meeting's GlobalObjectId, and not the forwarder's own copy.
	 */
	private function isForwardNotificationToProcess(array $messageprops): bool {
		if (!empty($messageprops[PR_PROCESSED]) || empty($messageprops[$this->proptags['goid']])) {
			return false;
		}

		// the copy in the forwarder's own mailbox is not processed
		foreach ([PR_IPM_SENTMAIL_ENTRYID, PR_IPM_OUTBOX_ENTRYID] as $folder) {
			if (compareEntryIds($this->getBaseEntryID($folder), $messageprops[PR_PARENT_ENTRYID] ?? false)) {
				return false;
			}
		}

		return true;
	}

	/**
	 * The exception attachment of the occurrence a meeting was forwarded for, created when
	 * the occurrence has none yet. False when there is nothing to add the attendees to; a
	 * deleted occurrence and a day without one are marked processed.
	 *
	 * @param mixed $store        store of the calendar item
	 * @param mixed $calendarItem the series in the organizer's calendar
	 * @param int   $basedate     basedate of the forwarded occurrence
	 */
	private function getForwardedOccurrenceAttachment(mixed $store, mixed $calendarItem, int $basedate): mixed {
		$recurr = new Recurrence($store, $calendarItem);
		// a deleted occurrence is never brought back
		if ($recurr->isDeleteException($basedate)) {
			$this->setProcessed();

			return false;
		}
		if (!$recurr->isException($basedate)) {
			$exception_props = [
				$this->proptags['startdate'] => $recurr->getOccurrenceStart($basedate),
				$this->proptags['duedate'] => $recurr->getOccurrenceEnd($basedate),
			];
			// fails when the series has no occurrence on that day
			if (!$recurr->createException($exception_props, $basedate, false, $this->getMessageRecipients($calendarItem))) {
				$this->setProcessed();

				return false;
			}
			mapi_savechanges($calendarItem);
		}

		return $recurr->getExceptionAttachment($basedate);
	}

	/**
	 * Adds the attendees a meeting forward notification lists to the meeting or the
	 * occurrence, as far as they are not attendees yet.
	 *
	 * @param mixed $calendarItem  the meeting, or the exception of the occurrence
	 * @param mixed $recurringItem the series when an occurrence is updated, else false
	 * @param mixed $attach        the exception attachment of the occurrence, else false
	 * @param array $messageprops  properties of the meeting forward notification
	 *
	 * @return bool true if attendees were added
	 */
	private function addForwardedAttendees(mixed $calendarItem, mixed $recurringItem, mixed $attach, array $messageprops): bool {
		$existing = $this->getMessageRecipients($calendarItem);
		$seriesRecipients = [];
		// an exception without recipients of its own has those of the series
		if ($recurringItem !== false && empty($existing)) {
			$existing = $seriesRecipients = $this->getMessageRecipients($recurringItem);
		}
		$added = [];
		foreach ($this->getNewForwardRecipients($existing, $this->getForwardRecipientRows($messageprops)) as $recip) {
			$added[] = $this->resolveForwardRecipient($recip);
		}

		if (!empty($added)) {
			mapi_message_modifyrecipients($calendarItem, MODRECIP_ADD, array_merge($seriesRecipients, $added));
			mapi_savechanges($calendarItem);
			if ($attach !== false && $recurringItem !== false) {
				mapi_savechanges($attach);
				mapi_savechanges($recurringItem);
			}
		}

		return !empty($added);
	}

	/**
	 * Returns true if the corresponding calendar items exists in the celendar folder for this
	 * meeting request/response/cancellation.
	 */
	public function isInCalendar(): bool {
		// @TODO check for deleted exceptions
		return $this->getCorrespondentCalendarItem(false) !== false;
	}

	/**
	 * Accepts the meeting request by moving the item to the calendar
	 * and sending a confirmation message back to the sender. If $tentative
	 * is TRUE, then the item is accepted tentatively. After accepting, you
	 * can't use this class instance any more. The message is closed. If you
	 * specify TRUE for 'move', then the item is actually moved (from your
	 * inbox probably) to the calendar. If you don't, it is copied into
	 * your calendar.
	 *
	 * @param bool      $tentative            true if user as tentative accepted the meeting
	 * @param bool      $sendresponse         true if a response has to be sent to organizer
	 * @param bool      $move                 true if the meeting request should be moved to the deleted items after processing
	 * @param mixed     $newProposedStartTime contains starttime if user has proposed other time
	 * @param mixed     $newProposedEndTime   contains endtime if user has proposed other time
	 * @param false|int $basedate             start of day of occurrence for which user has accepted the recurrent meeting
	 * @param bool      $isImported           true to indicate that MR is imported from .ics or .vcs file else it false.
	 *
	 * @return bool|string $entryid entryid of item which created/updated in calendar
	 */
	public function doAccept(bool $tentative, bool $sendresponse, bool $move, mixed $newProposedStartTime = false, mixed $newProposedEndTime = false, mixed $body = false, mixed $userAction = false, mixed $store = false, mixed $basedate = false, bool $isImported = false): bool|string {
		if ($this->isLocalOrganiser()) {
			return false;
		}

		// Remove any previous calendar items with this goid and appt id
		$messageprops = mapi_getprops($this->message, [PR_ENTRYID, PR_PARENT_ENTRYID,
			PR_MESSAGE_CLASS, $this->proptags['goid'], $this->proptags['updatecounter'],
			PR_PROCESSED, PR_RCVD_REPRESENTING_ENTRYID, PR_SENDER_ENTRYID,
			PR_SENT_REPRESENTING_ENTRYID, PR_RECEIVED_BY_ENTRYID]);

		// do not process meeting requests in sent items folder
		if ($this->isInSentItems($messageprops)) {
			return false;
		}

		['store' => $store, 'calFolder' => $calFolder] = $this->resolveDelegateStoreAndCalendar($messageprops);

		// check for calendar access
		$this->ensureCalendarWriteAccess($store);

		if ($this->isMeetingRequest($messageprops[PR_MESSAGE_CLASS]) && !$this->isRequestToProcess($messageprops, $userAction)) {
			return false;
		}

		// Retrieve basedate from globalID, if it is not received as argument
		if (empty($basedate)) {
			$basedate = $this->getBasedateFromGlobalID($messageprops[$this->proptags['goid']]);
		}

		// set counter proposal properties in calendar item when proposing new time
		$proposeNewTimeProps = $this->getCounterProposalProperties($newProposedStartTime, $newProposedEndTime);

		// While sender is receiver then we have to process the meeting request as per the intended busy status
		// instead of tentative, and accept the same as per the intended busystatus.
		try {
			if ($this->isSentToSelf($messageprops)) {
				$entryid = $this->accept(false, $sendresponse, $move, $proposeNewTimeProps, $body, true, $store, $calFolder, $basedate);
			}
			else {
				$entryid = $this->accept($tentative, $sendresponse, $move, $proposeNewTimeProps, $body, $userAction, $store, $calFolder, $basedate);
			}
		}
		finally {
			// accept() clears this once it has sent; anything left means it threw
			$this->discardPendingResponse();
		}

		// Opt-in; by default the request mail stays in the inbox.
		if ($this->removeRequestOnResponse && $entryid && $userAction && !$this->isMeetingRequest($messageprops[PR_MESSAGE_CLASS])) {
			$this->removeRequestFromInbox($basedate);
		}

		// if we have first time processed this meeting then set PR_PROCESSED property
		$this->setRequestProcessed($messageprops, $userAction, $isImported);

		return $entryid;
	}

	private function isInSentItems(array $messageprops): bool {
		$sentItemsEntryid = $this->getDefaultSentmailEntryID();

		return isset($messageprops[PR_PARENT_ENTRYID]) &&
			$sentItemsEntryid !== false &&
			$sentItemsEntryid == $messageprops[PR_PARENT_ENTRYID];
	}

	/**
	 * Whether a meeting request is still to be processed: not an out of date one, and not
	 * one that is opened automatically after it or its calendar item was processed.
	 *
	 * @param array $messageprops properties of the meeting request
	 * @param mixed $userAction   false when the request is processed automatically on opening
	 */
	private function isRequestToProcess(array $messageprops, mixed $userAction): bool {
		// if meeting is out dated then don't process it
		if ($this->isMeetingOutOfDate()) {
			return false;
		}

		/*
		 *	if this function is called automatically with meeting request object then there will be
		 *	two possibilitites
		 *	1) meeting request is opened first time, in this case make a tentative appointment in
		 *		recipient's calendar
		 *	2) after this every subsequent request to open meeting request will not do any processing
		 */
		if ($userAction !== false) {
			return true;
		}
		if (isset($messageprops[PR_PROCESSED]) && $messageprops[PR_PROCESSED] === true) {
			// if meeting request is already processed then don't do anything
			return false;
		}

		// if correspondent calendar item is already processed then don't do anything
		$calendarItem = $this->getCorrespondentCalendarItem();
		if ($calendarItem) {
			$calendarItemProps = mapi_getprops($calendarItem, [PR_PROCESSED]);
			if (isset($calendarItemProps[PR_PROCESSED]) && $calendarItemProps[PR_PROCESSED] === true) {
				// mark meeting-request mail as processed as well
				mapi_setprops($this->message, [PR_PROCESSED => true]);
				mapi_savechanges($this->message);

				return false;
			}
		}

		return true;
	}

	/**
	 * The counter proposal of an attendee who proposes another time, nothing without one.
	 */
	private function getCounterProposalProperties(mixed $newProposedStartTime, mixed $newProposedEndTime): array {
		$proposeNewTimeProps = [];
		if ($newProposedStartTime && $newProposedEndTime) {
			$proposeNewTimeProps[$this->proptags['proposed_start_whole']] = $newProposedStartTime;
			$proposeNewTimeProps[$this->proptags['proposed_end_whole']] = $newProposedEndTime;
			$proposeNewTimeProps[$this->proptags['proposed_duration']] = round($newProposedEndTime - $newProposedStartTime) / 60;
			$proposeNewTimeProps[$this->proptags['counter_proposal']] = true;
		}

		return $proposeNewTimeProps;
	}

	/**
	 * Whether the user received the message from themselves.
	 */
	private function isSentToSelf(array $messageprops): bool {
		$senderEntryId = $messageprops[PR_SENT_REPRESENTING_ENTRYID] ?? $messageprops[PR_SENDER_ENTRYID];

		return isset($messageprops[PR_RECEIVED_BY_ENTRYID]) && compareEntryIds($senderEntryId, $messageprops[PR_RECEIVED_BY_ENTRYID]);
	}

	/**
	 * Marks a meeting request as processed once it was processed automatically for the
	 * first time; an imported one is not marked, nor one that is already.
	 *
	 * @param array $messageprops properties of the message
	 * @param mixed $userAction   false when the request is processed automatically on opening
	 * @param bool  $isImported   true for a request imported from an .ics or .vcs file
	 */
	private function setRequestProcessed(array $messageprops, mixed $userAction, bool $isImported): void {
		if ($this->isMeetingRequest($messageprops[PR_MESSAGE_CLASS]) && $userAction === false && $isImported === false) {
			if (!isset($messageprops[PR_PROCESSED]) || $messageprops[PR_PROCESSED] != true) {
				// set processed flag
				$this->setProcessed();
			}
		}
	}

	/**
	 * @param (float|mixed|true)[] $proposeNewTimeProps
	 * @param resource             $calFolder
	 *
	 * @psalm-param array<float|mixed|true> $proposeNewTimeProps
	 */
	public function accept(bool $tentative, bool $sendresponse, bool $move, array $proposeNewTimeProps, mixed $body, bool $userAction, mixed $store, mixed $calFolder, mixed $basedate = false): mixed {
		$messageprops = mapi_getprops($this->message);
		$isDelegate = $this->isMessageFromDelegate($messageprops);

		if ($sendresponse) {
			// The response is built from the request, which the move below
			// copies and removes, so it is prepared now. It only goes out once
			// the calendar item exists: a failure in between must not leave the
			// organizer with an acceptance of a meeting the attendee never got.
			$this->pendingResponse = $this->createResponse($tentative ? olResponseTentative : olResponseAccepted, $proposeNewTimeProps, $body, $store, $basedate, $calFolder, true);
		}

		if (!$this->isMeetingRequest($messageprops[PR_MESSAGE_CLASS])) {
			$entryid = $this->acceptCalendarResponse($messageprops, $tentative, $proposeNewTimeProps, $store, $basedate);
		}
		elseif (!empty($messageprops[$this->proptags['recurring']]) && $basedate === false) {
			$entryid = $this->acceptRecurringRequest($messageprops, $tentative, $move, $userAction, $store, $calFolder, $isDelegate);
		}
		else {
			$entryid = $this->acceptSingleRequest($messageprops, $tentative, $move, $proposeNewTimeProps, $userAction, $store, $calFolder, $basedate, $isDelegate);
		}
		$this->submitPendingResponse($entryid);

		return $entryid;
	}

	/**
	 * Sends the response prepared by createResponse(), unless nothing was
	 * stored: an acceptance of a meeting that does not exist would be a lie.
	 */
	private function submitPendingResponse(mixed $entryid): void {
		$message = $this->pendingResponse;
		$this->pendingResponse = null;
		if ($message === null) {
			return;
		}
		if (empty($entryid)) {
			$this->deleteOutgoingMessage($message);

			return;
		}
		mapi_message_submitmessage($message);
	}

	/**
	 * Drops a response that was prepared but never sent, so that accept()
	 * throwing does not leave an unsent message in the outbox.
	 */
	private function discardPendingResponse(): void {
		$message = $this->pendingResponse;
		$this->pendingResponse = null;
		if ($message !== null) {
			$this->deleteOutgoingMessage($message);
		}
	}

	private function deleteOutgoingMessage(mixed $message): void {
		$props = mapi_getprops($message, [PR_ENTRYID, PR_PARENT_ENTRYID]);
		if (!isset($props[PR_ENTRYID], $props[PR_PARENT_ENTRYID])) {
			return;
		}
		$parent = mapi_msgstore_openentry($this->openDefaultStore(), $props[PR_PARENT_ENTRYID]);
		mapi_folder_deletemessages($parent, [$props[PR_ENTRYID]]);
	}

	private function acceptRecurringRequest(array $messageprops, bool $tentative, bool $move, bool $userAction, mixed $store, mixed $calFolder, bool $isDelegate): mixed {
		$nonRecurr2Recurr = false; // non-recurring meeting was converted to a recurring

		// Find main recurring item based on GlobalID (0x3)
		$calendarItem = $this->openMatchingCalendarItem($messageprops[$this->proptags['goid2']], $store, $calFolder);

		$processed = false;
		if (!$calendarItem) {
			// Recurring item not found, so create new meeting in Calendar
			$calendarItem = mapi_folder_createmessage($calFolder);
		}
		else {
			// we have found the main recurring item, check if this meeting request is already processed
			if (isset($messageprops[PR_PROCESSED]) && $messageprops[PR_PROCESSED] === true) {
				// only set required properties, other properties are already copied when processing this meeting request
				// for the first time
				$processed = true;
			}
			// Preserve the attendee's local categories on the series while applying
			// the update from the organizer.
			$localCategories = $this->getLocalCategories($calendarItem, $store, $calFolder, $nonRecurr2Recurr);
		}

		$props = $this->getAcceptedRequestProperties($processed, $tentative, $userAction);

		mapi_setprops($calendarItem, $props);

		// we have already processed attachments and recipients, so no need to do it again
		if (!$processed) {
			// Copy attachments too
			$this->replaceAttachments($this->message, $calendarItem);
			// Copy recipients too
			$this->replaceRecipients($this->message, $calendarItem, $isDelegate);
		}

		$this->mergeCalendarOccurrences($calendarItem, $messageprops, $store, $calFolder);

		if (!isset($props[$this->proptags["recurring_pattern"]])) {
			$recurr = new Recurrence($store, $calendarItem);
			$recurr->saveRecurrencePattern();
		}

		mapi_savechanges($calendarItem);

		// Restore the attendee's local categories on the series.
		// When a non-recurring meeting was converted to a recurring one, it is not
		// necessary to restore them because they remain on the same master item.
		if (!empty($localCategories) && !$nonRecurr2Recurr) {
			$this->applyLocalCategories($calendarItem, $store, $localCategories);
		}

		if ($move) {
			// open wastebasket of currently logged in user and move the meeting request to it
			// for delegates this will be delegate's wastebasket folder
			$wastebasket = $this->openDefaultWastebasket($this->openDefaultStore());
			$sourcefolder = $this->openParentFolder();
			mapi_folder_copymessages($sourcefolder, [$props[PR_ENTRYID]], $wastebasket, MESSAGE_MOVE);
		}

		return $props[PR_ENTRYID];
	}

	private function getAcceptedRequestProperties(bool $processed, bool $tentative, bool $userAction): array {
		if (!$processed) {
			// get all the properties and copy that to calendar item
			$props = mapi_getprops($this->message);
			// reset the PidLidMeetingType to Unspecified for outlook display the item
			$props[$this->proptags['meetingtype']] = mtgEmpty;
			// Correct reminder time (some clients like OL can generate wrong flagdueby time)
			$this->correctReminderTime($props);
		}
		else {
			// only get required properties so we will not overwrite existing updated properties from calendar
			$props = mapi_getprops($this->message, [PR_ENTRYID]);
		}

		$props[PR_MESSAGE_CLASS] = 'IPM.Appointment';
		// When meeting requests are generated by third-party solutions, we might be missing the updatecounter property.
		if (!isset($props[$this->proptags['updatecounter']])) {
			$props[$this->proptags['updatecounter']] = 0;
		}
		$props[$this->proptags['meetingstatus']] = olMeetingReceived;
		$props[$this->proptags['responsestatus']] = $this->determineResponseStatus($userAction, $tentative);

		$props[$this->proptags['busystatus']] = $this->calculateBusyStatus($tentative, $props);

		if ($userAction) {
			$this->setReplyTimeAndName($props);
		}

		return $props;
	}

	private function mergeCalendarOccurrences(mixed &$calendarItem, array $messageprops, mixed $store, mixed $calFolder): void {
		// Find all occurrences based on CleanGlobalID (0x23)
		// there will be no exceptions left if $processed is true, but even if it doesn't hurt to recheck
		$items = $this->findCalendarItems($messageprops[$this->proptags['goid2']], $calFolder, true);
		if (is_array($items)) {
			// Save all existing occurrence as exceptions
			foreach ($items as $entryid) {
				// Open occurrence
				$occurrenceItem = mapi_msgstore_openentry($store, $entryid);

				// Save occurrence into main recurring item as exception
				if ($occurrenceItem) {
					$occurrenceItemProps = mapi_getprops($occurrenceItem, [$this->proptags['goid'], $this->proptags['recurring']]);

					// Find basedate of occurrence item
					$basedate = $this->getBasedateFromGlobalID($occurrenceItemProps[$this->proptags['goid']]);
					if (!empty($basedate) && $occurrenceItemProps[$this->proptags['recurring']] != true) {
						$this->mergeException($calendarItem, $occurrenceItem, $basedate, $store);
					}
				}
			}
		}
	}

	private function acceptSingleRequest(array $messageprops, bool $tentative, bool $move, array $proposeNewTimeProps, bool $userAction, mixed $store, mixed $calFolder, mixed $basedate, bool $isDelegate): mixed {
		$entryid = '';
		$calendarItem = false;

		// We found basedate in GlobalID of this meeting request, so this meeting request if for an occurrence.
		if (!empty($basedate)) {
			// Find main recurring item from CleanGlobalID of this meeting request
			$calendarItem = $this->openMatchingCalendarItem($messageprops[$this->proptags['goid2']], $store, $calFolder);

			// Main recurring item is found, so now update exception
			if ($calendarItem) {
				$this->acceptException($calendarItem, $this->message, $basedate, $move, $tentative, $userAction, $store, $isDelegate);
				$calendarItemProps = mapi_getprops($calendarItem, [PR_ENTRYID]);
				$entryid = $calendarItemProps[PR_ENTRYID];
			}
		}

		if (!$calendarItem) {
			$items = $this->findCalendarItems($messageprops[$this->proptags['goid']], $calFolder);
			if (is_array($items)) {
				// Get local categories before deleting MR.
				$message = mapi_msgstore_openentry($store, $items[0]);
				$localCategories = mapi_getprops($message, [$this->proptags['categories']]);
				mapi_folder_deletemessages($calFolder, $items);
			}

			if ($move) {
				$entryid = $this->moveAcceptedRequest($messageprops, $tentative, $proposeNewTimeProps, $userAction, $calFolder, $localCategories ?? []);
			}
			else {
				$entryid = $this->copyAcceptedRequest($tentative, $proposeNewTimeProps, $userAction, $calFolder, $isDelegate, $localCategories ?? []);
			}
		}

		return $entryid;
	}

	private function moveAcceptedRequest(array $messageprops, bool $tentative, array $proposeNewTimeProps, bool $userAction, mixed $calFolder, mixed $localCategories): mixed {
		// All we have to do is open the default calendar,
		// set the message class correctly to be an appointment item
		// and move it to the calendar folder
		$sourcefolder = $this->openParentFolder();

		// create a new calendar message, and copy the message to there,
		// since we want to delete (move to wastebasket) the original message
		$old_entryid = mapi_getprops($this->message, [PR_ENTRYID]);
		$calmsg = mapi_folder_createmessage($calFolder);
		mapi_copyto($this->message, [], [], $calmsg); /* includes attachments and recipients */
		// reset the PidLidMeetingType to Unspecified for outlook display the item
		$tmp_props = [];
		$tmp_props[$this->proptags['meetingtype']] = mtgEmpty;
		// OL needs this field always being set, or it will not display item
		$tmp_props[$this->proptags['recurring']] = false;
		mapi_setprops($calmsg, $tmp_props);

		// After creating new MR, If local categories exist then apply it on new MR.
		if (!empty($localCategories)) {
			mapi_setprops($calmsg, $localCategories);
		}

		$calItemProps = [];
		$calItemProps[PR_MESSAGE_CLASS] = 'IPM.Appointment';

		/*
		 * the client which has sent this meeting request can generate wrong flagdueby
		 * time (mainly OL), so regenerate that property so we will always show reminder
		 * on right time
		 */
		if (isset($messageprops[$this->proptags['reminderminutes']])) {
			$calItemProps[$this->proptags['flagdueby']] = $messageprops[$this->proptags['startdate']] - ($messageprops[$this->proptags['reminderminutes']] * 60);
		}

		$calItemProps[$this->proptags['busystatus']] = $this->calculateBusyStatus($tentative, $messageprops);
		if (isset($messageprops[$this->proptags['intendedbusystatus']])) {
			$calItemProps[$this->proptags['intendedbusystatus']] = $messageprops[$this->proptags['intendedbusystatus']];
		}

		$calItemProps[$this->proptags['responsestatus']] = $this->determineResponseStatus($userAction, $tentative);
		if ($userAction) {
			$this->setReplyTimeAndName($calItemProps);
		}

		$calItemProps[$this->proptags['recurring_pattern']] = '';
		$calItemProps[$this->proptags['alldayevent']] = $messageprops[$this->proptags['alldayevent']] ?? false;
		$calItemProps[$this->proptags['private']] = $messageprops[$this->proptags['private']] ?? false;
		$calItemProps[$this->proptags['meetingstatus']] = olMeetingReceived;
		if (isset($messageprops[$this->proptags['startdate']])) {
			$calItemProps[$this->proptags['commonstart']] = $calItemProps[$this->proptags['startdate']] = $messageprops[$this->proptags['startdate']];
		}
		if (isset($messageprops[$this->proptags['duedate']])) {
			$calItemProps[$this->proptags['commonend']] = $calItemProps[$this->proptags['duedate']] = $messageprops[$this->proptags['duedate']];
		}

		mapi_setprops($calmsg, $proposeNewTimeProps + $calItemProps);

		// get properties which stores owner information in meeting request mails
		$props = mapi_getprops($calmsg, [
			PR_SENT_REPRESENTING_ENTRYID,
			PR_SENT_REPRESENTING_NAME,
			PR_SENT_REPRESENTING_EMAIL_ADDRESS,
			PR_SENT_REPRESENTING_ADDRTYPE,
			PR_SENT_REPRESENTING_SEARCH_KEY,
			PR_SENT_REPRESENTING_SMTP_ADDRESS,
		]);

		// mapi_copyto() has brought the recipients along, add the owner only if missing
		$recips = $this->getMessageRecipients($this->message);
		$count = count($recips);
		$this->addOrganizer($props, $recips);
		if (count($recips) > $count) {
			mapi_message_modifyrecipients($calmsg, MODRECIP_ADD, [$recips[0]]);
		}
		mapi_savechanges($calmsg);

		// Move the message to the wastebasket
		$wastebasket = $this->openDefaultWastebasket($this->openDefaultStore());
		mapi_folder_copymessages($sourcefolder, [$old_entryid[PR_ENTRYID]], $wastebasket, MESSAGE_MOVE);

		$messageprops = mapi_getprops($calmsg, [PR_ENTRYID]);

		return $messageprops[PR_ENTRYID];
	}

	private function copyAcceptedRequest(bool $tentative, array $proposeNewTimeProps, bool $userAction, mixed $calFolder, bool $isDelegate, mixed $localCategories): mixed {
		// Create a new appointment with duplicate properties and recipient, but as an IPM.Appointment
		$new = mapi_folder_createmessage($calFolder);
		$props = mapi_getprops($this->message);

		$props[$this->proptags['recurring_pattern']] = '';
		$props[$this->proptags['alldayevent']] ??= false;
		$props[$this->proptags['private']] ??= false;
		$props[$this->proptags['meetingstatus']] = olMeetingReceived;
		if (isset($props[$this->proptags['startdate']])) {
			$props[$this->proptags['commonstart']] = $props[$this->proptags['startdate']];
		}
		if (isset($props[$this->proptags['duedate']])) {
			$props[$this->proptags['commonend']] = $props[$this->proptags['duedate']];
		}

		$props[PR_MESSAGE_CLASS] = 'IPM.Appointment';
		// reset the PidLidMeetingType to Unspecified for outlook display the item
		$props[$this->proptags['meetingtype']] = mtgEmpty;
		// OL needs this field always being set, or it will not display item
		$props[$this->proptags['recurring']] = false;

		// After creating new MR, If local categories exist then apply it on new MR.
		if (!empty($localCategories)) {
			mapi_setprops($new, $localCategories);
		}

		/*
		 * the client which has sent this meeting request can generate wrong flagdueby
		 * time (mainly OL), so regenerate that property so we will always show reminder
		 * on right time
		 */
		$this->correctReminderTime($props);

		// When meeting requests are generated by third-party solutions, we might be missing the updatecounter property.
		if (!isset($props[$this->proptags['updatecounter']])) {
			$props[$this->proptags['updatecounter']] = 0;
		}
		$props[$this->proptags['responsestatus']] = $this->determineResponseStatus($userAction, $tentative);

		$props[$this->proptags['busystatus']] = $this->calculateBusyStatus($tentative, $props);

		if ($userAction) {
			$this->setReplyTimeAndName($props);
		}

		mapi_setprops($new, $proposeNewTimeProps + $props);

		$recips = $this->getAcceptedRecipients($this->message, $isDelegate, $this->message);

		$this->addOrganizer($props, $recips);
		mapi_message_modifyrecipients($new, MODRECIP_ADD, $recips);
		mapi_savechanges($new);

		$props = mapi_getprops($new, [PR_ENTRYID]);

		return $props[PR_ENTRYID];
	}

	private function openMatchingCalendarItem(string $goid, mixed $store, mixed $calFolder): mixed {
		$calendarItem = false;
		$items = $this->findCalendarItems($goid, $calFolder);
		if (is_array($items)) {
			foreach ($items as $entryid) {
				$calendarItem = mapi_msgstore_openentry($store, $entryid);
			}
		}

		return $calendarItem;
	}

	private function acceptCalendarResponse(array $messageprops, bool $tentative, array $proposeNewTimeProps, mixed $store, mixed $basedate): mixed {
		// Here only properties are set on calendaritem, because user is responding from calendar.
		$props = [];
		$props[$this->proptags['responsestatus']] = $tentative ? olResponseTentative : olResponseAccepted;

		$props[$this->proptags['busystatus']] = $this->calculateBusyStatus($tentative, $messageprops);
		if (isset($messageprops[$this->proptags['intendedbusystatus']])) {
			$props[$this->proptags['intendedbusystatus']] = $messageprops[$this->proptags['intendedbusystatus']];
		}

		$props[$this->proptags['meetingstatus']] = olMeetingReceived;

		$this->setReplyTimeAndName($props);

		if (!empty($basedate)) {
			$recurr = new Recurrence($store, $this->message);

			// Copy recipients list
			$reciptable = mapi_message_getrecipienttable($this->message);
			$recips = mapi_table_queryallrows($reciptable, $this->recipprops);

			if ($recurr->isException($basedate)) {
				$recurr->modifyException($proposeNewTimeProps + $props, $basedate, $recips);
			}
			else {
				$props[$this->proptags['startdate']] = $recurr->getOccurrenceStart($basedate);
				$props[$this->proptags['duedate']] = $recurr->getOccurrenceEnd($basedate);

				$props[PR_SENT_REPRESENTING_EMAIL_ADDRESS] = $messageprops[PR_SENT_REPRESENTING_EMAIL_ADDRESS];
				$props[PR_SENT_REPRESENTING_NAME] = $messageprops[PR_SENT_REPRESENTING_NAME];
				$props[PR_SENT_REPRESENTING_ADDRTYPE] = $messageprops[PR_SENT_REPRESENTING_ADDRTYPE];
				$props[PR_SENT_REPRESENTING_ENTRYID] = $messageprops[PR_SENT_REPRESENTING_ENTRYID];
				$props[PR_SENT_REPRESENTING_SEARCH_KEY] = $messageprops[PR_SENT_REPRESENTING_SEARCH_KEY];

				$recurr->createException($proposeNewTimeProps + $props, $basedate, false, $recips);
			}
		}
		else {
			mapi_setprops($this->message, $proposeNewTimeProps + $props);
		}
		mapi_savechanges($this->message);

		return $messageprops[PR_ENTRYID];
	}

	/**
	 * Moves the meeting request mail of the appointment which is being
	 * responded to into the wastebasket.
	 *
	 * Only the inbox of the responding user is searched, so a request which a
	 * rule has filed into another folder is left alone, and so is the request
	 * of a mailbox which merely shares its calendar with the responding user.
	 * A response to the series does not match the requests of single
	 * occurrences either, as those carry their basedate in the GlobalObjectId.
	 *
	 * Removing the mail is a courtesy rather than part of the response, so a
	 * failure to do so is swallowed instead of failing the accept or decline
	 * which has already been carried out.
	 *
	 * @param false|int $basedate basedate of the occurrence which was responded to
	 */
	public function removeRequestFromInbox(false|int $basedate = false): void {
		try {
			$props = mapi_getprops($this->message, [$this->proptags['goid'], $this->proptags['goid2']]);

			// An occurrence carries its basedate inside the GlobalObjectId, so a
			// response to one occurrence never matches the series invitation.
			$goid = $basedate !== false && !empty($props[$this->proptags['goid2']]) ?
				$this->setBasedateInGlobalID($props[$this->proptags['goid2']], $basedate) :
				($props[$this->proptags['goid']] ?? false);
			if (empty($goid)) {
				return;
			}

			// The request was delivered to the responding user, which for a delegate
			// is not the store holding the appointment.
			$store = $this->openDefaultStore();
			if ($store === false) {
				return;
			}
			$inbox = $this->openDefaultFolder(PR_ENTRYID, $store);
			$wastebasket = $this->openDefaultWastebasket($store);
			if ($inbox === false || $wastebasket === false) {
				return;
			}

			// Named property ids are assigned per store.
			$goidtag = getPropIdsFromStrings($store, ['goid' => 'PT_BINARY:PSETID_Meeting:0x3'])['goid'];

			$table = mapi_folder_getcontentstable($inbox);
			$rows = mapi_table_queryallrows($table, [PR_ENTRYID], [
				RES_AND,
				[
					[
						RES_PROPERTY,
						[
							RELOP => RELOP_EQ,
							ULPROPTAG => $goidtag,
							VALUE => $goid,
						],
					],
					[
						RES_CONTENT,
						[
							FUZZYLEVEL => FL_PREFIX | FL_IGNORECASE,
							ULPROPTAG => PR_MESSAGE_CLASS,
							VALUE => [PR_MESSAGE_CLASS => 'IPM.Schedule.Meeting.Request'],
						],
					],
				],
			]);
			if (empty($rows)) {
				return;
			}

			mapi_folder_copymessages($inbox, array_column($rows, PR_ENTRYID), $wastebasket, MESSAGE_MOVE);
		}
		catch (MAPIException $e) {
			// The response itself succeeded, so do not let the cleanup fail it.
			$e->setHandled();
		}
	}

	/**
	 * Declines the meeting request by moving the item to the deleted
	 * items folder and sending a decline message. After declining, you
	 * can't use this class instance any more. The message is closed.
	 * When an occurrence is decline then false is returned because that
	 * occurrence is deleted not the recurring item.
	 *
	 * @param bool      $sendresponse true if a response has to be sent to organizer
	 * @param false|int $basedate     if specified contains starttime of day of an occurrence
	 *
	 * @return bool true if item is deleted from Calendar else false
	 */
	public function doDecline(bool $sendresponse, mixed $basedate = false, mixed $body = false): bool {
		if ($this->isLocalOrganiser()) {
			return false;
		}

		$result = false;
		$calendaritem = false;

		// Remove any previous calendar items with this goid and appt id
		$messageprops = mapi_getprops($this->message, [
			$this->proptags['goid'],
			$this->proptags['goid2'],
			PR_RCVD_REPRESENTING_ENTRYID,
			PR_PARENT_ENTRYID
		]);

		['store' => $store, 'calFolder' => $calFolder] = $this->resolveDelegateStoreAndCalendar($messageprops);

		// check for calendar access before deleting the calendar item
		$this->ensureCalendarWriteAccess($store);

		$goid = $messageprops[$this->proptags['goid']];

		// First, find the items in the calendar by GlobalObjid (0x3)
		$entryids = $this->findCalendarItems($goid, $calFolder);

		if (empty($basedate)) {
			$basedate = $this->getBasedateFromGlobalID($goid);
		}

		if ($sendresponse) {
			$this->createResponse(olResponseDeclined, [], $body, $store, $basedate, $calFolder);
		}

		if (!empty($basedate)) {
			// use CleanGlobalObjid (0x23)
			$calendaritems = $this->findCalendarItems($messageprops[$this->proptags['goid2']], $calFolder);

			if (is_array($calendaritems)) {
				foreach ($calendaritems as $entryid) {
					// Open each calendar item and set the properties of the cancellation object
					$calendaritem = mapi_msgstore_openentry($store, $entryid);

					// Recurring item is found, now delete exception
					if ($calendaritem) {
						$this->doRemoveExceptionFromCalendar($basedate, $calendaritem, $store);
						$result = true;
					}
				}
			}

			if ($this->isMeetingRequest()) {
				$calendaritem = false;
			}
		}

		// Opt-in; by default the request mail stays in the inbox.
		if ($this->removeRequestOnResponse && !$this->isMeetingRequest()) {
			$this->removeRequestFromInbox($basedate);
		}

		if (!$calendaritem) {
			$calendar = $this->openDefaultCalendar($store);

			if (!empty($entryids)) {
				mapi_folder_deletemessages($calendar, $entryids);
			}

			// All we have to do to decline, is to move the item to the waste basket
			$wastebasket = $this->openDefaultWastebasket($this->openDefaultStore());
			$sourcefolder = $this->openParentFolder();

			$messageprops = mapi_getprops($this->message, [PR_ENTRYID]);

			// Release the message
			$this->message = null;

			// Move the message to the waste basket
			mapi_folder_copymessages($sourcefolder, [$messageprops[PR_ENTRYID]], $wastebasket, MESSAGE_MOVE);

			$result = true;
		}

		return $result;
	}

	/**
	 * Removes a meeting request from the calendar when the user presses the
	 * 'remove from calendar' button in response to a meeting cancellation.
	 *
	 * @param false|int $basedate if specified contains starttime of day of an occurrence
	 */
	public function doRemoveFromCalendar(mixed $basedate): ?false {
		if ($this->isLocalOrganiser()) {
			return false;
		}

		$messageprops = mapi_getprops($this->message, [
			PR_ENTRYID,
			$this->proptags['goid'],
			PR_RCVD_REPRESENTING_ENTRYID,
			PR_MESSAGE_CLASS,
			PR_PARENT_ENTRYID
		]);

		$goid = $messageprops[$this->proptags['goid']];

		['store' => $store, 'calFolder' => $calFolder] = $this->resolveDelegateStoreAndCalendar($messageprops);

		// check for calendar access before deleting the calendar item
		$this->ensureCalendarWriteAccess($store);

		$wastebasket = $this->openDefaultWastebasket($this->openDefaultStore());
		// get the source folder of the meeting message
		$sourcefolder = $this->openParentFolder();

		// Check if the message is a meeting request in the inbox or a calendaritem by checking the message class
		if ($this->isMeetingCancellation($messageprops[PR_MESSAGE_CLASS])) {
			// get the basedate to check for exception
			$basedate = $this->getBasedateFromGlobalID($goid);

			$calendarItem = $this->getCorrespondentCalendarItem(true);

			if ($calendarItem !== false) {
				// basedate is provided so open exception
				if (!empty($basedate)) {
					$exception = $this->getExceptionItem($calendarItem, $basedate);

					if ($exception !== false) {
						// exception found, remove it from calendar
						$this->doRemoveExceptionFromCalendar($basedate, $calendarItem, $store);
					}
				}
				else {
					// remove normal / recurring series from calendar
					$entryids = mapi_getprops($calendarItem, [PR_ENTRYID]);

					$entryids = [$entryids[PR_ENTRYID]];

					mapi_folder_copymessages($calFolder, $entryids, $wastebasket, MESSAGE_MOVE);
				}
			}

			// Release the message, because we are going to move it to wastebasket
			$this->message = null;

			// Move the cancellation mail to wastebasket
			mapi_folder_copymessages($sourcefolder, [$messageprops[PR_ENTRYID]], $wastebasket, MESSAGE_MOVE);
		}
		else {
			// Here only properties are set on calendaritem, because user is responding from calendar.
			if (!empty($basedate)) {
				// remove the occurrence
				$this->doRemoveExceptionFromCalendar($basedate, $this->message, $store);
			}
			else {
				// remove normal/recurring meeting item.
				// Move the message to the waste basket
				mapi_folder_copymessages($sourcefolder, [$messageprops[PR_ENTRYID]], $wastebasket, MESSAGE_MOVE);
			}
		}

		return null;
	}

	/**
	 * Function can be used to cancel any existing meeting and send cancellation mails to attendees.
	 * Should only be called from meeting object from calendar.
	 *
	 * @param false|int $basedate (optional) basedate of occurrence which should be cancelled
	 *
	 * @FIXME cancellation mail is also sent to attendee which has declined the meeting
	 * @FIXME don't send canellation mail when cancelling meeting from past
	 */
	public function doCancelInvitation(false|int $basedate = false): void {
		if (!$this->isLocalOrganiser()) {
			return;
		}

		// check write access on the folder the meeting resides in
		$parentProps = mapi_getprops($this->message, [PR_PARENT_ENTRYID]);
		$hasWriteAccess = empty($parentProps[PR_PARENT_ENTRYID]) ?
			$this->checkCalendarWriteAccess($this->store) :
			$this->checkFolderWriteAccess($parentProps[PR_PARENT_ENTRYID], $this->store);
		if ($hasWriteAccess !== true) {
			// Throw an exception that we don't have write permissions on calendar folder,
			// error message will be filled by module
			throw new MAPIException(_("Insufficient permissions"), MAPI_E_NO_ACCESS);
		}

		$messageProps = mapi_getprops($this->message, [PR_ENTRYID, $this->proptags['recurring']]);

		if (!empty($messageProps[$this->proptags['recurring']])) {
			// cancellation of recurring series or one occurrence
			$recurrence = new Recurrence($this->store, $this->message);

			// if basedate is specified then we are cancelling only one occurrence, so create exception for that occurrence
			if (!empty($basedate)) {
				$recurrence->createException([], $basedate, true);
			}

			// update the meeting request
			$this->updateMeetingRequest();

			// send cancellation mails
			$this->sendMeetingRequest(true, _('Canceled') . ': ', $basedate);

			// save changes in the message
			mapi_savechanges($this->message);
		}
		else {
			// cancellation of normal meeting request
			// Send the cancellation
			$this->updateMeetingRequest();
			$this->sendMeetingRequest(true, _('Canceled') . ': ');

			// save changes in the message
			mapi_savechanges($this->message);
		}

		// if basedate is specified then we have already created exception of it so nothing should be done now
		// but when cancelling normal / recurring meeting request we need to remove meeting from calendar
		if ($basedate === false) {
			// get the wastebasket folder, for delegate this will give wastebasket of delegate
			$wastebasket = $this->openDefaultWastebasket($this->openDefaultStore());

			// get the source folder of the meeting message
			$sourcefolder = $this->openParentFolder();

			// Move the message to the deleted items
			mapi_folder_copymessages($sourcefolder, [$messageProps[PR_ENTRYID]], $wastebasket, MESSAGE_MOVE);
		}
	}

	/**
	 * Convert epoch to MAPI FileTime, number of 100-nanosecond units since
	 * the start of January 1, 1601.
	 * https://msdn.microsoft.com/en-us/library/office/cc765906.aspx.
	 *
	 * @param int $epoch the current epoch
	 *
	 * @return int the MAPI FileTime equalevent to the given epoch time
	 */
	public function epochToMapiFileTime(int $epoch): int {
		$nanoseconds_between_epoch = 116444736000000000;

		return ($epoch * 10000000) + $nanoseconds_between_epoch;
	}

	/**
	 * Sets the properties in the message so that is can be sent
	 * as a meeting request. The caller has to submit the message. This
	 * is only used for new MeetingRequests. Pass the appointment item as $message
	 * in the constructor to do this.
	 */
	public function setMeetingRequest(false|int $basedate = false): void {
		$props = mapi_getprops($this->message, [$this->proptags['updatecounter']]);

		// Create a new global id for this item
		// https://msdn.microsoft.com/en-us/library/ee160198(v=exchg.80).aspx
		$goid = pack('H*', '040000008200E00074C5B7101A82E00800000000');
		/*
		$year = gmdate('Y');
		$month = gmdate('n');
		$day = gmdate('j');
		$goid .= pack('n', $year);
		$goid .= pack('C', $month);
		$goid .= pack('C', $day);
		*/
		// Creation Time
		$time = $this->epochToMapiFileTime(time());
		$goid .= pack('V', $time & 0xFFFFFFFF);
		$goid .= pack('V', $time >> 32);
		// 8 Zeros
		$goid .= pack('H*', '0000000000000000');
		// Length of the random data
		$goid .= pack('V', 16);
		// Random data.
		for ($i = 0; $i < 16; ++$i) {
			$goid .= chr(random_int(0, 255));
		}

		// Create a new appointment id for this item
		$apptid = random_int(0, mt_getrandmax());

		$props[PR_OWNER_APPT_ID] = $apptid;
		$props[PR_ICON_INDEX] = 1026;
		$props[$this->proptags['goid']] = $goid;
		$props[$this->proptags['goid2']] = $goid;

		if (!isset($props[$this->proptags['updatecounter']])) {
			$props[$this->proptags['updatecounter']] = 0;			// OL also starts sequence no with zero.
			$props[$this->proptags['last_updatecounter']] = 0;
		}

		mapi_setprops($this->message, $props);
	}

	/**
	 * Sends a meeting request by copying it to the outbox, converting
	 * the message class, adding some properties that are required only
	 * for sending the message and submitting the message. Set cancel to
	 * true if you wish to completely cancel the meeting request. You can
	 * specify an optional 'prefix' to prefix the sent message, which is normally
	 * 'Canceled: '.
	 *
	 * @return array|bool true on success, resource error details otherwise
	 *
	 * @psalm-return array{error: 1|3|4, displayname: mixed}|true
	 */
	public function sendMeetingRequest(mixed $cancel, mixed $prefix = false, mixed $basedate = false, mixed $modifiedRecips = false, mixed $deletedRecips = false): array|bool {
		$this->includesResources = false;
		$this->nonAcceptingResources = [];

		// Get the properties of the message
		$messageprops = mapi_getprops($this->message, [$this->proptags['recurring']]);

		/*
		 * Submit message to non-resource recipients
		 */
		// Set BusyStatus to olTentative (1)
		// Set MeetingStatus to olMeetingReceived
		// Set ResponseStatus to olResponseNotResponded

		/*
		 * While sending recurrence meeting exceptions are not sent as attachments
		 * because first all exceptions are sent and then recurrence meeting is sent.
		 */
		if (isset($messageprops[$this->proptags['recurring']]) && $messageprops[$this->proptags['recurring']] && empty($basedate)) {
			// Book resource
			$this->bookResources($this->message, $cancel, $prefix);

			if (empty($this->errorSetResource)) {
				$recurr = new Recurrence($this->store, $this->message);

				// First send meetingrequest for recurring item
				$this->submitMeetingRequest($this->message, $cancel, $prefix, false, $recurr, false, $modifiedRecips, $deletedRecips);

				// Then send all meeting request for all exceptions
				$exceptions = $recurr->getAllExceptions();
				if ($exceptions) {
					foreach ($exceptions as $exceptionBasedate) {
						$attach = $recurr->getExceptionAttachment($exceptionBasedate);

						if ($attach) {
							$occurrenceItem = mapi_attach_openobj($attach, MAPI_MODIFY);
							$this->submitMeetingRequest($occurrenceItem, $cancel, false, $exceptionBasedate, $recurr, false, $modifiedRecips, $deletedRecips);
							mapi_savechanges($attach);
						}
					}
				}
			}
		}
		else {
			// Basedate found, an exception is to be sent
			if (!empty($basedate)) {
				$recurr = new Recurrence($this->store, $this->message);

				if ($cancel) {
					// @TODO: remove occurrence from Resource's Calendar if resource was booked for whole series
					$this->submitMeetingRequest($this->message, $cancel, $prefix, $basedate, $recurr, false);
				}
				else {
					$attach = $recurr->getExceptionAttachment($basedate);

					if ($attach) {
						$occurrenceItem = mapi_attach_openobj($attach, MAPI_MODIFY);

						// Book resource for this occurrence
						$this->bookResources($occurrenceItem, $cancel, $prefix, $basedate);

						if (empty($this->errorSetResource)) {
							// Save all previous changes
							mapi_savechanges($this->message);

							$this->submitMeetingRequest($occurrenceItem, $cancel, $prefix, $basedate, $recurr, true, $modifiedRecips, $deletedRecips);
							mapi_savechanges($occurrenceItem);
							mapi_savechanges($attach);
						}
					}
				}
			}
			else {
				// This is normal meeting
				$this->bookResources($this->message, $cancel, $prefix);

				if (empty($this->errorSetResource)) {
					$this->submitMeetingRequest($this->message, $cancel, $prefix, false, false, false, $modifiedRecips, $deletedRecips);
				}
			}
		}

		if (!empty($this->errorSetResource)) {
			return [
				'error' => $this->errorSetResource,
				'displayname' => $this->recipientDisplayname,
			];
		}

		return true;
	}

	/**
	 * Updates the message after an update has been performed (for example,
	 * changing the time of the meeting). This must be called before re-sending
	 * the meeting request. You can also call this function instead of 'setMeetingRequest()'
	 * as it will automatically call setMeetingRequest on this object if it is the first
	 * call to this function.
	 */
	public function updateMeetingRequest(false|int $basedate = false): void {
		$messageprops = mapi_getprops($this->message, [$this->proptags['last_updatecounter'], $this->proptags['goid']]);

		if (!isset($messageprops[$this->proptags['goid']])) {
			$this->setMeetingRequest($basedate);
		}
		else {
			$counter = ($messageprops[$this->proptags['last_updatecounter']] ?? 0) + 1;

			// increment value of last_updatecounter, last_updatecounter will be common for recurring series
			// so even if you sending an exception only you need to update the last_updatecounter in the recurring series message
			// this way we can make sure that every time we will be using a uniwue number for every operation
			mapi_setprops($this->message, [$this->proptags['last_updatecounter'] => $counter]);
		}
	}

	/**
	 * Forwards the meeting to further attendees (MS-OXOCAL v22.1 §3.1.4.7.5). The request is sent
	 * from the acting user's outbox in the name of the organizer, so the new attendees
	 * respond to the organizer, who is informed with a meeting forward notification.
	 * Pass the calendar item or the meeting request as $message in the constructor.
	 *
	 * @param array     $recipients recipient rows of the attendees to forward to
	 * @param string    $prefix     subject prefix
	 * @param false|int $basedate   basedate of the occurrence to forward
	 */
	public function forwardMeetingRequest(array $recipients, string $prefix = 'FW: ', false|int $basedate = false): void {
		$organizer = $this->getMeetingOrganizer();
		[$exception, $occurrence] = $this->getForwardOccurrence($basedate);

		$new = $this->createOutgoingMessage();
		$exclude = [
			PR_ENTRYID,
			PR_PARENT_ENTRYID,
			PR_STORE_ENTRYID,
			PR_MESSAGE_FLAGS,
			PR_MESSAGE_RECIPIENTS,
			PR_MESSAGE_DELIVERY_TIME,
			PR_SENTMAIL_ENTRYID,
			PR_ICON_INDEX,
			PR_PROCESSED,
			PR_INTERNET_MESSAGE_ID,
			PR_TRANSPORT_MESSAGE_HEADERS,
			PR_SENDER_ENTRYID,
			PR_SENDER_NAME,
			PR_SENDER_EMAIL_ADDRESS,
			PR_SENDER_ADDRTYPE,
			PR_SENDER_SEARCH_KEY,
			PR_SENDER_SMTP_ADDRESS,
			PR_SENT_REPRESENTING_ENTRYID,
			PR_SENT_REPRESENTING_NAME,
			PR_SENT_REPRESENTING_EMAIL_ADDRESS,
			PR_SENT_REPRESENTING_ADDRTYPE,
			PR_SENT_REPRESENTING_SEARCH_KEY,
			PR_SENT_REPRESENTING_SMTP_ADDRESS,
			PR_RECEIVED_BY_ENTRYID,
			PR_RECEIVED_BY_NAME,
			PR_RECEIVED_BY_EMAIL_ADDRESS,
			PR_RECEIVED_BY_ADDRTYPE,
			PR_RECEIVED_BY_SEARCH_KEY,
			PR_RCVD_REPRESENTING_ENTRYID,
			PR_RCVD_REPRESENTING_NAME,
			PR_RCVD_REPRESENTING_EMAIL_ADDRESS,
			PR_RCVD_REPRESENTING_ADDRTYPE,
			PR_RCVD_REPRESENTING_SEARCH_KEY,
		];
		// an occurrence takes the attachments of its exception, not the exceptions of the series
		mapi_copyto($this->message, [], !empty($occurrence) ? array_merge($exclude, [PR_MESSAGE_ATTACHMENTS]) : $exclude, $new);
		if ($exception !== false) {
			mapi_copyto($exception, [], $exclude, $new);
		}

		$messageprops = mapi_getprops($new, [
			PR_SUBJECT,
			$this->proptags['startdate'],
			$this->proptags['duedate'],
			$this->proptags['busystatus'],
			$this->proptags['intendedbusystatus'],
			$this->proptags['auxiliary_flags'],
		]);
		$messageprops = $occurrence + $messageprops;
		$intendedBusyStatus = $messageprops[$this->proptags['intendedbusystatus']] ?? $messageprops[$this->proptags['busystatus']] ?? fbBusy;

		$props = $occurrence;
		$props[PR_MESSAGE_CLASS] = 'IPM.Schedule.Meeting.Request';
		$props[PR_SUBJECT] = $prefix . ($messageprops[PR_SUBJECT] ?? '');
		$props[PR_RESPONSE_REQUESTED] = true;
		$props[$this->proptags['auxiliary_flags']] = ($messageprops[$this->proptags['auxiliary_flags']] ?? 0) | auxApptFlagForwarded;
		$props[$this->proptags['attendee_critical_change']] = time();
		$props[$this->proptags['responsestatus']] = olResponseNotResponded;
		$props[$this->proptags['meetingstatus']] = olMeetingReceived;
		$props[$this->proptags['intendedbusystatus']] = $intendedBusyStatus;
		$props[$this->proptags['busystatus']] = $intendedBusyStatus === fbFree ? fbFree : fbTentative;
		$props[$this->proptags['toattendeesstring']] = '';
		$props[$this->proptags['ccattendeesstring']] = '';
		$props[$this->proptags['allattendeesstring']] = '';
		$props[PR_START_DATE] = $messageprops[$this->proptags['startdate']] ?? null;
		$props[PR_END_DATE] = $messageprops[$this->proptags['duedate']] ?? null;
		if ($organizer !== false) {
			$props[PR_SENT_REPRESENTING_ENTRYID] = $organizer[PR_ENTRYID];
			$props[PR_SENT_REPRESENTING_NAME] = $organizer[PR_DISPLAY_NAME];
			$props[PR_SENT_REPRESENTING_EMAIL_ADDRESS] = $organizer[PR_EMAIL_ADDRESS];
			$props[PR_SENT_REPRESENTING_ADDRTYPE] = $organizer[PR_ADDRTYPE];
			$props[PR_SENT_REPRESENTING_SEARCH_KEY] = $organizer[PR_SEARCH_KEY];
			$props[PR_SENT_REPRESENTING_SMTP_ADDRESS] = $organizer[PR_SMTP_ADDRESS];
		}
		// the forwarder's note, as set with setMeetingTimeInfo()
		$meetingTimeInfo = $this->getMeetingTimeInfo();
		if ($meetingTimeInfo) {
			$props[$this->mti_html ? PR_HTML : PR_BODY] = $meetingTimeInfo;
		}
		mapi_setprops($new, array_filter($props, static fn ($value) => $value !== null));

		$deleteProps = [
			$this->proptags['counter_proposal'],
			$this->proptags['requestsent'],
			$this->proptags['replytime'],
			$this->proptags['apptreplyname'],
			$this->proptags['categories'],
		];
		if (!empty($occurrence)) {
			$deleteProps[] = $this->proptags['recurrence_data'];
			$deleteProps[] = $this->proptags['recurring_pattern'];
		}
		mapi_deleteprops($new, $deleteProps);

		mapi_message_modifyrecipients($new, MODRECIP_ADD, $recipients);
		mapi_savechanges($new);

		// an older zcore refuses the organizer's name; the notification still tells the organizer
		$this->submitOutgoingMessage($new, $organizer !== false);

		$this->sendMeetingForwardNotification($recipients, $basedate);
	}

	/**
	 * Sends a meeting forward notification to the organizer, telling whom the meeting was
	 * forwarded to (MS-OXOCAL v22.1 §3.1.4.10.1). Nothing is sent when the organizer is not a local
	 * user or is the acting user.
	 *
	 * @param array     $recipients recipient rows of the attendees the meeting was forwarded to
	 * @param false|int $basedate   basedate of the forwarded occurrence
	 */
	public function sendMeetingForwardNotification(array $recipients, false|int $basedate = false): void {
		$organizer = $this->getMeetingOrganizer();
		$organizer = $organizer !== false ? $this->resolveAddress($organizer[PR_SMTP_ADDRESS]) : false;
		if ($organizer === false) {
			return;
		}

		$userDetails = $this->getOwnerAddress($this->openDefaultStore());
		if ($userDetails === false || $this->compareABEntryIDs($organizer[PR_ENTRYID], $userDetails[3])) {
			return;
		}

		[$addresses, $names, $forwardedTo] = $this->getForwardedAddresses($recipients);
		if (empty($addresses)) {
			return;
		}

		[, $occurrence] = $this->getForwardOccurrence($basedate);
		$messageprops = $occurrence + mapi_getprops($this->message, [
			PR_SUBJECT,
			PR_OWNER_APPT_ID,
			$this->proptags['goid'],
			$this->proptags['goid2'],
			$this->proptags['startdate'],
			$this->proptags['duedate'],
			$this->proptags['location'],
			$this->proptags['timezone'],
			$this->proptags['timezone_data'],
			$this->proptags['tzdefstart'],
		]);
		$body = $this->getForwardNotificationBody($messageprops, $userDetails[0], $forwardedTo);
		$props = $this->getForwardNotificationProperties($messageprops, $body, $addresses, $names);

		$new = $this->createOutgoingMessage();
		mapi_setprops($new, $props);
		mapi_message_modifyrecipients($new, MODRECIP_ADD, [[
			PR_ENTRYID => $organizer[PR_ENTRYID],
			PR_DISPLAY_NAME => $organizer[PR_DISPLAY_NAME] ?? '',
			PR_EMAIL_ADDRESS => $organizer[PR_EMAIL_ADDRESS] ?? '',
			PR_ADDRTYPE => $organizer[PR_ADDRTYPE] ?? 'SMTP',
			PR_SEARCH_KEY => $organizer[PR_SEARCH_KEY] ?? '',
			PR_RECIPIENT_TYPE => MAPI_TO,
		]]);
		mapi_savechanges($new);
		mapi_message_submitmessage($new);
	}

	/**
	 * The attendees a meeting was forwarded to, as a forward notification lists them.
	 *
	 * @param array $recipients recipient rows of the attendees the meeting was forwarded to
	 *
	 * @return array their SMTP addresses, their names, and how the body shows them
	 */
	private function getForwardedAddresses(array $recipients): array {
		$addresses = $names = $forwardedTo = [];
		foreach ($recipients as $recip) {
			$smtp = $this->getRecipientSMTPAddress($recip);
			// Bcc recipients stay hidden from the organizer
			if ($smtp === '' || ($recip[PR_RECIPIENT_TYPE] ?? MAPI_TO) == MAPI_BCC) {
				continue;
			}
			$name = $recip[PR_DISPLAY_NAME] ?? '';
			$addresses[] = $smtp;
			$names[] = $name !== '' ? $name : $smtp;
			$forwardedTo[] = $name !== '' && strcasecmp($name, $smtp) != 0 ? $name . ' <' . $smtp . '>' : $smtp;
		}

		return [$addresses, $names, $forwardedTo];
	}

	/**
	 * The text of a meeting forward notification: who forwarded which meeting to whom.
	 *
	 * @param array $messageprops properties of the forwarded meeting or occurrence
	 * @param mixed $forwarder    name of the user who forwarded the meeting
	 * @param array $forwardedTo  the attendees as getForwardedAddresses() shows them
	 */
	private function getForwardNotificationBody(array $messageprops, mixed $forwarder, array $forwardedTo): string {
		$subject = $messageprops[PR_SUBJECT] ?? '';
		$location = $messageprops[$this->proptags['location']] ?? '';

		$body = sprintf(_('%s has forwarded your meeting request to additional recipients.'), $forwarder) . "\n\n";
		$body .= _('Meeting') . ': ' . $subject . "\n";
		if (isset($messageprops[$this->proptags['startdate']], $messageprops[$this->proptags['duedate']])) {
			[$tz, $zone] = $this->getMeetingTimezone($messageprops);
			$body .= _('When') . ': ' . $this->formatMeetingTime($messageprops[$this->proptags['startdate']], $messageprops[$this->proptags['duedate']], $tz, $zone) . "\n";
		}
		if ($location !== '') {
			$body .= _('Location') . ': ' . $location . "\n";
		}

		return $body . _('Recipients') . ': ' . implode(', ', $forwardedTo) . "\n";
	}

	/**
	 * The properties of a meeting forward notification, with those of the forwarded
	 * meeting or occurrence that it has.
	 *
	 * @param array  $messageprops properties of the forwarded meeting or occurrence
	 * @param string $body         text of the notification
	 * @param array  $addresses    SMTP addresses of the attendees the meeting was forwarded to
	 * @param array  $names        their names
	 */
	private function getForwardNotificationProperties(array $messageprops, string $body, array $addresses, array $names): array {
		$subject = $messageprops[PR_SUBJECT] ?? '';
		$location = $messageprops[$this->proptags['location']] ?? '';

		$props = [
			PR_MESSAGE_CLASS => 'IPM.Schedule.Meeting.Notification.Forward',
			PR_SUBJECT => _('Meeting Forward Notification') . ': ' . $subject,
			PR_BODY => $body,
			$this->proptags['forward_notification_recipients'] => packForwardNotificationRecipients($addresses, $names),
			$this->proptags['attendee_critical_change'] => time(),
		];
		if (isset($messageprops[$this->proptags['goid']])) {
			$props[$this->proptags['goid']] = $messageprops[$this->proptags['goid']];
		}
		if (isset($messageprops[$this->proptags['goid2']])) {
			$props[$this->proptags['goid2']] = $messageprops[$this->proptags['goid2']];
		}
		if (isset($messageprops[PR_OWNER_APPT_ID])) {
			$props[PR_OWNER_APPT_ID] = $messageprops[PR_OWNER_APPT_ID];
		}
		if (isset($messageprops[$this->proptags['startdate']], $messageprops[$this->proptags['duedate']])) {
			$props[$this->proptags['startdate']] = $props[PR_START_DATE] = $messageprops[$this->proptags['startdate']];
			$props[$this->proptags['duedate']] = $props[PR_END_DATE] = $messageprops[$this->proptags['duedate']];
		}
		if ($location !== '') {
			$props[$this->proptags['location']] = $location;
		}

		return $props;
	}

	/**
	 * Returns TRUE if we are the organiser of the meeting. Can be used with any type of meeting object.
	 */
	public function isLocalOrganiser(): bool {
		$props = mapi_getprops($this->message, [$this->proptags['goid'], PR_MESSAGE_CLASS]);

		// Determine which item to check based on message class
		$messageClass = $props[PR_MESSAGE_CLASS] ?? '';
		$isMeetingMessage = $this->isMeetingRequest($messageClass) ||
							$this->isMeetingRequestResponse($messageClass) ||
							$this->isMeetingCancellation($messageClass) ||
							$this->isMeetingForwardNotification($messageClass);

		$calendarItem = $isMeetingMessage ?
			$this->getCorrespondentCalendarItem(true) : // Meeting request/response/cancellation/forward notification mail
			$this->message;  // Calendar item

		// Even if we have received request/response for exception/occurrence then also
		// we can check recurring series for organizer, no need to check with exception/occurrence
		if ($calendarItem === false) {
			return false;
		}

		$messageProps = mapi_getprops($calendarItem, [$this->proptags['responsestatus']]);

		return isset($messageProps[$this->proptags['responsestatus']]) &&
			   $messageProps[$this->proptags['responsestatus']] === olResponseOrganized;
	}

	/*
	 * Support functions - INTERNAL ONLY
	 ***************************************************************************************************
	 */

	/**
	 * Return the tracking status of a recipient based on the IPM class (passed).
	 *
	 * @return int tracking status constant
	 */
	public function getTrackStatus(string $class): int {
		return match ($class) {
			'IPM.Schedule.Meeting.Resp.Pos' => olRecipientTrackStatusAccepted,
			'IPM.Schedule.Meeting.Resp.Tent' => olRecipientTrackStatusTentative,
			'IPM.Schedule.Meeting.Resp.Neg' => olRecipientTrackStatusDeclined,
			default => olRecipientTrackStatusNone,
		};
	}

	/**
	 * Function returns MAPIFolder resource of the folder that currently holds this meeting/meeting request
	 * object.
	 */
	public function openParentFolder(): mixed {
		$messageprops = mapi_getprops($this->message, [PR_PARENT_ENTRYID]);

		return mapi_msgstore_openentry($this->store, $messageprops[PR_PARENT_ENTRYID]);
	}

	/**
	 * Function will return resource of the default calendar folder of store.
	 *
	 * @param mixed $store {optional} user store whose default calendar should be opened
	 *
	 * @return resource default calendar folder of store
	 */
	public function openDefaultCalendar(mixed $store = false): mixed {
		return $this->openDefaultFolder(PR_IPM_APPOINTMENT_ENTRYID, $store);
	}

	/**
	 * Function will return resource of the default outbox folder of store.
	 *
	 * @param mixed $store {optional} user store whose default outbox should be opened
	 *
	 * @return resource default outbox folder of store
	 */
	public function openDefaultOutbox(mixed $store = false): mixed {
		return $this->openBaseFolder(PR_IPM_OUTBOX_ENTRYID, $store);
	}

	/**
	 * Function will return resource of the default wastebasket folder of store.
	 *
	 * @param mixed $store {optional} user store whose default wastebasket should be opened
	 *
	 * @return resource default wastebasket folder of store
	 */
	public function openDefaultWastebasket(mixed $store = false): mixed {
		return $this->openBaseFolder(PR_IPM_WASTEBASKET_ENTRYID, $store);
	}

	/**
	 * Function will return resource of the default calendar folder of store.
	 *
	 * @param mixed $store {optional} user store whose default calendar should be opened
	 *
	 * @return false|string default calendar folder of store
	 */
	public function getDefaultWastebasketEntryID(mixed $store = false): bool|string {
		$entryid = $this->getBaseEntryID(PR_IPM_WASTEBASKET_ENTRYID, $store);

		return is_string($entryid) ? $entryid : false;
	}

	/**
	 * Function will return resource of the default sent mail folder of store.
	 *
	 * @param mixed $store {optional} user store whose default sent mail should be opened
	 *
	 * @return false|string default sent mail folder of store
	 */
	public function getDefaultSentmailEntryID(mixed $store = false): bool|string {
		$entryid = $this->getBaseEntryID(PR_IPM_SENTMAIL_ENTRYID, $store);

		return is_string($entryid) ? $entryid : false;
	}

	/**
	 * Function will return entryid of any default folder of store. The default folder
	 * entryids (PR_IPM_APPOINTMENT_ENTRYID, PR_IPM_CONTACT_ENTRYID, ...) are read from
	 * the store root folder, which is accessible even when the inbox is not.
	 * PR_ENTRYID returns the entryid of the inbox itself.
	 *
	 * @param int   $prop  proptag of the folder for which we want to get entryid
	 * @param mixed $store {optional} user store from which we need to get entryid of default folder
	 *
	 * @return false|string entryid of folder pointed by $prop
	 */
	public function getDefaultFolderEntryID(int $prop, mixed $store = false): bool|string {
		try {
			$entry = $prop === PR_ENTRYID ?
				mapi_msgstore_getreceivefolder($store ?: $this->store) :
				mapi_msgstore_openentry($store ?: $this->store);
			$entryprops = mapi_getprops($entry, [$prop]);

			$entryid = $entryprops[$prop] ?? false;

			return is_string($entryid) ? $entryid : false;
		}
		catch (MAPIException $e) {
			// public store doesn't support this method
			if ($e->getCode() == MAPI_E_NO_SUPPORT) {
				// don't propagate this error to parent handlers, if store doesn't support it
				$e->setHandled();

				return false;
			}
		}

		return false;
	}

	/**
	 * Function will return resource of any default folder of store.
	 *
	 * @param int   $prop  proptag of the folder that we want to open
	 * @param mixed $store {optional} user store from which we need to open default folder
	 *
	 * @return false|resource default folder of store
	 */
	public function openDefaultFolder(int $prop, mixed $store = false): mixed {
		$entryid = $this->getDefaultFolderEntryID($prop, $store);
		if (!is_string($entryid)) {
			return false;
		}

		try {
			return mapi_msgstore_openentry($store ?: $this->store, $entryid);
		}
		catch (MAPIException $e) {
			// gromox reports a folder the user has no rights on as not found
			if ($e->getCode() == MAPI_E_NO_ACCESS || $e->getCode() == MAPI_E_NOT_FOUND) {
				$e->setHandled();

				return false;
			}

			throw $e;
		}
	}

	/**
	 * Function will return entryid of default folder from store. This method is useful when you want
	 * to get entryid of folder which is stored as store properties
	 * (PR_IPM_FAVORITES_ENTRYID, PR_IPM_OUTBOX_ENTRYID, PR_IPM_SENTMAIL_ENTRYID, PR_IPM_WASTEBASKET_ENTRYID).
	 *
	 * @param int   $prop  proptag of the folder whose entryid we want to get
	 * @param mixed $store {optional} user store from which we need to get entryid of default folder
	 *
	 * @return false|string entryid of default folder from store
	 */
	public function getBaseEntryID(int $prop, mixed $store = false): bool|string {
		$storeprops = mapi_getprops($store ?: $this->store, [$prop]);
		$entryid = $storeprops[$prop] ?? false;

		return is_string($entryid) ? $entryid : false;
	}

	/**
	 * Function will return resource of any default folder of store.
	 *
	 * @param int   $prop  proptag of the folder that we want to open
	 * @param mixed $store {optional} user store from which we need to open default folder
	 *
	 * @return false|resource default folder of store
	 */
	public function openBaseFolder(int $prop, mixed $store = false): mixed {
		$entryid = $this->getBaseEntryID($prop, $store);

		return is_string($entryid) ?
			mapi_msgstore_openentry($store ?: $this->store, $entryid) : false;
	}

	/**
	 * Function checks whether user has access over the specified folder or not.
	 *
	 * @param string $entryid entryid The entryid of the folder to check
	 * @param mixed  $store   (optional) store from which folder should be opened
	 *
	 * @return bool true if user has an access over the folder, false if not
	 */
	public function checkFolderWriteAccess(string $entryid, mixed $store = false): bool {
		if (empty($entryid)) {
			return false;
		}

		$store = $store ?: $this->store;

		try {
			$folder = mapi_msgstore_openentry($store, $entryid);
			$folderProps = mapi_getprops($folder, [PR_ACCESS]);

			return ($folderProps[PR_ACCESS] & MAPI_ACCESS_CREATE_CONTENTS) === MAPI_ACCESS_CREATE_CONTENTS;
		}
		catch (MAPIException $e) {
			// no rights to open the folder; gromox reports this as not found
			if ($e->getCode() == MAPI_E_NO_ACCESS || $e->getCode() == MAPI_E_NOT_FOUND) {
				return false;
			}

			// Rethrow other errors
			throw $e;
		}
	}

	/**
	 * Function checks whether user has access over the specified folder or not.
	 *
	 * @return bool true if user has an access over the folder, false if not
	 */
	public function checkCalendarWriteAccess(mixed $store = false): bool {
		if ($store === false) {
			$messageProps = mapi_getprops($this->message, [PR_RCVD_REPRESENTING_ENTRYID]);
			$store = $this->store;
			// If this meeting request is received by a delegate then open delegator's store.
			if (isset($messageProps[PR_RCVD_REPRESENTING_ENTRYID])) {
				$delegatorStore = $this->getDelegatorStore($messageProps[PR_RCVD_REPRESENTING_ENTRYID]);
				if (!empty($delegatorStore['store'])) {
					$store = $delegatorStore['store'];
				}
			}
		}

		// If the store is a public folder, the calendar folder is the PARENT_ENTRYID of the calendar item
		$provider = mapi_getprops($store, [PR_MDB_PROVIDER]);
		if (isset($provider[PR_MDB_PROVIDER]) && $provider[PR_MDB_PROVIDER] === ZARAFA_STORE_PUBLIC_GUID) {
			$entryid = mapi_getprops($this->message, [PR_PARENT_ENTRYID]);
			$entryid = $entryid[PR_PARENT_ENTRYID];
		}
		else {
			$entryid = $this->getDefaultFolderEntryID(PR_IPM_APPOINTMENT_ENTRYID, $store);
			if ($entryid === false) {
				$entryid = $this->getBaseEntryID(PR_IPM_APPOINTMENT_ENTRYID, $store);
			}

			if ($entryid === false) {
				return false;
			}
		}

		return $this->checkFolderWriteAccess($entryid, $store);
	}

	/**
	 * Function will resolve the user and open its store.
	 *
	 * @param string $ownerentryid the entryid of the user
	 *
	 * @return mixed store of the user, null if the user cannot be resolved
	 */
	public function openCustomUserStore(string $ownerentryid): mixed {
		$ab = $this->openAddressBook();

		try {
			$mailuser = mapi_ab_openentry($ab, $ownerentryid);
			if (!$mailuser) {
				error_log(sprintf("Unable to open ab entry: 0x%08X", mapi_last_hresult()));

				return null;
			}
		}
		catch (MAPIException) {
			return null;
		}

		$mailuserprops = mapi_getprops($mailuser, [PR_EMAIL_ADDRESS]);
		$storeid = mapi_msgstore_createentryid($this->store, $mailuserprops[PR_EMAIL_ADDRESS]);

		return mapi_openmsgstore($this->session, $storeid);
	}

	/**
	 * Function which sends response to organizer when attendee accepts, declines or proposes new time to a received meeting request.
	 *
	 * @param int       $status              response status of attendee
	 * @param array     $proposeNewTimeProps properties of attendee's proposal
	 * @param mixed     $body
	 * @param mixed     $store
	 * @param false|int $basedate            date of occurrence which attendee has responded
	 * @param mixed     $calFolder
	 * @param bool      $defer               hand the saved response back instead of sending it
	 *
	 * @return mixed the unsent response when deferred, null otherwise
	 */
	public function createResponse($status, $proposeNewTimeProps, $body, $store, $basedate, $calFolder, bool $defer = false): mixed {
		$messageprops = mapi_getprops($this->message, [
			PR_SENT_REPRESENTING_ENTRYID,
			PR_SENT_REPRESENTING_EMAIL_ADDRESS,
			PR_SENT_REPRESENTING_ADDRTYPE,
			PR_SENT_REPRESENTING_NAME,
			PR_SENT_REPRESENTING_SEARCH_KEY,
			$this->proptags['goid'],
			$this->proptags['goid2'],
			$this->proptags['location'],
			$this->proptags['startdate'],
			$this->proptags['duedate'],
			$this->proptags['alldayevent'],
			$this->proptags['recurring'],
			$this->proptags['recurring_pattern'],
			$this->proptags['recurrence_data'],
			$this->proptags['timezone_data'],
			$this->proptags['timezone'],
			$this->proptags['updatecounter'],
			PR_SUBJECT,
			PR_MESSAGE_CLASS,
			PR_OWNER_APPT_ID,
			$this->proptags['is_exception'],
		]);

		$props = [];
		$this->setResponseRecurrenceProperties($store, $basedate, $calFolder, $messageprops, $props);

		// Create a response message
		$recip = $this->getOrganizerRecipient($messageprops);
		$this->setResponseSubjectAndClass($props, $status, $proposeNewTimeProps, $messageprops);
		$this->setResponseMeetingProperties($props, $proposeNewTimeProps, $body, $basedate, $messageprops);

		$message = $this->createOutgoingMessage($store);

		mapi_setprops($message, $props);
		mapi_message_modifyrecipients($message, MODRECIP_ADD, [$recip]);
		mapi_savechanges($message);
		if ($defer) {
			return $message;
		}
		mapi_message_submitmessage($message);

		return null;
	}

	/**
	 * Sets the properties that say which meeting the response answers for: the occurrence of
	 * a recurring calendar item, or the request with the recurrence of its series.
	 *
	 * @param mixed $store        store of the calendar
	 * @param mixed $basedate     date of the occurrence which the attendee has responded, else false
	 * @param mixed $calFolder    calendar folder
	 * @param array $messageprops properties of the message, timed like the occurrence afterwards
	 * @param array $props        properties of the response
	 */
	private function setResponseRecurrenceProperties(mixed $store, mixed $basedate, mixed $calFolder, array &$messageprops, array &$props): void {
		if ($basedate !== false && !$this->isMeetingRequest($messageprops[PR_MESSAGE_CLASS])) {
			// we are creating response from a recurring calendar item object
			// We found basedate,so opened occurrence and get properties.
			$recurr = new Recurrence($store, $this->message);
			$this->copyOccurrenceToResponse($recurr, $basedate, $messageprops, $props);
		}
		else {
			// we are creating a response from meeting request mail (it could be recurring or non-recurring)
			// Send all recurrence info in response, if this is a recurrence meeting.
			$recurr = $this->getRequestRecurrence($store, $calFolder, $messageprops, $props);
		}

		// we are sending a response for recurring meeting request (or exception), so set some required properties
		if ($recurr !== null) {
			$this->copyRecurrenceToResponse($recurr, $messageprops, $props);
		}
	}

	/**
	 * Takes the times, the location and the status of the occurrence a calendar item answers
	 * for into the response, which is for that occurrence alone.
	 *
	 * @param Recurrence $recurr       recurrence of the calendar item
	 * @param mixed      $basedate     date of the occurrence
	 * @param array      $messageprops properties of the message, timed like the occurrence afterwards
	 * @param array      $props        properties of the response
	 */
	private function copyOccurrenceToResponse(Recurrence $recurr, mixed $basedate, array &$messageprops, array &$props): void {
		$exception = $recurr->getExceptionAttachment($basedate);

		if ($exception) {
			// Exception found, Now retrieve properties
			$imessage = mapi_attach_openobj($exception, 0);
			$imsgprops = mapi_getprops($imessage);

			// If location is provided, copy it to the response
			if (isset($imsgprops[$this->proptags['location']])) {
				$messageprops[$this->proptags['location']] = $imsgprops[$this->proptags['location']];
			}

			// Update $messageprops with timings of occurrence
			$messageprops[$this->proptags['startdate']] = $imsgprops[$this->proptags['startdate']];
			$messageprops[$this->proptags['duedate']] = $imsgprops[$this->proptags['duedate']];
			if (isset($imsgprops[$this->proptags['alldayevent']])) {
				$messageprops[$this->proptags['alldayevent']] = $imsgprops[$this->proptags['alldayevent']];
			}

			// Meeting related properties
			$props[$this->proptags['meetingstatus']] = $imsgprops[$this->proptags['meetingstatus']];
			$props[$this->proptags['responsestatus']] = $imsgprops[$this->proptags['responsestatus']];
			$props[PR_SUBJECT] = $imsgprops[PR_SUBJECT];
		}
		else {
			// Exceptions is deleted.
			// Update $messageprops with timings of occurrence
			$messageprops[$this->proptags['startdate']] = $recurr->getOccurrenceStart($basedate);
			$messageprops[$this->proptags['duedate']] = $recurr->getOccurrenceEnd($basedate);

			$props[$this->proptags['meetingstatus']] = olNonMeeting;
			$props[$this->proptags['responsestatus']] = olResponseNone;
		}

		$props[$this->proptags['recurring']] = false;
		$props[$this->proptags['is_exception']] = true;
	}

	/**
	 * The recurrence a response to a recurring request or to an exception carries, null for
	 * a single meeting. The response is flagged as recurring or as exception like the request.
	 *
	 * @param mixed $store        store of the calendar
	 * @param mixed $calFolder    calendar folder
	 * @param array $messageprops properties of the request
	 * @param array $props        properties of the response
	 */
	private function getRequestRecurrence(mixed $store, mixed $calFolder, array $messageprops, array &$props): ?Recurrence {
		$isRecurring = !empty($messageprops[$this->proptags['recurring']]);
		$isException = !empty($messageprops[$this->proptags['is_exception']]);
		if (!$isRecurring && !$isException) {
			return null;
		}
		if ($isRecurring) {
			$props[$this->proptags['recurring']] = $messageprops[$this->proptags['recurring']];
		}
		if ($isException) {
			$props[$this->proptags['is_exception']] = $messageprops[$this->proptags['is_exception']];
		}
		// The series may be gone from the calendar (or not be there yet),
		// the request carries the recurrence then.
		$calendaritems = $this->findCalendarItems($messageprops[$this->proptags['goid2']], $calFolder);

		return !empty($calendaritems) ?
			new Recurrence($store, mapi_msgstore_openentry($store, $calendaritems[0])) :
			new Recurrence($store, $this->message);
	}

	/**
	 * Sends the recurrence of the series along in the response.
	 *
	 * @param Recurrence $recurr       recurrence of the series
	 * @param array      $messageprops properties of the message
	 * @param array      $props        properties of the response
	 */
	private function copyRecurrenceToResponse(Recurrence $recurr, array $messageprops, array &$props): void {
		if (!empty($messageprops[$this->proptags['recurring_pattern']])) {
			$props[$this->proptags['recurring_pattern']] = $messageprops[$this->proptags['recurring_pattern']];
		}

		if (!empty($messageprops[$this->proptags['recurrence_data']])) {
			$props[$this->proptags['recurrence_data']] = $messageprops[$this->proptags['recurrence_data']];
		}

		$props[$this->proptags['timezone_data']] = $messageprops[$this->proptags['timezone_data']];
		$props[$this->proptags['timezone']] = $messageprops[$this->proptags['timezone']];

		$this->generateRecurDates($recurr, $messageprops, $props);
	}

	/**
	 * The organizer of the meeting as the recipient of the response.
	 */
	private function getOrganizerRecipient(array $messageprops): array {
		$recip = [];
		$recip[PR_ENTRYID] = $messageprops[PR_SENT_REPRESENTING_ENTRYID];
		$recip[PR_EMAIL_ADDRESS] = $messageprops[PR_SENT_REPRESENTING_EMAIL_ADDRESS];
		$recip[PR_ADDRTYPE] = $messageprops[PR_SENT_REPRESENTING_ADDRTYPE];
		$recip[PR_DISPLAY_NAME] = $messageprops[PR_SENT_REPRESENTING_NAME];
		$recip[PR_RECIPIENT_TYPE] = MAPI_TO;
		$recip[PR_SEARCH_KEY] = $messageprops[PR_SENT_REPRESENTING_SEARCH_KEY];

		return $recip;
	}

	/**
	 * The subject and the message class of the response say how the attendee answered.
	 *
	 * @param array $props               properties of the response
	 * @param mixed $status              response status of attendee
	 * @param mixed $proposeNewTimeProps properties of attendee's proposal
	 * @param array $messageprops        properties of the message
	 */
	private function setResponseSubjectAndClass(array &$props, mixed $status, mixed $proposeNewTimeProps, array $messageprops): void {
		$subjectprefix = '';
		$classpostfix = '';

		switch ($status) {
			case olResponseAccepted:
				$classpostfix = 'Pos';
				$subjectprefix = _('Accepted');
				break;

			case olResponseDeclined:
				$classpostfix = 'Neg';
				$subjectprefix = _('Declined');
				break;

			case olResponseTentative:
				$classpostfix = 'Tent';
				$subjectprefix = _('Tentatively accepted');
				break;
		}

		if (!empty($proposeNewTimeProps)) {
			// if attendee has proposed new time then change subject prefix
			$subjectprefix = _('New Time Proposed');
		}

		$props[PR_SUBJECT] = $subjectprefix . ': ' . $messageprops[PR_SUBJECT];

		$props[PR_MESSAGE_CLASS] = 'IPM.Schedule.Meeting.Resp.' . $classpostfix;
	}

	/**
	 * Sets which meeting the response is about, when it was given, what the attendee proposes
	 * and says, and the time and place of the meeting.
	 *
	 * @param array $props               properties of the response
	 * @param mixed $proposeNewTimeProps properties of attendee's proposal
	 * @param mixed $body                text of the response
	 * @param mixed $basedate            date of the occurrence which the attendee has responded, else false
	 * @param array $messageprops        properties of the message
	 */
	private function setResponseMeetingProperties(array &$props, mixed $proposeNewTimeProps, mixed $body, mixed $basedate, array $messageprops): void {
		if (isset($messageprops[PR_OWNER_APPT_ID])) {
			$props[PR_OWNER_APPT_ID] = $messageprops[PR_OWNER_APPT_ID];
		}

		// Set GlobalId AND CleanGlobalId, if exception then also set basedate into GlobalId(0x3).
		// $basedate is the local day of the occurrence already (from the client or
		// from the GlobalId of the request), so it must not be converted from UTC.
		$props[$this->proptags['goid']] = $this->setBasedateInGlobalID($messageprops[$this->proptags['goid2']], $basedate);
		$props[$this->proptags['goid2']] = $messageprops[$this->proptags['goid2']];
		$props[$this->proptags['updatecounter']] = $messageprops[$this->proptags['updatecounter']] ?? 0;
		// When the answer was given. The organizer orders responses by it, and it
		// is what the outgoing iCal REPLY carries as its DTSTAMP.
		$props[$this->proptags['attendee_critical_change']] = time();

		if (!empty($proposeNewTimeProps)) {
			// merge proposal properties to message properties which will be sent to organizer
			$props = $proposeNewTimeProps + $props;
		}

		// Set body message in Appointment
		$meetingTimeInfo = $this->getMeetingTimeInfo();
		if ($meetingTimeInfo) {
			if ($this->mti_html) {
				$props[PR_HTML] = $meetingTimeInfo;
			} else {
				$props[PR_BODY] = $meetingTimeInfo;
			}
		} elseif (isset($body)) {
			$props[PR_BODY] = $body;
		}

		// PR_START_DATE/PR_END_DATE is used in the UI in Outlook on the response message
		$props[PR_START_DATE] = $messageprops[$this->proptags['startdate']];
		$props[PR_END_DATE] = $messageprops[$this->proptags['duedate']];

		// Set startdate and duedate in response mail.
		$props[$this->proptags['startdate']] = $messageprops[$this->proptags['startdate']];
		$props[$this->proptags['duedate']] = $messageprops[$this->proptags['duedate']];
		// Without it the iCal reply of an all-day meeting is a timed one
		if (isset($messageprops[$this->proptags['alldayevent']])) {
			$props[$this->proptags['alldayevent']] = $messageprops[$this->proptags['alldayevent']];
		}

		// responselocation is used in the UI in Outlook on the response message
		if (isset($messageprops[$this->proptags['location']])) {
			$props[$this->proptags['responselocation']] = $messageprops[$this->proptags['location']];
			$props[$this->proptags['location']] = $messageprops[$this->proptags['location']];
		}
	}

	/**
	 * Function which finds items in calendar based on globalId and cleanGlobalId.
	 *
	 * @param string $goid             GlobalID(0x3) of item
	 * @param mixed  $calendar         MAPI_folder of user (optional)
	 * @param bool   $useCleanGlobalId if true then search should be performed on cleanGlobalId(0x23) else globalId(0x3)
	 *
	 * @return array|null
	 */
	public function findCalendarItems(string $goid, mixed $calendar = false, bool $useCleanGlobalId = false): ?array {
		if ($calendar === false) {
			// Open the Calendar
			$calendar = $this->openDefaultCalendar();
			if ($calendar === false) {
				// no access to the calendar folder
				return null;
			}
		}

		// Find the item by restricting all items to the correct ID
		$restrict = [
			RES_PROPERTY,
			[
				RELOP => RELOP_EQ,
				ULPROPTAG => ($useCleanGlobalId === true ? $this->proptags['goid2'] : $this->proptags['goid']),
				VALUE => $goid,
			],
		];

		$calendarcontents = mapi_folder_getcontentstable($calendar);

		$rows = mapi_table_queryallrows($calendarcontents, [PR_ENTRYID], $restrict);

		if (empty($rows)) {
			return null;
		}

		// In principle, there should only be one row, but we'll handle them all just in case
		return array_column($rows, PR_ENTRYID);
	}

	// Returns TRUE if both entryid's are equal. Equality is defined by both entryid's pointing at the
	// same SMTP address when converted to SMTP
	public function compareABEntryIDs(string $entryid1, string $entryid2): bool {
		// If the session was not passed, just do a 'normal' compare.
		if (!$this->session) {
			return $entryid1 == $entryid2;
		}

		return $this->getSMTPAddress($entryid1) == $this->getSMTPAddress($entryid2);
	}

	private function openAddressBook(): mixed {
		return $this->addressBook ??= mapi_openaddressbook($this->session);
	}

	// Gets the SMTP address of the passed addressbook entryid
	public function getSMTPAddress(string $entryid): false|string {
		if (!$this->session) {
			return false;
		}
		if (!array_key_exists($entryid, $this->smtpAddresses)) {
			$this->smtpAddresses[$entryid] = $this->lookupSMTPAddress($entryid);
		}

		return $this->smtpAddresses[$entryid];
	}

	private function lookupSMTPAddress(string $entryid): false|string {
		try {
			$ab = $this->openAddressBook();
			$abitem = mapi_ab_openentry($ab, $entryid);

			if (!$abitem) {
				return '';
			}
		}
		catch (MAPIException) {
			return '';
		}

		$props = mapi_getprops($abitem, [PR_ADDRTYPE, PR_EMAIL_ADDRESS, PR_SMTP_ADDRESS]);

		if ($props[PR_ADDRTYPE] == 'SMTP') {
			return $props[PR_EMAIL_ADDRESS];
		}

		return $props[PR_SMTP_ADDRESS];
	}

	// Returns TRUE if both recipient rows denote the same address; rows
	// need not carry PR_ENTRYID
	public function compareRecipients(array $recip1, array $recip2): bool {
		if (isset($recip1[PR_ENTRYID], $recip2[PR_ENTRYID])) {
			return $this->compareABEntryIDs($recip1[PR_ENTRYID], $recip2[PR_ENTRYID]);
		}

		$smtp1 = $this->getRecipientSMTPAddress($recip1);
		$smtp2 = $this->getRecipientSMTPAddress($recip2);
		if ($smtp1 !== '' && $smtp2 !== '') {
			return strcasecmp($smtp1, $smtp2) == 0;
		}

		return !empty($recip1[PR_EMAIL_ADDRESS]) && !empty($recip2[PR_EMAIL_ADDRESS]) &&
			strcasecmp($recip1[PR_ADDRTYPE] ?? '', $recip2[PR_ADDRTYPE] ?? '') == 0 &&
			strcasecmp($recip1[PR_EMAIL_ADDRESS], $recip2[PR_EMAIL_ADDRESS]) == 0;
	}

	private function getRecipientSMTPAddress(array $recip): string {
		if (!empty($recip[PR_SMTP_ADDRESS])) {
			return $recip[PR_SMTP_ADDRESS];
		}
		if (isset($recip[PR_ADDRTYPE], $recip[PR_EMAIL_ADDRESS]) &&
			strcasecmp($recip[PR_ADDRTYPE], 'SMTP') == 0) {
			return $recip[PR_EMAIL_ADDRESS];
		}
		if (isset($recip[PR_ENTRYID])) {
			return (string) $this->getSMTPAddress($recip[PR_ENTRYID]);
		}

		return '';
	}

	/**
	 * Gets the properties associated with the owner of the passed store:
	 * PR_DISPLAY_NAME, PR_EMAIL_ADDRESS, PR_ADDRTYPE, PR_ENTRYID, PR_SEARCH_KEY.
	 *
	 * @param mixed $store                  message store
	 * @param bool  $fallbackToLoggedInUser If true then return properties of logged in user instead of mailbox owner.
	 *                                      Not used when passed store is public store.
	 *                                      For public store we are always returning logged in user's info.
	 *
	 * @return array|false properties of logged in user in an array in sequence of display_name, email address, address type, entryid and search key
	 *
	 * @psalm-return false|list{mixed, mixed, mixed, mixed, mixed}
	 */
	public function getOwnerAddress(mixed $store, bool $fallbackToLoggedInUser = true): array|false {
		if (!$this->session) {
			return false;
		}

		$storeProps = mapi_getprops($store, [PR_MAILBOX_OWNER_ENTRYID, PR_USER_ENTRYID]);

		// Determine owner entry ID: use mailbox owner if not falling back, otherwise use user entry ID
		$ownerEntryId = (!$fallbackToLoggedInUser && !empty($storeProps[PR_MAILBOX_OWNER_ENTRYID])) ?
			$storeProps[PR_MAILBOX_OWNER_ENTRYID] :
			($storeProps[PR_USER_ENTRYID] ?? false);

		if (!$ownerEntryId) {
			return false;
		}

		$ab = $this->openAddressBook();

		$zarafaUser = mapi_ab_openentry($ab, $ownerEntryId);
		if (!$zarafaUser) {
			return false;
		}

		$ownerProps = mapi_getprops($zarafaUser, [PR_ADDRTYPE, PR_DISPLAY_NAME, PR_EMAIL_ADDRESS, PR_SEARCH_KEY]);

		return [
			$ownerProps[PR_DISPLAY_NAME],
			$ownerProps[PR_EMAIL_ADDRESS],
			$ownerProps[PR_ADDRTYPE],
			$ownerEntryId,
			$ownerProps[PR_SEARCH_KEY],
		];
	}

	// Opens this session's default message store
	public function openDefaultStore(): mixed {
		$entryid = '';

		$storestable = mapi_getmsgstorestable($this->session);
		$rows = mapi_table_queryallrows($storestable, [PR_ENTRYID, PR_DEFAULT_STORE]);

		foreach ($rows as $row) {
			if (isset($row[PR_DEFAULT_STORE]) && $row[PR_DEFAULT_STORE]) {
				$entryid = $row[PR_ENTRYID];
				break;
			}
		}

		if (!$entryid) {
			return false;
		}

		return mapi_openmsgstore($this->session, $entryid);
	}

	/**
	 * Function which adds organizer to recipient list which is passed.
	 * This function also checks if it has organizer.
	 *
	 * @param array $messageProps message properties
	 * @param array $recipients   recipients list of message
	 * @param bool  $isException  true if we are processing recipient of exception
	 */
	public function addOrganizer(array $messageProps, array &$recipients, bool $isException = false): void {
		$hasOrganizer = false;
		// Check if meeting already has an organizer.
		foreach ($recipients as $key => $recipient) {
			// gromox also sets recipOriginal on the organizer of a received request
			if (isset($recipient[PR_RECIPIENT_FLAGS]) && ($recipient[PR_RECIPIENT_FLAGS] & recipOrganizer)) {
				$hasOrganizer = true;
			}
			elseif ($isException && !isset($recipient[PR_RECIPIENT_FLAGS])) {
				// Recipients for an occurrence
				$recipients[$key][PR_RECIPIENT_FLAGS] = recipSendable | recipExceptionalResponse;
			}
		}

		if (!$hasOrganizer) {
			// Create organizer.
			$organizer = [];
			$organizer[PR_ENTRYID] = $organizer[PR_RECIPIENT_ENTRYID] = $messageProps[PR_SENT_REPRESENTING_ENTRYID];
			$organizer[PR_DISPLAY_NAME] = $messageProps[PR_SENT_REPRESENTING_NAME];
			$organizer[PR_EMAIL_ADDRESS] = $messageProps[PR_SENT_REPRESENTING_EMAIL_ADDRESS];
			$organizer[PR_RECIPIENT_TYPE] = MAPI_TO;
			$organizer[PR_RECIPIENT_DISPLAY_NAME] = $messageProps[PR_SENT_REPRESENTING_NAME];
			$organizer[PR_ADDRTYPE] = empty($messageProps[PR_SENT_REPRESENTING_ADDRTYPE]) ? 'SMTP' : $messageProps[PR_SENT_REPRESENTING_ADDRTYPE];
			$organizer[PR_RECIPIENT_TRACKSTATUS] = olRecipientTrackStatusNone;
			$organizer[PR_RECIPIENT_FLAGS] = recipSendable | recipOrganizer;
			$organizer[PR_SEARCH_KEY] = $messageProps[PR_SENT_REPRESENTING_SEARCH_KEY];
			$organizer[PR_SMTP_ADDRESS] = $messageProps[PR_SENT_REPRESENTING_SMTP_ADDRESS] ?? $messageProps[PR_SENT_REPRESENTING_EMAIL_ADDRESS];

			// Add organizer to recipients list.
			array_unshift($recipients, $organizer);
		}
	}

	/**
	 * Function which removes an exception/occurrence from recurrencing meeting
	 * when a meeting cancellation of an occurrence is processed.
	 *
	 * @param false|int $basedate basedate of an occurrence
	 * @param mixed     $message  recurring item from which occurrence has to be deleted
	 * @param resource  $store    MAPI_MSG_Store which contains the item
	 */
	public function doRemoveExceptionFromCalendar(mixed $basedate, mixed $message, mixed $store): void {
		$recurr = new Recurrence($store, $message);
		$recurr->createException([], $basedate, true);
		mapi_savechanges($message);
	}

	/**
	 * Function which returns basedate of an changed occurrence from globalID of meeting request.
	 *
	 * @param string $goid globalID
	 *
	 * @return false|int true if basedate is found else false it not found
	 */
	public function getBasedateFromGlobalID(string $goid): false|int {
		$hexguid = bin2hex($goid);
		$hexbase = substr($hexguid, 32, 8);
		$day = (int) hexdec(substr($hexbase, 6, 2));
		$month = (int) hexdec(substr($hexbase, 4, 2));
		$year = (int) hexdec(substr($hexbase, 0, 4));

		return ($day && $month && $year) ? gmmktime(0, 0, 0, $month, $day, $year) : false;
	}

	/**
	 * Function which sets basedate in globalID of changed occurrence which is to be sent.
	 *
	 * @param string              $goid       globalID
	 * @param false|int           $basedate   of changed occurrence: a UTC time on the original
	 *                                        occurrence when $recurrence is provided, else its
	 *                                        local day as a UTC timestamp (a recurrence basedate)
	 * @param null|BaseRecurrence $recurrence recurrence helper for timezone conversion
	 *
	 * @return false|string globalID with basedate in it
	 */
	public function setBasedateInGlobalID(string $goid, false|int $basedate = false, ?BaseRecurrence $recurrence = null): false|string {
		$hexguid = bin2hex($goid);
		$timestamp = $basedate;

		if ($basedate !== false && $recurrence instanceof BaseRecurrence && isset($recurrence->tz)) {
			$timestamp = $recurrence->fromGMT($recurrence->tz, $basedate);
		}

		$year = $timestamp !== false ? sprintf('%04s', dechex((int) gmdate('Y', $timestamp))) : '0000';
		$month = $timestamp !== false ? sprintf('%02s', dechex((int) gmdate('m', $timestamp))) : '00';
		$day = $timestamp !== false ? sprintf('%02s', dechex((int) gmdate('d', $timestamp))) : '00';

		return hex2bin(strtoupper(substr($hexguid, 0, 32) . $year . $month . $day . substr($hexguid, 40)));
	}

	/**
	 * Function which replaces attachments with copy_from in copy_to.
	 *
	 * @param mixed $copyFrom       MAPI_message from which attachments are to be copied
	 * @param mixed $copyTo         MAPI_message to which attachment are to be copied
	 * @param bool  $copyExceptions if true then all exceptions should also be sent as attachments
	 */
	public function replaceAttachments(mixed $copyFrom, mixed $copyTo, bool $copyExceptions = true): void {
		/* remove all old attachments */
		$attachmentTableTo = mapi_message_getattachmenttable($copyTo);
		if ($attachmentTableTo) {
			$attachments = mapi_table_queryallrows($attachmentTableTo, [PR_ATTACH_NUM, PR_ATTACH_METHOD, PR_EXCEPTION_STARTTIME]);

			foreach ($attachments as $attachProps) {
				/* remove exceptions too? */
				if (!$copyExceptions && $attachProps[PR_ATTACH_METHOD] == ATTACH_EMBEDDED_MSG && isset($attachProps[PR_EXCEPTION_STARTTIME])) {
					continue;
				}
				mapi_message_deleteattach($copyTo, $attachProps[PR_ATTACH_NUM]);
			}
		}

		/* copy new attachments */
		$attachmentTableFrom = mapi_message_getattachmenttable($copyFrom);
		if ($attachmentTableFrom) {
			$attachments = mapi_table_queryallrows($attachmentTableFrom, [PR_ATTACH_NUM, PR_ATTACH_METHOD, PR_EXCEPTION_STARTTIME]);

			foreach ($attachments as $attachProps) {
				if (!$copyExceptions && $attachProps[PR_ATTACH_METHOD] == ATTACH_EMBEDDED_MSG && isset($attachProps[PR_EXCEPTION_STARTTIME])) {
					continue;
				}

				$attachOld = mapi_message_openattach($copyFrom, (int) $attachProps[PR_ATTACH_NUM]);
				$attachNewResourceMsg = mapi_message_createattach($copyTo);
				mapi_copyto($attachOld, [], [], $attachNewResourceMsg, 0);
				mapi_savechanges($attachNewResourceMsg);
			}
		}
	}

	/**
	 * Function which replaces recipients in copyTo with recipients from copyFrom.
	 *
	 * @param mixed $copyFrom   MAPI_message from which recipients are to be copied
	 * @param mixed $copyTo     MAPI_message to which recipients are to be copied
	 * @param bool  $isDelegate indicates whether delegate is processing
	 *                          so don't copy delegate information to recipient table
	 */
	public function replaceRecipients(mixed $copyFrom, mixed $copyTo, bool $isDelegate = false): void {
		$recipients = $this->getAcceptedRecipients($copyFrom, $isDelegate, $copyFrom);

		$copyToRecipientTable = mapi_message_getrecipienttable($copyTo);
		$copyToRecipientRows = mapi_table_queryallrows($copyToRecipientTable, [PR_ROWID]);

		mapi_message_modifyrecipients($copyTo, MODRECIP_REMOVE, $copyToRecipientRows);
		mapi_message_modifyrecipients($copyTo, MODRECIP_ADD, $recipients);
	}

	/**
	 * Function creates meeting item in resource's calendar.
	 *
	 * @param resource  $message  MAPI_message which is to create in resource's calendar
	 * @param bool      $cancel   cancel meeting
	 * @param mixed     $prefix   prefix for subject of meeting
	 * @param false|int $basedate
	 *
	 * @return (mixed|resource)[][]
	 *
	 * @psalm-return list<array{store: resource, folder: mixed, msg: mixed}>
	 */
	public function bookResources($message, $cancel, $prefix, $basedate = false): array {
		if (!$this->enableDirectBooking) {
			return [];
		}

		$messageprops = $this->getResourceMessageProperties($message, $basedate);

		// Get resource recipients
		$getResourcesRestriction = [
			RES_PROPERTY,
			[
				RELOP => RELOP_EQ,	// Equals recipient type 3: Resource
				ULPROPTAG => PR_RECIPIENT_TYPE,
				VALUE => [PR_RECIPIENT_TYPE => MAPI_BCC],
			],
		];
		$resourceRecipients = $this->getMessageRecipients($message, $getResourcesRestriction);

		$this->errorSetResource = false;
		$resourceRecipData = [];
		$resourceMsgProps = null;

		// Put appointment into store resource users
		$i = 0;
		$len = count($resourceRecipients);
		while (empty($this->errorSetResource) && $i < $len) {
			try {
				$userStore = $this->openCustomUserStore($resourceRecipients[$i][PR_ENTRYID]);
			}
			catch (MAPIException $e) {
				$e->setHandled();
				$userStore = null;
			}
			if (!$userStore) {
				$this->errorSetResource = 1; // No access

				break;
			}

			$calFolder = $this->openResourceCalendar($userStore);

			if ($calFolder !== false) {
				$this->checkResourceBooking($message, $messageprops, $userStore, $calFolder, $resourceRecipients[$i], $cancel);
			}

			if (empty($this->errorSetResource) && $calFolder !== false) {
				$newResourceMsg = $this->findResourceCalendarMessage($userStore, $calFolder, $messageprops, $resourceMsgProps);

				$this->setResourceMessageProperties($messageprops, $prefix, $cancel);

				$this->saveResourceMessage($message, $userStore, $newResourceMsg, $messageprops, $basedate, $resourceMsgProps);

				$resourceRecipData[] = [
					'store' => $userStore,
					'folder' => $calFolder,
					'msg' => $newResourceMsg,
				];
				$this->includesResources = true;
			}
			else {
				/*
				 * If no other errors occurred and you have no access to the
				 * folder of the resource, throw an error=1.
				 */
				if (empty($this->errorSetResource)) {
					$this->errorSetResource = 1;
				}

				for ($j = 0, $len = count($resourceRecipData); $j < $len; ++$j) {
					// Get the EntryID
					$props = mapi_getprops($resourceRecipData[$j]['msg']);

					mapi_folder_deletemessages($resourceRecipData[$j]['folder'], [$props[PR_ENTRYID]], DELETE_HARD_DELETE);
				}
				$this->recipientDisplayname = $resourceRecipients[$i][PR_DISPLAY_NAME];
			}
			++$i;
		}

		$this->updateResourceTracking($message);

		return $resourceRecipData;
	}

	private function getResourceMessageProperties(mixed $message, mixed $basedate): array {
		// Get the properties of the message
		$messageprops = mapi_getprops($message);

		if (!empty($basedate)) {
			$recurrItemProps = mapi_getprops($this->message, [$this->proptags['goid'], $this->proptags['goid2'], $this->proptags['timezone_data'], $this->proptags['timezone'], PR_OWNER_APPT_ID]);

			$recurrenceHelper = new Recurrence($this->store, $this->message);
			$basedateUtc = $basedate;
			if ($recurrenceHelper instanceof BaseRecurrence && isset($recurrenceHelper->tz)) {
				$basedateUtc = $recurrenceHelper->toGMT($recurrenceHelper->tz, $basedate);
			}

			$messageprops[$this->proptags['goid']] = $this->setBasedateInGlobalID($recurrItemProps[$this->proptags['goid']], $basedateUtc, $recurrenceHelper);
			$messageprops[$this->proptags['goid2']] = $recurrItemProps[$this->proptags['goid2']];

			// Delete properties which are not needed.
			$deleteProps = [$this->proptags['basedate'], PR_DISPLAY_NAME, PR_ATTACHMENT_FLAGS, PR_ATTACHMENT_HIDDEN, PR_ATTACHMENT_LINKID, PR_ATTACH_FLAGS, PR_ATTACH_METHOD];
			foreach ($deleteProps as $propID) {
				if (isset($messageprops[$propID])) {
					unset($messageprops[$propID]);
				}
			}

			if (isset($messageprops[$this->proptags['recurring']])) {
				$messageprops[$this->proptags['recurring']] = false;
			}

			// Set Outlook properties
			$messageprops[$this->proptags['clipstart']] = $messageprops[$this->proptags['startdate']];
			$messageprops[$this->proptags['clipend']] = $messageprops[$this->proptags['duedate']];
			$messageprops[$this->proptags['timezone_data']] = $recurrItemProps[$this->proptags['timezone_data']];
			$messageprops[$this->proptags['timezone']] = $recurrItemProps[$this->proptags['timezone']];
			$messageprops[$this->proptags['attendee_critical_change']] = time();
			$messageprops[$this->proptags['owner_critical_change']] = time();
		}

		return $messageprops;
	}

	private function openResourceCalendar(mixed $userStore): mixed {
		// Open root folder
		$userRoot = mapi_msgstore_openentry($userStore);

		// Get calendar entryID
		$userRootProps = mapi_getprops($userRoot, [PR_STORE_ENTRYID, PR_IPM_APPOINTMENT_ENTRYID, PR_FREEBUSY_ENTRYIDS]);

		// Open Calendar folder
		$calFolder = false;

		try {
			// @FIXME this checks delegate has access to resource's calendar folder
			// but it should use boss' credentials

			if ($this->checkCalendarWriteAccess($this->store)) {
				$calFolder = mapi_msgstore_openentry($userStore, $userRootProps[PR_IPM_APPOINTMENT_ENTRYID]);
			}
		}
		catch (MAPIException $e) {
			$e->setHandled();
			$this->errorSetResource = 1; // No access
		}

		return $calFolder;
	}

	private function checkResourceBooking(mixed $message, array $messageprops, mixed $userStore, mixed $calFolder, array $recipient, mixed $cancel): void {
		$localFreebusyMsg = FreeBusy::getLocalFreeBusyMessage($userStore);
		if (!$localFreebusyMsg) {
			return;
		}
		$props = mapi_getprops($localFreebusyMsg, [PR_SCHDINFO_AUTO_ACCEPT_APPTS, PR_SCHDINFO_DISALLOW_RECURRING_APPTS, PR_SCHDINFO_DISALLOW_OVERLAPPING_APPTS]);

		$acceptMeetingRequests = $props[PR_SCHDINFO_AUTO_ACCEPT_APPTS] ?? false;
		$declineRecurringMeetingRequests = $props[PR_SCHDINFO_DISALLOW_RECURRING_APPTS] ?? false;
		$declineConflictingMeetingRequests = $props[PR_SCHDINFO_DISALLOW_OVERLAPPING_APPTS] ?? false;

		if (!$acceptMeetingRequests) {
			$this->nonAcceptingResources[] = $recipient;

			return;
		}
		if ($declineRecurringMeetingRequests && !$cancel && $messageprops[$this->proptags['recurring']]) {
			$this->errorSetResource = 3;
		}
		if ($declineConflictingMeetingRequests && !$cancel &&
			$calFolder && $this->isMeetingConflicting($message, $userStore, $calFolder)) {
			$this->errorSetResource = 4;
		}
	}

	private function findResourceCalendarMessage(mixed $userStore, mixed $calFolder, array $messageprops, mixed &$resourceMsgProps): mixed {
		/*
		 * First search on GlobalID(0x3)
		 * If (recurring and occurrence) If Resource was booked for only this occurrence then Resource should have only this occurrence in Calendar and not whole series.
		 * If (normal meeting) then GlobalID(0x3) and CleanGlobalID(0x23) are same, so doesn't matter if search is based on GlobalID.
		 */
		$rows = $this->findCalendarItems($messageprops[$this->proptags['goid']], $calFolder);

		/*
		 * If no entry is found then
		 * 1) Resource doesn't have meeting in Calendar. Seriously!!
		 * OR
		 * 2) We were looking for occurrence item but Resource has whole series
		 */
		if (empty($rows)) {
			/**
			 * Now search on CleanGlobalID(0x23) WHY???
			 * Because we are looking recurring item.
			 *
			 * Possible results of this search
			 * 1) If Resource was booked for more than one occurrences then this search will return all those occurrence because search is perform on CleanGlobalID
			 * 2) If Resource was booked for whole series then it should return series.
			 */
			$rows = $this->findCalendarItems($messageprops[$this->proptags['goid2']], $calFolder, true);

			$newResourceMsg = false;
			if (!empty($rows)) {
				// Since we are looking for recurring item, open every result and check for 'recurring' property.
				foreach ($rows as $row) {
					$ResourceMsg = mapi_msgstore_openentry($userStore, $row);
					$resourceMsgProps = mapi_getprops($ResourceMsg, [$this->proptags['recurring']]);

					if (!empty($resourceMsgProps[$this->proptags['recurring']])) {
						$newResourceMsg = $ResourceMsg;
						break;
					}
				}
			}

			// Still no results found. I giveup, create new message.
			if (!$newResourceMsg) {
				$newResourceMsg = mapi_folder_createmessage($calFolder);
			}
		}
		else {
			$newResourceMsg = mapi_msgstore_openentry($userStore, $rows[0]);
		}

		return $newResourceMsg;
	}

	private function setResourceMessageProperties(array &$messageprops, mixed $prefix, mixed $cancel): void {
		// Prefix the subject if needed
		if ($prefix && isset($messageprops[PR_SUBJECT])) {
			$messageprops[PR_SUBJECT] = $prefix . $messageprops[PR_SUBJECT];
		}

		// Set status to cancelled if needed
		$messageprops[$this->proptags['busystatus']] = fbBusy; // The default status (Busy)
		if ($cancel) {
			$messageprops[$this->proptags['meetingstatus']] = olMeetingCanceled; // The meeting has been canceled
			$messageprops[$this->proptags['busystatus']] = fbFree; // Free
		}
		else {
			$messageprops[$this->proptags['meetingstatus']] = olMeetingReceived; // The recipient is receiving the request
		}
		$messageprops[$this->proptags['responsestatus']] = olResponseAccepted; // The resource automatically accepts the appointment

		$messageprops[PR_MESSAGE_CLASS] = 'IPM.Appointment';

		// Remove the PR_ICON_INDEX as it is not needed in the sent message.
		$messageprops[PR_ICON_INDEX] = null;
		$messageprops[PR_RESPONSE_REQUESTED] = true;

		// get the store of organizer, in case of delegates it will be delegate store
		$defaultStore = $this->openDefaultStore();

		$storeProps = mapi_getprops($this->store, [PR_ENTRYID]);
		$defaultStoreProps = mapi_getprops($defaultStore, [PR_ENTRYID]);

		if (!compareEntryIds($storeProps[PR_ENTRYID], $defaultStoreProps[PR_ENTRYID])) {
			// get delegate information
			$addrInfo = $this->getOwnerAddress($defaultStore, false) ?: [];
			$this->setAddressProperties($messageprops, $addrInfo, 'SENDER');

			// get delegator information
			$addrInfo = $this->getOwnerAddress($this->store, false) ?: [];
			$this->setAddressProperties($messageprops, $addrInfo, 'SENT_REPRESENTING');
		}
		else {
			// get organizer information
			$addrInfo = $this->getOwnerAddress($this->store) ?: [];
			$this->setAddressProperties($messageprops, $addrInfo, 'SENDER');
			$this->setAddressProperties($messageprops, $addrInfo, 'SENT_REPRESENTING');
		}

		$messageprops[$this->proptags['replytime']] = time();
	}

	private function saveResourceMessage(mixed $message, mixed $userStore, mixed $newResourceMsg, array $messageprops, mixed $basedate, mixed $resourceMsgProps): void {
		if (!empty($basedate) && isset($resourceMsgProps[$this->proptags['recurring']]) && $resourceMsgProps[$this->proptags['recurring']]) {
			$recurr = new Recurrence($userStore, $newResourceMsg);

			// Copy recipients list
			$reciptable = mapi_message_getrecipienttable($message);
			$recips = mapi_table_queryallrows($reciptable, $this->recipprops);

			// add owner to recipient table
			$this->addOrganizer($messageprops, $recips, true);

			// Update occurrence
			if ($recurr->isException($basedate)) {
				$recurr->modifyException($messageprops, $basedate, $recips);
			}
			else {
				$recurr->createException($messageprops, $basedate, false, $recips);
			}
		}
		else {
			mapi_setprops($newResourceMsg, $messageprops);

			// Copy attachments
			$this->replaceAttachments($message, $newResourceMsg);

			// Copy all recipients too
			$this->replaceRecipients($message, $newResourceMsg);

			// Now add organizer also to recipient table
			$recips = [];
			$this->addOrganizer($messageprops, $recips);

			mapi_message_modifyrecipients($newResourceMsg, MODRECIP_ADD, $recips);
		}

		mapi_savechanges($newResourceMsg);
	}

	private function updateResourceTracking(mixed $message): void {
		$resourceRecipients = $this->getMessageRecipients($message);
		if (!empty($resourceRecipients)) {
			// Set Tracking status of resource recipients to olResponseAccepted (3)
			for ($i = 0, $len = count($resourceRecipients); $i < $len; ++$i) {
				if (isset($resourceRecipients[$i][PR_RECIPIENT_TYPE]) && $resourceRecipients[$i][PR_RECIPIENT_TYPE] == MAPI_BCC) {
					$resourceRecipients[$i][PR_RECIPIENT_TRACKSTATUS] = olRecipientTrackStatusAccepted;
					$resourceRecipients[$i][PR_RECIPIENT_TRACKSTATUS_TIME] = time();
				}
			}
			mapi_message_modifyrecipients($message, MODRECIP_MODIFY, $resourceRecipients);
		}
	}

	/**
	 * Function which save an exception into recurring item.
	 *
	 * @param resource $recurringItem  reference to MAPI_message of recurring item
	 * @param resource $occurrenceItem reference to MAPI_message of occurrence
	 * @param string   $basedate       basedate of occurrence
	 * @param bool     $move           if true then occurrence item is deleted
	 * @param bool     $tentative      true if user has tentatively accepted it or false if user has accepted it
	 * @param bool     $userAction     true if user has manually responded to meeting request
	 * @param resource $store          user store
	 * @param bool     $isDelegate     true if delegate is processing this meeting request
	 */
	public function acceptException(mixed &$recurringItem, mixed &$occurrenceItem, mixed $basedate, bool $move, bool $tentative, bool $userAction, mixed $store, bool $isDelegate = false): void {
		$recurr = new Recurrence($store, $recurringItem);

		// Copy properties from meeting request
		$exception_props = mapi_getprops($occurrenceItem);

		// Copy recipients list
		$recips = $this->getAcceptedRecipients($occurrenceItem, $isDelegate, $this->message);

		// add owner to recipient table
		$this->addOrganizer($exception_props, $recips, true);

		// add delegator to meetings
		if ($isDelegate) {
			$this->addDelegator($exception_props, $recips);
		}

		$exception_props[$this->proptags['meetingstatus']] = olMeetingReceived;
		$exception_props[$this->proptags['responsestatus']] = $this->determineResponseStatus($userAction, $tentative);

		if (isset($exception_props[$this->proptags['intendedbusystatus']])) {
			if ($tentative && $exception_props[$this->proptags['intendedbusystatus']] !== fbFree) {
				$exception_props[$this->proptags['busystatus']] = fbTentative;
			}
			else {
				$exception_props[$this->proptags['busystatus']] = $exception_props[$this->proptags['intendedbusystatus']];
			}
			// we already have intendedbusystatus value in $exception_props so no need to copy it
		}
		else {
			$exception_props[$this->proptags['busystatus']] = $tentative ? fbTentative : fbBusy;
		}

		if ($userAction) {
			$this->setReplyTimeAndName($exception_props);
		}

		// In some cases the exception subject is not in the property list,
		// so it's necessary to fetch it.
		if (!isset($exception_props[PR_SUBJECT])) {
			$exSubject = mapi_getprops($occurrenceItem, [PR_SUBJECT]);
			if (!empty($exSubject[PR_SUBJECT])) {
				$exception_props[PR_SUBJECT] = $exSubject[PR_SUBJECT];
			}
		}
		if ($recurr->isException($basedate)) {
			$recurr->modifyException($exception_props, $basedate, $recips, $occurrenceItem);
		}
		else {
			$recurr->createException($exception_props, $basedate, false, $recips, $occurrenceItem);
		}

		// Move the occurrenceItem to the waste basket
		if ($move) {
			$wastebasket = $this->openDefaultWastebasket($this->openDefaultStore());
			$sourcefolder = mapi_msgstore_openentry($store, $exception_props[PR_PARENT_ENTRYID]);
			mapi_folder_copymessages($sourcefolder, [$exception_props[PR_ENTRYID]], $wastebasket, MESSAGE_MOVE);
		}

		mapi_savechanges($recurringItem);
	}

	/**
	 * Function which merges an exception mapi message to recurring message.
	 * This will be used when we receive recurring meeting request and we already have an exception message
	 * of same meeting in calendar and we need to remove that exception message and add it to attachment table
	 * of recurring meeting.
	 *
	 * @param resource  $recurringItem  reference to MAPI_message of recurring item
	 * @param resource  $occurrenceItem reference to MAPI_message of occurrence
	 * @param false|int $basedate       basedate of occurrence
	 * @param resource  $store          user store
	 */
	public function mergeException(mixed &$recurringItem, mixed &$occurrenceItem, mixed $basedate, mixed $store): void {
		$recurr = new Recurrence($store, $recurringItem);

		// Copy properties from meeting request
		$exception_props = mapi_getprops($occurrenceItem);

		// Get recipient list from message and add it to exception attachment
		$recips = $this->getMessageRecipients($occurrenceItem);

		if ($recurr->isException($basedate)) {
			$recurr->modifyException($exception_props, $basedate, $recips, $occurrenceItem);
		}
		else {
			$recurr->createException($exception_props, $basedate, false, $recips, $occurrenceItem);
		}

		// Move the occurrenceItem to the waste basket
		$wastebasket = $this->openDefaultWastebasket($this->openDefaultStore());
		$sourcefolder = mapi_msgstore_openentry($store, $exception_props[PR_PARENT_ENTRYID]);
		mapi_folder_copymessages($sourcefolder, [$exception_props[PR_ENTRYID]], $wastebasket, MESSAGE_MOVE);

		mapi_savechanges($recurringItem);
	}

	/**
	 * Function which submits meeting request based on arguments passed to it.
	 *
	 * @param resource         $message        MAPI_message whose meeting request is to be sent
	 * @param bool             $cancel         if true send request, else send cancellation
	 * @param mixed            $prefix         subject prefix
	 * @param false|int        $basedate       basedate for an occurrence
	 * @param false|Recurrence $recurObject    recurrence object of mr
	 * @param bool             $copyExceptions When sending update mail for recurring item then we don't send exceptions in attachments
	 * @param mixed            $modifiedRecips
	 * @param mixed            $deletedRecips
	 */
	public function submitMeetingRequest($message, $cancel, $prefix, $basedate = false, $recurObject = false, $copyExceptions = true, $modifiedRecips = false, $deletedRecips = false): void {
		$newmessageprops = $messageprops = mapi_getprops($this->message);
		$new = $this->createOutgoingMessage($this->store);

		// Copy the entire message into the new meeting request message
		if (!empty($basedate)) {
			$newmessageprops = $this->getOutgoingExceptionProperties($message, $cancel, $basedate, $recurObject, $messageprops);

			$restriction = $this->getMeetingRecipientRestriction(true);

			$recipients = $this->getMessageRecipients($message, $restriction);

			$deletedRecips = array_merge($deletedRecips ?: [], $recipients);
		}

		// gromox returns PR_NORMALIZED_SUBJECT and PR_SUBJECT_PREFIX from a
		// getprops without a tag list, but no PR_SUBJECT
		if (($prefix || $deletedRecips) && !isset($newmessageprops[PR_SUBJECT])) {
			$source = empty($basedate) ? $this->message : $message;
			$subject = mapi_getprops($source, [PR_SUBJECT]);
			if (isset($subject[PR_SUBJECT])) {
				$newmessageprops[PR_SUBJECT] = $subject[PR_SUBJECT];
			}
		}

		$newmessageprops = $this->getOutgoingMeetingProperties($newmessageprops, $messageprops, $prefix, $recurObject);
		mapi_setprops($new, $newmessageprops);

		// Copy attachments
		$this->replaceAttachments($message, $new, $copyExceptions);

		$stripResourcesRestriction = $this->getMeetingRecipientRestriction(false);

		// If no recipients were explicitly provided, we will send the update to all
		// recipients from the meeting.
		if ($modifiedRecips === false) {
			$modifiedRecips = $this->getMeetingUpdateRecipients($message, $basedate, $stripResourcesRestriction);
		}

		if (!empty($modifiedRecips)) {
			$this->submitMeetingUpdate($new, $modifiedRecips, $messageprops, $newmessageprops, $cancel);
		}

		if ($deletedRecips) {
			$deletedRecips = $this->filterCanceledRecipients($deletedRecips, $modifiedRecips);
		}

		// Send cancellation to deleted attendees
		if ($deletedRecips) {
			$this->submitCanceledAttendees($deletedRecips, $newmessageprops);
		}

		$props = $this->getSentMeetingProperties($messageprops, $newmessageprops, $modifiedRecips);
		mapi_setprops($message, $props);

		// saving of these properties on calendar item should be handled by caller function
		// based on sending meeting request was successful or not
	}

	private function getOutgoingExceptionProperties(mixed $message, mixed $cancel, mixed $basedate, mixed $recurObject, array $messageprops): array {
		// messageprops contains properties of whole recurring series
		// and newmessageprops contains properties of exception item
		$newmessageprops = mapi_getprops($message);

		$basedateUtc = $basedate;
		if ($recurObject instanceof BaseRecurrence && isset($recurObject->tz)) {
			// PidLidExceptionReplaceTime is the original start, not the day
			$origStart = $recurObject->dayStartOf($basedate) + $recurObject->recur['startocc'] * 60;
			$basedateUtc = $recurObject->toGMT($recurObject->tz, $origStart);
		}

		// Ensure that the correct basedate is set in the new message
		$newmessageprops[$this->proptags['basedate']] = $basedateUtc;

		// Set isRecurring to false, because this is an exception
		$newmessageprops[$this->proptags['recurring']] = false;

		// PidLidIsRecurring indicates a message associated with a recurring series object.
		// It's true both for the series and an exception.
		$newmessageprops[$this->proptags['meetingrecurring']] = true;

		// Recurrence data is not necessary for an exception
		unset($newmessageprops[$this->proptags['recurrence_data']]);

		// set LID_IS_EXCEPTION to true
		$newmessageprops[$this->proptags['is_exception']] = true;

		// Set to high importance
		if ($cancel) {
			$newmessageprops[PR_IMPORTANCE] = IMPORTANCE_HIGH;
		}

		// Set startdate and enddate of exception
		if ($cancel && $recurObject instanceof Recurrence) {
			$newmessageprops[$this->proptags['startdate']] = $recurObject->getOccurrenceStart($basedate);
			$newmessageprops[$this->proptags['duedate']] = $recurObject->getOccurrenceEnd($basedate);
		}

		// Set basedate in guid (0x3)
		$newmessageprops[$this->proptags['goid']] = $this->setBasedateInGlobalID($messageprops[$this->proptags['goid2']], $basedateUtc, $recurObject instanceof BaseRecurrence ? $recurObject : null);
		$newmessageprops[$this->proptags['goid2']] = $messageprops[$this->proptags['goid2']];
		// optional per MS-OXOCAL v22.1 §2.2.1.29, EWS and iCalendar series lack it
		unset($newmessageprops[PR_OWNER_APPT_ID]);
		if (isset($messageprops[PR_OWNER_APPT_ID])) {
			$newmessageprops[PR_OWNER_APPT_ID] = $messageprops[PR_OWNER_APPT_ID];
		}

		return $newmessageprops;
	}

	private function getMeetingRecipientRestriction(bool $deleted): array {
		// $deleted: the recipExceptionalDeleted rows, otherwise the live ones;
		// never the organizer, and no resources in direct-booking mode
		$restriction = [
			RES_AND,
			[
				[
					RES_BITMASK,
					[
						ULTYPE => $deleted ? BMR_NEZ : BMR_EQZ,
						ULPROPTAG => PR_RECIPIENT_FLAGS,
						ULMASK => recipExceptionalDeleted,
					],
				],
				[
					RES_BITMASK,
					[
						ULTYPE => BMR_EQZ,
						ULPROPTAG => PR_RECIPIENT_FLAGS,
						ULMASK => recipOrganizer,
					],
				],
			],
		];

		// In direct-booking mode, we don't need to send cancellations to resources
		if ($this->enableDirectBooking) {
			$restriction[1][] = [
				RES_PROPERTY,
				[
					RELOP => RELOP_NE,	// Does not equal recipient type: MAPI_BCC (Resource)
					ULPROPTAG => PR_RECIPIENT_TYPE,
					VALUE => [PR_RECIPIENT_TYPE => MAPI_BCC],
				],
			];
		}

		return $restriction;
	}

	private function getOutgoingMeetingProperties(array $newmessageprops, array $messageprops, mixed $prefix, mixed $recurObject): array {
		// don't let the addressing copied from the calendar item override the
		// sender set up by createOutgoingMessage
		unset(
			$newmessageprops[PR_SENDER_ENTRYID],
			$newmessageprops[PR_SENDER_NAME],
			$newmessageprops[PR_SENDER_ADDRTYPE],
			$newmessageprops[PR_SENDER_EMAIL_ADDRESS],
			$newmessageprops[PR_SENDER_SEARCH_KEY],
			$newmessageprops[PR_SENDER_SMTP_ADDRESS],
			$newmessageprops[PR_SENT_REPRESENTING_ENTRYID],
			$newmessageprops[PR_SENT_REPRESENTING_NAME],
			$newmessageprops[PR_SENT_REPRESENTING_ADDRTYPE],
			$newmessageprops[PR_SENT_REPRESENTING_EMAIL_ADDRESS],
			$newmessageprops[PR_SENT_REPRESENTING_SEARCH_KEY],
			$newmessageprops[PR_SENT_REPRESENTING_SMTP_ADDRESS]
		);

		// Remove the PR_ICON_INDEX as it is not needed in the sent message.
		$newmessageprops[PR_ICON_INDEX] = null;
		$newmessageprops[PR_RESPONSE_REQUESTED] = true;

		// PR_START_DATE and PR_END_DATE will be used by outlook to show the position in the calendar
		$newmessageprops[PR_START_DATE] = $newmessageprops[$this->proptags['startdate']];
		$newmessageprops[PR_END_DATE] = $newmessageprops[$this->proptags['duedate']];

		// Set updatecounter/AppointmentSequenceNumber
		// get the value of latest updatecounter for the whole series and use it
		$newmessageprops[$this->proptags['updatecounter']] = $messageprops[$this->proptags['last_updatecounter']];

		$meetingTimeInfo = $this->getMeetingTimeInfo();

		if ($meetingTimeInfo) {
			// Needs to unset PR_HTML and PR_RTF_COMPRESSED props
			// because while canceling meeting requests with edit text
			// will override the PR_BODY because body value is not consistent with
			// PR_HTML and PR_RTF_COMPRESSED value so in this case PR_RTF_COMPRESSED will
			// get priority which override the PR_BODY value.
			if ($this->mti_html) {
				unset($newmessageprops[PR_BODY], $newmessageprops[PR_RTF_COMPRESSED]);
				$newmessageprops[PR_HTML] = $meetingTimeInfo;
			}
			else {
				unset($newmessageprops[PR_HTML], $newmessageprops[PR_RTF_COMPRESSED]);
				$newmessageprops[PR_BODY] = $meetingTimeInfo;
			}
		}

		// Send all recurrence info in mail, if this is a recurrence meeting.
		if (isset($newmessageprops[$this->proptags['recurring']]) && $newmessageprops[$this->proptags['recurring']]) {
			if (!empty($messageprops[$this->proptags['recurring_pattern']])) {
				$newmessageprops[$this->proptags['recurring_pattern']] = $messageprops[$this->proptags['recurring_pattern']];
			}
			$newmessageprops[$this->proptags['recurrence_data']] = $messageprops[$this->proptags['recurrence_data']];
			$newmessageprops[$this->proptags['timezone_data']] = $messageprops[$this->proptags['timezone_data']];
			$newmessageprops[$this->proptags['timezone']] = $messageprops[$this->proptags['timezone']];

			if ($recurObject) {
				$this->generateRecurDates($recurObject, $messageprops, $newmessageprops);
			}
		}

		if (isset($newmessageprops[$this->proptags['counter_proposal']])) {
			unset($newmessageprops[$this->proptags['counter_proposal']]);
		}

		// Prefix the subject if needed
		if ($prefix && isset($newmessageprops[PR_SUBJECT])) {
			unset($newmessageprops[PR_NORMALIZED_SUBJECT], $newmessageprops[PR_SUBJECT_PREFIX]);
			$newmessageprops[PR_SUBJECT] = $prefix . $newmessageprops[PR_SUBJECT];
		}

		if (isset($newmessageprops[$this->proptags['categories']]) &&
			!empty($newmessageprops[$this->proptags['categories']])) {
			unset($newmessageprops[$this->proptags['categories']]);
		}

		return $newmessageprops;
	}

	private function getMeetingUpdateRecipients(mixed $message, mixed $basedate, array $stripResourcesRestriction): array {
		$modifiedRecips = $this->getMessageRecipients($message, $stripResourcesRestriction);

		if (!empty($basedate) && empty($modifiedRecips)) {
			// Retrieve full list
			$modifiedRecips = $this->getMessageRecipients($this->message);

			// Save recipients in exceptions
			mapi_message_modifyrecipients($message, MODRECIP_ADD, $modifiedRecips);

			// Now retrieve only those recipient who should receive this meeting request.
			$modifiedRecips = $this->getMessageRecipients($this->message, $stripResourcesRestriction);
		}

		return $modifiedRecips;
	}

	private function submitMeetingUpdate(mixed $new, mixed $modifiedRecips, array $messageprops, array &$newmessageprops, mixed $cancel): void {
		// Strip out the sender/'owner' recipient
		mapi_message_modifyrecipients($new, MODRECIP_ADD, $modifiedRecips);

		// Set some properties that are different in the sent request than
		// in the item in our calendar

		// we should store busystatus value to intendedbusystatus property, because busystatus for outgoing meeting request
		// should always be fbTentative
		$newmessageprops[$this->proptags['intendedbusystatus']] = $newmessageprops[$this->proptags['busystatus']] ?? $messageprops[$this->proptags['busystatus']];
		$newmessageprops[$this->proptags['busystatus']] = fbTentative; // The default status when not accepted
		$newmessageprops[$this->proptags['responsestatus']] = olResponseNotResponded; // The recipient has not responded yet
		$newmessageprops[$this->proptags['attendee_critical_change']] = time();
		$newmessageprops[$this->proptags['owner_critical_change']] = time();
		$newmessageprops[$this->proptags['meetingtype']] = mtgRequest;

		if ($cancel) {
			$newmessageprops[PR_MESSAGE_CLASS] = 'IPM.Schedule.Meeting.Canceled';
			$newmessageprops[$this->proptags['meetingstatus']] = olMeetingCanceled; // It's a cancel request
			$newmessageprops[$this->proptags['busystatus']] = fbFree; // set the busy status as free
		}
		else {
			$newmessageprops[PR_MESSAGE_CLASS] = 'IPM.Schedule.Meeting.Request';
			$newmessageprops[$this->proptags['meetingstatus']] = olMeetingReceived; // The recipient is receiving the request
		}

		mapi_setprops($new, $newmessageprops);
		mapi_savechanges($new);

		// Submit message to non-resource recipients
		$this->submitOutgoingMessage($new, (bool) $cancel);
	}

	private function filterCanceledRecipients(mixed $deletedRecips, mixed $modifiedRecips): array {
		$deleted = [];
		foreach ($deletedRecips as $delRecip) {
			foreach ($modifiedRecips as $recip) {
				if ($this->compareRecipients($recip, $delRecip)) {
					continue 2;
				}
			}
			$deleted[] = $delRecip;
		}

		return $deleted;
	}

	private function submitCanceledAttendees(mixed $deletedRecips, array &$newmessageprops): void {
		$new = $this->createOutgoingMessage($this->store);

		mapi_message_modifyrecipients($new, MODRECIP_ADD, $deletedRecips);

		$newmessageprops[PR_MESSAGE_CLASS] = 'IPM.Schedule.Meeting.Canceled';
		$newmessageprops[$this->proptags['meetingstatus']] = olMeetingCanceled; // It's a cancel request
		$newmessageprops[$this->proptags['busystatus']] = fbFree; // set the busy status as free
		$newmessageprops[PR_IMPORTANCE] = IMPORTANCE_HIGH;	// HIGH Importance
		if (isset($newmessageprops[PR_SUBJECT])) {
			unset($newmessageprops[PR_NORMALIZED_SUBJECT], $newmessageprops[PR_SUBJECT_PREFIX]);
			$newmessageprops[PR_SUBJECT] = _('Canceled') . ': ' . $newmessageprops[PR_SUBJECT];
		}

		mapi_setprops($new, $newmessageprops);
		mapi_savechanges($new);

		// mails to removed attendees are always cancellations
		$this->submitOutgoingMessage($new, true);
	}

	private function getSentMeetingProperties(array $messageprops, array $newmessageprops, mixed $modifiedRecips): array {
		// Set properties on meeting object in calendar
		// Set requestsent to 'true' (turns on 'tracking', etc)
		$props = [];
		$props[$this->proptags['meetingstatus']] = olMeeting;
		$props[$this->proptags['responsestatus']] = olResponseOrganized;
		// Only set the 'requestsent' property if it wasn't set previously yet,
		// this ensures we will not accidentally set it from true to false.
		if (!isset($messageprops[$this->proptags['requestsent']]) || $messageprops[$this->proptags['requestsent']] !== true) {
			$props[$this->proptags['requestsent']] = !empty($modifiedRecips) || ($this->includesResources && empty($this->errorSetResource));
		}
		$props[$this->proptags['attendee_critical_change']] = time();
		$props[$this->proptags['owner_critical_change']] = time();
		$props[$this->proptags['meetingtype']] = mtgRequest;
		// save the new updatecounter to exception/recurring series/normal meeting
		$props[$this->proptags['updatecounter']] = $newmessageprops[$this->proptags['updatecounter']];

		// PR_START_DATE and PR_END_DATE will be used by outlook to show the position in the calendar
		$props[PR_START_DATE] = $messageprops[$this->proptags['startdate']];
		$props[PR_END_DATE] = $messageprops[$this->proptags['duedate']];
		// Remove MSGFLAG_UNSENT flag, so that the current attendees won't be addded again
		// when modifying the appointment
		$props[PR_MESSAGE_FLAGS] = $messageprops[PR_MESSAGE_FLAGS] & ~MSGFLAG_UNSENT;

		return $props;
	}

	/**
	 * OL2007 uses these 4 properties to specify occurrence that should be updated.
	 * ical generates RECURRENCE-ID property based on exception's basedate (PidLidExceptionReplaceTime),
	 * but OL07 doesn't send this property, so ical will generate RECURRENCE-ID property based on date
	 * from GlobalObjId and time from StartRecurTime property, so we are sending basedate property and
	 * also additionally we are sending these properties.
	 * Ref: MS-OXCICAL 2.2.1.20.20 Property: RECURRENCE-ID.
	 *
	 * @param object $recurObject     instance of recurrence class for this message
	 * @param array  $messageprops    properties of meeting object that is going to be sent
	 * @param array  $newmessageprops properties of meeting request/response that is going to be sent
	 */
	public function generateRecurDates(object $recurObject, array $messageprops, array &$newmessageprops): void {
		if ($messageprops[$this->proptags['startdate']] && $messageprops[$this->proptags['duedate']]) {
			$startDate = gmdate('Y:n:j:G:i:s', $recurObject->fromGMT($recurObject->tz, $messageprops[$this->proptags['startdate']]));
			$endDate = gmdate('Y:n:j:G:i:s', $recurObject->fromGMT($recurObject->tz, $messageprops[$this->proptags['duedate']]));

			$startDate = explode(':', $startDate);
			$endDate = explode(':', $endDate);

			// [0] => year, [1] => month, [2] => day, [3] => hour, [4] => minutes, [5] => seconds
			// RecurStartDate = year * 512 + month_number * 32 + day_number
			$newmessageprops[$this->proptags['start_recur_date']] = (((int) $startDate[0]) * 512) + (((int) $startDate[1]) * 32) + ((int) $startDate[2]);
			// RecurStartTime = hour * 4096 + minutes * 64 + seconds
			$newmessageprops[$this->proptags['start_recur_time']] = (((int) $startDate[3]) * 4096) + (((int) $startDate[4]) * 64) + ((int) $startDate[5]);

			$newmessageprops[$this->proptags['end_recur_date']] = (((int) $endDate[0]) * 512) + (((int) $endDate[1]) * 32) + ((int) $endDate[2]);
			$newmessageprops[$this->proptags['end_recur_time']] = (((int) $endDate[3]) * 4096) + (((int) $endDate[4]) * 64) + ((int) $endDate[5]);
		}
	}

	/**
	 * Function will create a new outgoing message that will be used to send meeting mail.
	 *
	 * @param mixed $store (optional) store that is used when creating response, if delegate is creating outgoing mail
	 *                     then this would point to delegate store
	 *
	 * @return resource outgoing mail that is created and can be used for sending it
	 */
	public function createOutgoingMessage(mixed $store = false): mixed {
		// get logged in user's store that will be used to send mail, for delegate this will be
		// delegate store
		$userStore = $this->openDefaultStore();

		$sentprops = [];
		$outbox = $this->openDefaultOutbox($userStore);

		$outgoing = mapi_folder_createmessage($outbox);

		// check if $store is set and it is not equal to $defaultStore (means its the delegation case)
		$isDelegate = false;
		if ($store !== false) {
			$storeProps = mapi_getprops($store, [PR_ENTRYID]);
			$userStoreProps = mapi_getprops($userStore, [PR_ENTRYID]);
			$isDelegate = !compareEntryIds($storeProps[PR_ENTRYID], $userStoreProps[PR_ENTRYID]);
		}

		if ($isDelegate) {
			// get the delegator properties and set it into outgoing mail
			$delegatorDetails = $this->getOwnerAddress($store, false);
			$this->setAddressProperties($sentprops, $delegatorDetails ?: [], 'SENT_REPRESENTING');

			// get the delegate properties and set it into outgoing mail
			$delegateDetails = $this->getOwnerAddress($userStore, false);
			$this->setAddressProperties($sentprops, $delegateDetails ?: [], 'SENDER');
		}
		else {
			// normal user is sending mail, so both set of properties will be same
			$userDetails = $this->getOwnerAddress($userStore);
			$this->setAddressProperties($sentprops, $userDetails ?: [], 'SENT_REPRESENTING');
			$this->setAddressProperties($sentprops, $userDetails ?: [], 'SENDER');
		}

		$sentprops[PR_SENTMAIL_ENTRYID] = $this->getDefaultSentmailEntryID($userStore);

		mapi_setprops($outgoing, $sentprops);

		return $outgoing;
	}

	/**
	 * Submits an outgoing meeting mail. A cancellation mail may fall back to
	 * being sent in the name of the acting user when send-on-behalf is denied.
	 * Updates and responses must not, since the recipient side derives the
	 * organizer/attendee identity from the sender properties.
	 *
	 * @param mixed $outgoing        the outgoing message to submit
	 * @param bool  $allowSendAsSelf send as the acting user when send-on-behalf
	 *                               is denied
	 */
	public function submitOutgoingMessage(mixed $outgoing, bool $allowSendAsSelf = false): void {
		try {
			mapi_message_submitmessage($outgoing);
		}
		catch (MAPIException $e) {
			if (!$allowSendAsSelf || $e->getCode() != MAPI_E_NO_ACCESS) {
				throw $e;
			}

			$userStore = $this->openDefaultStore();
			if ($userStore === false) {
				throw $e;
			}
			$userDetails = $this->getOwnerAddress($userStore);
			if ($userDetails === false) {
				throw $e;
			}
			$e->setHandled();

			$sentprops = [];
			$this->setAddressProperties($sentprops, $userDetails, 'SENT_REPRESENTING');
			$this->setAddressProperties($sentprops, $userDetails, 'SENDER');
			// zcore checks the SMTP address first, it must not name the other user
			mapi_deleteprops($outgoing, [PR_SENT_REPRESENTING_SMTP_ADDRESS, PR_SENDER_SMTP_ADDRESS]);
			mapi_setprops($outgoing, $sentprops);
			mapi_savechanges($outgoing);
			mapi_message_submitmessage($outgoing);
		}
	}

	/**
	 * Function which checks that meeting in attendee's calendar is already updated
	 * and we are checking an old meeting request. This function also will update property
	 * meetingtype to indicate that its out of date meeting request.
	 *
	 * @return bool true if meeting request is outofdate else false if it is new
	 */
	public function isMeetingOutOfDate(): bool {
		$result = false;

		$props = mapi_getprops($this->message, [PR_MESSAGE_CLASS, $this->proptags['goid'], $this->proptags['goid2'], $this->proptags['updatecounter'], $this->proptags['meetingtype'], $this->proptags['owner_critical_change']]);

		if (!$this->isMeetingRequest($props[PR_MESSAGE_CLASS])) {
			return $result;
		}

		if (isset($props[$this->proptags['meetingtype']]) && ($props[$this->proptags['meetingtype']] & mtgOutOfDate) == mtgOutOfDate) {
			return true;
		}

		// get the basedate to check for exception
		$basedate = $this->getBasedateFromGlobalID($props[$this->proptags['goid']]);

		$calendarItem = $this->getCorrespondentCalendarItem(true);

		// if basedate is provided and we could not find the item then it could be that we are checking
		// an exception so get the exception and check it
		if ($basedate !== false && $calendarItem !== false) {
			$exception = $this->getExceptionItem($calendarItem, $basedate);

			if ($exception !== false) {
				// we are able to find the exception compare with it
				$calendarItem = $exception;
			}
			// we are not able to find exception, could mean that a significant change has occurred on series
			// and it deleted all exceptions, so compare with series
			// $calendarItem already contains reference to series
		}

		if ($calendarItem !== false) {
			$calendarItemProps = mapi_getprops($calendarItem, [
				$this->proptags['owner_critical_change'],
				$this->proptags['updatecounter'],
			]);

			// A request without these properties counts as the oldest one
			$updateCounter = (isset($calendarItemProps[$this->proptags['updatecounter']]) && ($props[$this->proptags['updatecounter']] ?? 0) < $calendarItemProps[$this->proptags['updatecounter']]);

			$criticalChange = (isset($calendarItemProps[$this->proptags['owner_critical_change']]) && ($props[$this->proptags['owner_critical_change']] ?? 0) < $calendarItemProps[$this->proptags['owner_critical_change']]);

			if ($updateCounter || $criticalChange) {
				// meeting request is out of date, set properties to indicate this
				mapi_setprops($this->message, [$this->proptags['meetingtype'] => mtgOutOfDate, PR_ICON_INDEX => 1033]);
				mapi_savechanges($this->message);

				$result = true;
			}
		}

		return $result;
	}

	/**
	 * Function which checks that if we have received a meeting response for an updated meeting in organizer's calendar.
	 *
	 * @param false|int $basedate basedate of the exception if we want to compare with exception
	 *
	 * @return bool true if meeting request is updated later
	 */
	public function isMeetingUpdated(false|int $basedate = false): bool {
		$result = false;

		$props = mapi_getprops($this->message, [PR_MESSAGE_CLASS, $this->proptags['updatecounter']]);

		if (!$this->isMeetingRequestResponse($props[PR_MESSAGE_CLASS])) {
			return $result;
		}

		$calendarItem = $this->getCorrespondentCalendarItem(true);

		if ($calendarItem !== false) {
			// basedate is provided so open exception
			if ($basedate !== false) {
				$exception = $this->getExceptionItem($calendarItem, $basedate);

				if ($exception !== false) {
					// we are able to find the exception compare with it
					$calendarItem = $exception;
				}
				// we are not able to find exception, could mean that a significant change has occurred on series
				// and it deleted all exceptions, so compare with series
				// $calendarItem already contains reference to series
			}

			if ($calendarItem !== false) {
				$calendarItemProps = mapi_getprops($calendarItem, [$this->proptags['updatecounter']]);

				/*
				 * if(message_counter < appointment_counter) meeting object is newer then meeting response (meeting is updated)
				 * if(message_counter >= appointment_counter) meeting is not updated, do normal processing
				 */
				if (isset($calendarItemProps[$this->proptags['updatecounter']], $props[$this->proptags['updatecounter']])) {
					$result = $props[$this->proptags['updatecounter']] < $calendarItemProps[$this->proptags['updatecounter']];
				}
			}
		}

		return $result;
	}

	/**
	 * Checks if there has been any significant changes on appointment/meeting item.
	 * Significant changes be:
	 * 1) startdate has been changed
	 * 2) duedate has been changed OR
	 * 3) recurrence pattern has been created, modified or removed.
	 *
	 * @param bool $isRecurrenceChanged for change in recurrence pattern.
	 *                                  true means Recurrence pattern has been changed,
	 *                                  so clear all attendees response
	 */
	public function checkSignificantChanges(array $oldProps, mixed $basedate, bool $isRecurrenceChanged = false): void {
		$message = null;
		$attach = null;

		// If basedate is specified then we need to open exception message to clear recipient responses
		if (!empty($basedate)) {
			$recurrence = new Recurrence($this->store, $this->message);
			if ($recurrence->isException($basedate)) {
				$attach = $recurrence->getExceptionAttachment($basedate);
				if ($attach) {
					$message = mapi_attach_openobj($attach, MAPI_MODIFY);
				}
			}
		}
		else {
			// use normal message or recurring series message
			$message = $this->message;
		}

		if (!$message) {
			return;
		}

		$newProps = mapi_getprops($message, [$this->proptags['startdate'], $this->proptags['duedate'], $this->proptags['updatecounter']]);

		// Check whether message is updated or not.
		if (isset($newProps[$this->proptags['updatecounter']]) && $newProps[$this->proptags['updatecounter']] == 0) {
			return;
		}

		if (($newProps[$this->proptags['startdate']] != $oldProps[$this->proptags['startdate']]) ||
				($newProps[$this->proptags['duedate']] != $oldProps[$this->proptags['duedate']]) ||
				$isRecurrenceChanged) {
			$this->clearRecipientResponse($message);

			mapi_setprops($message, [$this->proptags['owner_critical_change'] => time()]);

			mapi_savechanges($message);
			if ($attach) { // Also save attachment Object.
				mapi_savechanges($attach);
			}
		}
	}

	/**
	 * Clear responses of all attendees who have replied in past.
	 *
	 * @param resource $message on which responses should be cleared
	 */
	public function clearRecipientResponse($message): void {
		$recipsRows = $this->getMessageRecipients($message);
		for ($i = 0, $recipsCnt = count($recipsRows); $i < $recipsCnt; ++$i) {
			// Clear track status for everyone in the recipients table
			$recipsRows[$i][PR_RECIPIENT_TRACKSTATUS] = olRecipientTrackStatusNone;
		}
		mapi_message_modifyrecipients($message, MODRECIP_MODIFY, $recipsRows);
	}

	/**
	 * Function returns correspondent calendar item attached with the meeting request/response/cancellation/forward notification.
	 * This will only check for actual MAPIMessages in calendar folder, so if a meeting request is
	 * for exception then this function will return recurring series for that meeting request
	 * after that you need to use getExceptionItem function to get exception item that will be
	 * fetched from the attachment table of recurring series MAPIMessage.
	 *
	 * @param bool $open boolean to indicate the function should return entryid or MAPIMessage. Defaults to true.
	 *
	 * @return bool|resource resource of calendar item
	 */
	public function getCorrespondentCalendarItem(bool $open = true): mixed {
		$props = mapi_getprops($this->message, [
			PR_MESSAGE_CLASS,
			$this->proptags['goid'],
			$this->proptags['goid2'],
			PR_RCVD_REPRESENTING_ENTRYID,
			PR_PARENT_ENTRYID
		]);

		if (!$this->isMeetingRequest($props[PR_MESSAGE_CLASS]) && !$this->isMeetingRequestResponse($props[PR_MESSAGE_CLASS]) &&
			!$this->isMeetingCancellation($props[PR_MESSAGE_CLASS]) && !$this->isMeetingForwardNotification($props[PR_MESSAGE_CLASS])) {
			// can work only with meeting requests/responses/cancellations/forward notifications
			return false;
		}

		// there is no goid - no items can be found - aborting
		if (empty($props[$this->proptags['goid']])) {
			return false;
		}
		$globalId = $props[$this->proptags['goid']];

		['store' => $store, 'calFolder' => $calFolder] = $this->resolveDelegateStoreAndCalendar($props);

		$basedate = $this->getBasedateFromGlobalID($globalId);

		/**
		 * First search for any appointments which correspond to the $globalId,
		 * this can be the entire series (if the Meeting Request refers to the
		 * entire series), or an particular Occurrence (if the meeting Request
		 * contains a basedate).
		 *
		 * If we cannot find a corresponding item, and the $globalId contains
		 * a $basedate, it might imply that a new exception will have to be
		 * created for a series which is present in the calendar, we can look
		 * that one up by searching for the $cleanGlobalId.
		 */
		$entryids = $this->findCalendarItems($globalId, $calFolder);
		if ($basedate !== false && empty($entryids)) {
			// only search if a goid2 is available
			if (!empty($props[$this->proptags['goid2']])) {
				$cleanGlobalId = $props[$this->proptags['goid2']];
				$entryids = $this->findCalendarItems($cleanGlobalId, $calFolder, true);
			}
		}

		// there should be only one item returned
		if (!empty($entryids) && count($entryids) === 1) {
			// return only entryid
			if ($open === false) {
				return $entryids[0];
			}

			// open calendar item and return it
			if ($store) {
				return mapi_msgstore_openentry($store, $entryids[0]);
			}
		}

		// no items found in calendar
		return false;
	}

	/**
	 * Function returns exception item based on the basedate passed.
	 *
	 * @param mixed     $recurringMessage Resource of Recurring meeting from calendar
	 * @param false|int $basedate         basedate of exception that needs to be returned
	 * @param mixed     $store            store that contains the recurring calendar item
	 *
	 * @return false|resource resource of exception item
	 */
	public function getExceptionItem(mixed $recurringMessage, mixed $basedate, mixed $store = false): mixed {
		$occurItem = false;

		$props = mapi_getprops($this->message, [PR_RCVD_REPRESENTING_ENTRYID, $this->proptags['recurring']]);

		// check if the passed item is recurring series
		if (isset($props[$this->proptags['recurring']]) && $props[$this->proptags['recurring']] !== false) {
			return false;
		}

		if ($store === false) {
			$store = $this->store;
			// If Delegate is processing Meeting Request/Response for Delegator then retrieve Delegator's store and calendar.
			if (isset($props[PR_RCVD_REPRESENTING_ENTRYID])) {
				$delegatorStore = $this->getDelegatorStore($props[PR_RCVD_REPRESENTING_ENTRYID]);
				if (!empty($delegatorStore['store'])) {
					$store = $delegatorStore['store'];
				}
			}
		}

		$recurr = new Recurrence($store, $recurringMessage);
		$attach = $recurr->getExceptionAttachment($basedate);
		if ($attach) {
			$occurItem = mapi_attach_openobj($attach);
		}

		return $occurItem;
	}

	/**
	 * Function which checks whether received meeting request is either conflicting with other appointments or not.
	 *
	 * @param false|resource $message
	 * @param false|resource $userStore
	 * @param mixed          $calFolder calendar folder for conflict checking
	 *
	 * @psalm-return bool|int<1, max>
	 */
	public function isMeetingConflicting(mixed $message = false, mixed $userStore = false, mixed $calFolder = false): bool|int {
		if ($message === false) {
			$message = $this->message;
		}

		$messageProps = mapi_getprops(
			$message,
			[
				PR_MESSAGE_CLASS,
				$this->proptags['goid'],
				$this->proptags['goid2'],
				$this->proptags['startdate'],
				$this->proptags['duedate'],
				$this->proptags['recurring'],
				$this->proptags['clipstart'],
				$this->proptags['clipend'],
				PR_RCVD_REPRESENTING_ENTRYID,
				$this->proptags['basedate'],
				PR_RCVD_REPRESENTING_NAME,
				PR_ENTRYID,
				PR_SUBJECT,
				$this->proptags['recurrence_data'],
			]
		);

		if ($userStore === false) {
			$userStore = $this->store;

			// check if delegate is processing the response
			if (isset($messageProps[PR_RCVD_REPRESENTING_ENTRYID])) {
				$delegatorStore = $this->getDelegatorStore($messageProps[PR_RCVD_REPRESENTING_ENTRYID], [PR_IPM_APPOINTMENT_ENTRYID]);

				if (!empty($delegatorStore['store'])) {
					$userStore = $delegatorStore['store'];
				}
				if (!empty($delegatorStore[PR_IPM_APPOINTMENT_ENTRYID])) {
					$calFolder = $delegatorStore[PR_IPM_APPOINTMENT_ENTRYID];
				}
			}
		}

		if ($calFolder === false) {
			$calFolder = $this->openDefaultCalendar($userStore);
		}

		if (!$calFolder) {
			return false;
		}
		if (($messageProps[$this->proptags['recurring']] ?? false) === true) {
			return $this->countRecurringConflicts($message, $userStore, $calFolder, $messageProps);
		}

		// Get all items in the timeframe that we want to book, and get the goid and busystatus for each item
		$items = getCalendarItems($userStore, $calFolder, $messageProps[$this->proptags['startdate']], $messageProps[$this->proptags['duedate']], [$this->proptags['goid'], $this->proptags['busystatus']]);

		if (isset($messageProps[$this->proptags['basedate']]) && !empty($messageProps[$this->proptags['basedate']])) {
			$basedate = $messageProps[$this->proptags['basedate']];
			// Get the goid2 from recurring MR which further used to
			// check the resource conflicts item.
			$recurrItemProps = mapi_getprops($this->message, [$this->proptags['goid2']]);
			$recurrenceHelper = new Recurrence($this->store, $this->message);
			$messageProps[$this->proptags['goid']] = $this->setBasedateInGlobalID($recurrItemProps[$this->proptags['goid2']], $basedate, $recurrenceHelper);
			$messageProps[$this->proptags['goid2']] = $recurrItemProps[$this->proptags['goid2']];
		}
		return $this->hasCalendarConflict($items, $messageProps, true);
	}

	private function countRecurringConflicts(mixed $message, mixed $userStore, mixed $calFolder, array $messageProps): false|int {
		$noOfInstances = 0;
		// Apply recurrence class and retrieve all occurrences(max: 30 occurrence because recurrence can also be set as 'no end date')
		$recurr = new Recurrence($userStore, $message);
		try {
			$items = $recurr->getItems($messageProps[$this->proptags['clipstart']], $messageProps[$this->proptags['clipend']] * (24 * 24 * 60), 30);
		}
		catch (RecurrenceException $re) {
			error_log(sprintf(
				"isMeetingConflicting RecurrenceException (%d) for item '%s' - %s - %s",
				$re->getCode(),
				$messageProps[PR_SUBJECT] ?? '<empty subject>',
				bin2hex($messageProps[PR_ENTRYID]),
				bin2hex($messageProps[$this->proptags['recurrence_data']])
			));
			$re->setHandled();

			return false;
		}

		foreach ($items as $item) {
			// Get all items in the timeframe that we want to book, and get the goid and busystatus for each item
			$calendarItems = $recurr->getCalendarItems($userStore, $calFolder, $item[$this->proptags['startdate']], $item[$this->proptags['duedate']], [$this->proptags['goid'], $this->proptags['busystatus']]);

			if ($this->hasCalendarConflict($calendarItems, $messageProps, false)) {
				++$noOfInstances;
			}
		}

		return $noOfInstances ?: false;
	}

	private function hasCalendarConflict(array $items, array $messageProps, bool $checkCleanId): bool {
		foreach ($items as $item) {
			if ($item[$this->proptags['busystatus']] === fbFree) {
				continue;
			}
			/*
			 * Only meeting requests have globalID, normal appointments do not have globalID
			 * so if any normal appointment if found then it is assumed to be conflict.
			 */
			if (!isset($item[$this->proptags['goid']])) {
				return true;
			}
			if ($item[$this->proptags['goid']] !== $messageProps[$this->proptags['goid']] &&
				(!$checkCleanId || $item[$this->proptags['goid']] !== $messageProps[$this->proptags['goid2']])) {
				return true;
			}
		}

		return false;
	}

	/**
	 * Function which adds organizer to recipient list which is passed.
	 * This function also checks if it has organizer.
	 *
	 * @param array $messageProps message properties
	 * @param array $recipients   recipients list of message
	 */
	public function addDelegator(array $messageProps, array &$recipients): void {
		$hasDelegator = false;
		// gromox stamps the delegator as an EX address, the request lists it as SMTP
		$delegatorRow = [
			PR_ENTRYID => $messageProps[PR_RCVD_REPRESENTING_ENTRYID] ?? null,
			PR_EMAIL_ADDRESS => $messageProps[PR_RCVD_REPRESENTING_EMAIL_ADDRESS] ?? null,
			PR_ADDRTYPE => $messageProps[PR_RCVD_REPRESENTING_ADDRTYPE] ?? null,
		];
		foreach ($recipients as $recipient) {
			if ($this->compareRecipients($recipient, array_filter($delegatorRow))) {
				$hasDelegator = true;
			}
		}

		if (!$hasDelegator) {
			// Create delegator.
			$delegator = [];
			$delegator[PR_ENTRYID] = $messageProps[PR_RCVD_REPRESENTING_ENTRYID];
			$delegator[PR_DISPLAY_NAME] = $messageProps[PR_RCVD_REPRESENTING_NAME];
			$delegator[PR_EMAIL_ADDRESS] = $messageProps[PR_RCVD_REPRESENTING_EMAIL_ADDRESS];
			$delegator[PR_RECIPIENT_TYPE] = MAPI_TO;
			$delegator[PR_RECIPIENT_DISPLAY_NAME] = $messageProps[PR_RCVD_REPRESENTING_NAME];
			$delegator[PR_ADDRTYPE] = empty($messageProps[PR_RCVD_REPRESENTING_ADDRTYPE]) ? 'SMTP' : $messageProps[PR_RCVD_REPRESENTING_ADDRTYPE];
			$delegator[PR_RECIPIENT_TRACKSTATUS] = olRecipientTrackStatusNone;
			$delegator[PR_RECIPIENT_FLAGS] = recipSendable;
			$delegator[PR_SEARCH_KEY] = $messageProps[PR_RCVD_REPRESENTING_SEARCH_KEY];

			// Add organizer to recipients list.
			array_unshift($recipients, $delegator);
		}
	}

	/**
	 * Function will return delegator's store and calendar folder for processing meetings.
	 *
	 * @param string $receivedRepresentingEntryId entryid of the delegator user
	 * @param array  $foldersToOpen               contains list of folder types that should be returned in result
	 *
	 * @return resource[] contains store of the delegator and resource of folders if $foldersToOpen is not empty
	 *
	 * @psalm-return array<resource>
	 */
	public function getDelegatorStore($receivedRepresentingEntryId, $foldersToOpen = []): array {
		$returnData = [];

		$delegatorStore = $this->openCustomUserStore($receivedRepresentingEntryId);
		$returnData['store'] = $delegatorStore;

		if (!empty($foldersToOpen)) {
			for ($index = 0, $len = count($foldersToOpen); $index < $len; ++$index) {
				$folderType = $foldersToOpen[$index];

				// first try with default folders
				$folder = $this->openDefaultFolder($folderType, $delegatorStore);

				// if folder not found then try with base folders
				if ($folder === false) {
					$folder = $this->openBaseFolder($folderType, $delegatorStore);
				}

				if ($folder === false) {
					// we are still not able to get the folder so give up
					continue;
				}

				$returnData[$folderType] = $folder;
			}
		}

		return $returnData;
	}

	/**
	 * Function returns extra info about meeting timing along with message body
	 * which will be included in body while sending meeting request/response.
	 *
	 * @return false|string $meetingTimeInfo info about meeting timing along with message body
	 */
	public function getMeetingTimeInfo(): false|string {
		return $this->meetingTimeInfo;
	}

	/**
	 * Function sets extra info about meeting timing along with message body
	 * which will be included in body while sending meeting request/response.
	 *
	 * @param string $meetingTimeInfo info about meeting timing along with message body
	 */
	public function setMeetingTimeInfo(false|string $meetingTimeInfo, bool $html = false): void {
		$this->meetingTimeInfo = $meetingTimeInfo;
		$this->mti_html = $html;
	}

	/**
	 * Get the attendee's local categories from the series master.
	 *
	 * @param mixed $calendarItem     meeting request item
	 * @param mixed $store            store containing calendar folder
	 * @param mixed $calFolder        calendar folder
	 * @param bool  $nonRecurr2Recurr whether a non-recurring meeting was converted to a recurring
	 *
	 * @return array local categories of the series
	 */
	public function getLocalCategories(mixed $calendarItem, mixed $store, mixed $calFolder, bool &$nonRecurr2Recurr): array {
		$calendarItemProps = mapi_getprops($calendarItem);
		// There's a corner case that a non-recurring meeting was converted to a
		// recurring meeting. In such a case the calendar item doesn't have the
		// recurrence information yet.
		if (!isset($calendarItemProps[$this->proptags['recurring']]) || $calendarItemProps[$this->proptags['recurring']] === false) {
			$nonRecurr2Recurr = true;

			return $calendarItemProps[$this->proptags['categories']] ?? [];
		}

		return $calendarItemProps[$this->proptags['categories']] ?? [];
	}

	/**
	 * Apply the attendee's local categories to the series master.
	 *
	 * @param mixed $calendarItem    meeting request item
	 * @param mixed $store           store containing calendar folder
	 * @param array $localCategories local categories of the series
	 */
	public function applyLocalCategories(mixed $calendarItem, mixed $store, array $localCategories): void {
		mapi_setprops($calendarItem, [$this->proptags['categories'] => $localCategories]);
		mapi_savechanges($calendarItem);
	}

	/**
	 * Check if a message is from a delegate (received representing someone else).
	 *
	 * @param array $messageprops Message properties
	 *
	 * @return bool True if message is from delegate
	 */
	private function isMessageFromDelegate(array $messageprops): bool {
		// gromox stamps PR_RCVD_REPRESENTING on every delivered message
		return $this->getDelegatorEntryId($messageprops) !== false;
	}

	/**
	 * Calculate the busy status for an accepted meeting based on tentative flag and intended status.
	 *
	 * @param bool  $tentative Whether acceptance is tentative
	 * @param array $props     Message properties containing intended busy status
	 *
	 * @return int The calculated busy status
	 */
	private function calculateBusyStatus(bool $tentative, array $props): int {
		if (isset($props[$this->proptags['intendedbusystatus']])) {
			if ($tentative && $props[$this->proptags['intendedbusystatus']] !== fbFree) {
				return fbTentative;
			}

			return $props[$this->proptags['intendedbusystatus']];
		}

		return $tentative ? fbTentative : fbBusy;
	}

	/**
	 * Set reply time and name properties when user responds to a meeting.
	 *
	 * @param array $props Properties array to update (passed by reference)
	 */
	private function setReplyTimeAndName(array &$props): void {
		$addrInfo = $this->getOwnerAddress($this->store);

		// if user has responded then set replytime and name
		$props[$this->proptags['replytime']] = time();
		if (!empty($addrInfo)) {
			// @FIXME conditionally set this property only for delegation case
			$props[$this->proptags['apptreplyname']] = $addrInfo[0];
		}
	}

	/**
	 * Correct the flagdueby (reminder time) property.
	 * Some clients (mainly OL) can generate wrong flagdueby time, so regenerate it.
	 *
	 * @param array $props Properties array to update (passed by reference)
	 */
	private function correctReminderTime(array &$props): void {
		if (isset($props[$this->proptags['reminderminutes']])) {
			$props[$this->proptags['flagdueby']] = $props[$this->proptags['startdate']] - ($props[$this->proptags['reminderminutes']] * 60);
		}
	}

	/**
	 * Determine the appropriate response status based on user action and tentative flag.
	 *
	 * @param bool $userAction Whether this is a user-initiated action
	 * @param bool $tentative  Whether the response is tentative
	 *
	 * @return int The response status constant
	 */
	private function determineResponseStatus(bool $userAction, bool $tentative): int {
		if (!$userAction) {
			return olResponseNotResponded;
		}

		return $tentative ? olResponseTentative : olResponseAccepted;
	}

	/**
	 * Sets sender or representing address properties in message props.
	 *
	 * @param array  $messageprops reference to message properties array
	 * @param array  $addrInfo     address info array from getOwnerAddress
	 * @param string $prefix       property prefix ('SENDER' or 'SENT_REPRESENTING')
	 */
	private function setAddressProperties(array &$messageprops, array $addrInfo, string $prefix): void {
		if (empty($addrInfo)) {
			return;
		}

		[$ownername, $owneremailaddr, $owneraddrtype, $ownerentryid, $ownersearchkey] = $addrInfo;

		$messageprops[constant("PR_{$prefix}_EMAIL_ADDRESS")] = $owneremailaddr;
		$messageprops[constant("PR_{$prefix}_NAME")] = $ownername;
		$messageprops[constant("PR_{$prefix}_ADDRTYPE")] = $owneraddrtype;
		$messageprops[constant("PR_{$prefix}_ENTRYID")] = $ownerentryid;
		$messageprops[constant("PR_{$prefix}_SEARCH_KEY")] = $ownersearchkey;
	}

	/**
	 * Resolves the appropriate store and calendar folder for delegate scenarios.
	 *
	 * When a meeting request is received by a delegate, this method opens the
	 * delegator's store and calendar folder instead of the delegate's own.
	 *
	 * @param array $messageprops message properties containing delegate information
	 *
	 * @return array{store: mixed, calFolder: mixed} array with 'store' and 'calFolder' keys
	 */
	private function resolveDelegateStoreAndCalendar(array $messageprops): array {
		$store = $this->store;
		$calFolder = $this->openDefaultCalendar();

		// A meeting addressed to somebody else belongs in their calendar, whether
		// it was opened in their inbox or in the copy a delegate received.
		$delegator = $this->getDelegatorEntryId($messageprops);
		if ($delegator !== false) {
			$delegatorStore = $this->getDelegatorStore($delegator, [PR_IPM_APPOINTMENT_ENTRYID]);
			if (!empty($delegatorStore['store'])) {
				$store = $delegatorStore['store'];
			}
			if (!empty($delegatorStore[PR_IPM_APPOINTMENT_ENTRYID])) {
				$calFolder = $delegatorStore[PR_IPM_APPOINTMENT_ENTRYID];
			}
		}

		return ['store' => $store, 'calFolder' => $calFolder];
	}

	/**
	 * The address book entryid of the mailbox this message was addressed to when
	 * that is somebody other than the acting user, false otherwise.
	 *
	 * PR_RECEIVED_BY is no help in telling the two apart: gromox stamps it with
	 * the delegator on the copy a delegate receives, exactly like
	 * PR_RCVD_REPRESENTING. The acting user is what the message has to be
	 * measured against.
	 */
	private function getDelegatorEntryId(array $messageprops): false|string {
		$representing = $messageprops[PR_RCVD_REPRESENTING_ENTRYID] ?? false;
		if (empty($representing)) {
			return false;
		}

		$userStore = $this->openDefaultStore();
		if ($userStore === false) {
			return false;
		}
		$userProps = mapi_getprops($userStore, [PR_MAILBOX_OWNER_ENTRYID]);
		if (empty($userProps[PR_MAILBOX_OWNER_ENTRYID])) {
			return false;
		}

		return $this->compareABEntryIDs($representing, $userProps[PR_MAILBOX_OWNER_ENTRYID]) ?
			false : $representing;
	}

	/**
	 * The organizer of the meeting as a recipient row that has PR_SMTP_ADDRESS: the sender
	 * of the meeting, else its organizer recipient, else the owner of the store when the
	 * meeting is organized there.
	 *
	 * @return array|false false when the organizer is unknown
	 */
	private function getMeetingOrganizer(): array|false {
		$messageprops = mapi_getprops($this->message, [
			PR_SENT_REPRESENTING_ENTRYID,
			PR_SENT_REPRESENTING_NAME,
			PR_SENT_REPRESENTING_EMAIL_ADDRESS,
			PR_SENT_REPRESENTING_ADDRTYPE,
			PR_SENT_REPRESENTING_SEARCH_KEY,
			PR_SENT_REPRESENTING_SMTP_ADDRESS,
		]);

		$organizer = false;
		if (!empty($messageprops[PR_SENT_REPRESENTING_EMAIL_ADDRESS])) {
			$organizer = [
				PR_ENTRYID => $messageprops[PR_SENT_REPRESENTING_ENTRYID] ?? null,
				PR_DISPLAY_NAME => $messageprops[PR_SENT_REPRESENTING_NAME] ?? '',
				PR_EMAIL_ADDRESS => $messageprops[PR_SENT_REPRESENTING_EMAIL_ADDRESS],
				PR_ADDRTYPE => $messageprops[PR_SENT_REPRESENTING_ADDRTYPE] ?? 'SMTP',
				PR_SEARCH_KEY => $messageprops[PR_SENT_REPRESENTING_SEARCH_KEY] ?? null,
				PR_SMTP_ADDRESS => $messageprops[PR_SENT_REPRESENTING_SMTP_ADDRESS] ?? null,
			];
		}
		else {
			foreach ($this->getMessageRecipients($this->message) as $recip) {
				if (($recip[PR_RECIPIENT_FLAGS] ?? 0) & recipOrganizer) {
					$organizer = $recip;
					break;
				}
			}
		}

		if ($organizer === false && $this->isLocalOrganiser()) {
			$ownerDetails = $this->getOwnerAddress($this->store, false);
			if ($ownerDetails !== false) {
				$organizer = [
					PR_DISPLAY_NAME => $ownerDetails[0],
					PR_EMAIL_ADDRESS => $ownerDetails[1],
					PR_ADDRTYPE => $ownerDetails[2],
					PR_ENTRYID => $ownerDetails[3],
					PR_SEARCH_KEY => $ownerDetails[4],
				];
			}
		}
		if ($organizer === false) {
			return false;
		}

		$organizer[PR_SMTP_ADDRESS] = $this->getRecipientSMTPAddress($organizer);
		if ($organizer[PR_SMTP_ADDRESS] === '') {
			return false;
		}
		$organizer[PR_ENTRYID] ??= mapi_createoneoff($organizer[PR_DISPLAY_NAME] ?? '', 'SMTP', $organizer[PR_SMTP_ADDRESS]);

		return $organizer;
	}

	/**
	 * The exception and the properties of the occurrence of a series that is forwarded,
	 * as a forwarded occurrence is a meeting of its own.
	 *
	 * @param false|int $basedate basedate of the occurrence, false for the whole meeting
	 *
	 * @return array the exception message or false, and the properties of the occurrence
	 *               (empty when the whole meeting is forwarded)
	 *
	 * @throws MAPIException with MAPI_E_NOT_FOUND for a deleted occurrence
	 */
	private function getForwardOccurrence(false|int $basedate): array {
		$messageprops = mapi_getprops($this->message, [$this->proptags['recurring'], $this->proptags['goid2']]);
		if ($basedate === false || empty($messageprops[$this->proptags['recurring']])) {
			return [false, []];
		}

		$recurr = new Recurrence($this->store, $this->message);
		if ($recurr->isDeleteException($basedate)) {
			throw new MAPIException(_('The occurrence has been deleted'), MAPI_E_NOT_FOUND);
		}

		$props = [
			$this->proptags['basedate'] => $recurr->getOccurrenceStart($basedate),
			$this->proptags['startdate'] => $recurr->getOccurrenceStart($basedate),
			$this->proptags['duedate'] => $recurr->getOccurrenceEnd($basedate),
			$this->proptags['recurring'] => false,
			$this->proptags['meetingrecurring'] => true,
			$this->proptags['is_exception'] => true,
			$this->proptags['forward_instance'] => true,
		];
		if (isset($messageprops[$this->proptags['goid2']])) {
			$props[$this->proptags['goid']] = $this->setBasedateInGlobalID($messageprops[$this->proptags['goid2']], $basedate);
		}

		$exception = false;
		$attach = $recurr->getExceptionAttachment($basedate);
		if ($attach) {
			$exception = mapi_attach_openobj($attach, 0);
			$props = mapi_getprops($exception, [
				PR_SUBJECT,
				$this->proptags['startdate'],
				$this->proptags['duedate'],
				$this->proptags['location'],
				$this->proptags['busystatus'],
			]) + $props;
		}
		$props[$this->proptags['commonstart']] = $props[$this->proptags['startdate']];
		$props[$this->proptags['commonend']] = $props[$this->proptags['duedate']];

		return [$exception, $props];
	}

	/**
	 * The address book entry of a local user.
	 *
	 * @param string $smtp SMTP address of the user
	 *
	 * @return array|false resolved address book row, false for an unknown or external address
	 */
	private function resolveAddress(string $smtp): array|false {
		if (!$this->session || $smtp === '') {
			return false;
		}

		try {
			$rows = mapi_ab_resolvename($this->openAddressBook(), [[PR_DISPLAY_NAME => $smtp]], EMS_AB_ADDRESS_LOOKUP);
		}
		catch (MAPIException $e) {
			$e->setHandled();

			return false;
		}

		return isset($rows[0][PR_ENTRYID]) && strcasecmp($rows[0][PR_ADDRTYPE] ?? '', 'EX') == 0 ? $rows[0] : false;
	}

	/**
	 * Recipient rows of the attendees listed in a meeting forward notification.
	 *
	 * @param array $messageprops properties of the meeting forward notification
	 *
	 * @return array optional attendees addressed by SMTP
	 */
	private function getForwardRecipientRows(array $messageprops): array {
		$blob = (string) ($messageprops[$this->proptags['forward_notification_recipients']] ?? '');
		$rows = [];
		foreach (unpackForwardNotificationRecipients($blob) as [$addrtype, $smtp, $name]) {
			$smtp = trim($smtp);
			if ($smtp === '' || strcasecmp($addrtype, 'SMTP') != 0) {
				continue;
			}
			$name = trim($name);
			$rows[] = [
				PR_DISPLAY_NAME => $name !== '' ? $name : $smtp,
				PR_RECIPIENT_DISPLAY_NAME => $name !== '' ? $name : $smtp,
				PR_EMAIL_ADDRESS => $smtp,
				PR_SMTP_ADDRESS => $smtp,
				PR_ADDRTYPE => 'SMTP',
				PR_RECIPIENT_TYPE => MAPI_CC,
				PR_RECIPIENT_FLAGS => recipSendable,
				PR_RECIPIENT_TRACKSTATUS => olRecipientTrackStatusNone,
			];
		}

		return $rows;
	}

	/**
	 * The forwarded attendees that are not attendees of the meeting yet.
	 *
	 * @param array $existing  recipient rows of the meeting
	 * @param array $forwarded recipient rows of the forwarded attendees
	 *
	 * @return array rows of $forwarded, each address once
	 */
	private function getNewForwardRecipients(array $existing, array $forwarded): array {
		// the forwarded rows carry an SMTP address and no entryid, so
		// compareRecipients() would match them by that address alone
		$known = [];
		foreach ($existing as $recip) {
			$smtp = $this->getRecipientSMTPAddress($recip);
			if ($smtp !== '') {
				$known[strtolower($smtp)] = true;
			}
		}
		$new = [];
		foreach ($forwarded as $recip) {
			$smtp = strtolower($recip[PR_SMTP_ADDRESS]);
			if (isset($known[$smtp])) {
				continue;
			}
			$known[$smtp] = true;
			$new[] = $recip;
		}

		return $new;
	}

	/**
	 * Addresses a forwarded attendee by the address book entry when it is a local user,
	 * else by a one-off entryid.
	 *
	 * @param array $recip recipient row from getForwardRecipientRows()
	 *
	 * @return array the recipient row with PR_ENTRYID
	 */
	private function resolveForwardRecipient(array $recip): array {
		$resolved = $this->resolveAddress($recip[PR_SMTP_ADDRESS]);
		if ($resolved === false) {
			$recip[PR_ENTRYID] = mapi_createoneoff($recip[PR_DISPLAY_NAME], 'SMTP', $recip[PR_SMTP_ADDRESS]);

			return $recip;
		}

		$recip[PR_ENTRYID] = $resolved[PR_ENTRYID];
		$recip[PR_EMAIL_ADDRESS] = $resolved[PR_EMAIL_ADDRESS] ?? $recip[PR_EMAIL_ADDRESS];
		$recip[PR_ADDRTYPE] = $resolved[PR_ADDRTYPE];
		if (isset($resolved[PR_SEARCH_KEY])) {
			$recip[PR_SEARCH_KEY] = $resolved[PR_SEARCH_KEY];
		}

		return $recip;
	}

	/**
	 * The timezone a meeting is shown in and the name of it, from
	 * PidLidAppointmentTimeZoneDefinitionStartDisplay or PidLidTimeZoneStruct.
	 *
	 * @param array $messageprops properties of the meeting
	 *
	 * @return array the timezone or null when the meeting has none, and its name
	 */
	private function getMeetingTimezone(array $messageprops): array {
		$tzdef = parseTimezoneDefinition($messageprops[$this->proptags['tzdefstart']] ?? null);
		if (getEffectiveTimezoneRule($tzdef) !== null) {
			return [TimezoneUtil::GetTzFromTimezoneDef($tzdef), (string) iconv('UTF-16LE', 'UTF-8', $tzdef['keyname'])];
		}

		$tzstruct = (string) ($messageprops[$this->proptags['timezone_data']] ?? '');
		if (strlen($tzstruct) >= 48) {
			return [TimezoneUtil::GetTzFromTimezoneStruct($tzstruct), (string) ($messageprops[$this->proptags['timezone']] ?? '')];
		}

		return [null, ''];
	}

	/**
	 * Start and end of a meeting in its timezone, which is named, or in UTC.
	 *
	 * @param int        $start start of the meeting (UTC)
	 * @param int        $end   end of the meeting (UTC)
	 * @param null|array $tz    timezone of the meeting
	 * @param string     $zone  name of the timezone, the offset to UTC is shown without one
	 */
	private function formatMeetingTime(int $start, int $end, ?array $tz, string $zone): string {
		if ($tz === null) {
			$zone = 'UTC';
		}
		elseif ($zone === '') {
			$offset = -TimezoneUtil::GetBiasAtUtc($start, $tz);
			$zone = sprintf('UTC%s%02d:%02d', $offset < 0 ? '-' : '+', intdiv((int) abs($offset), 60), abs($offset) % 60);
		}
		$localStart = TimezoneUtil::GetLocalTimeByTz($start, $tz);
		$localEnd = TimezoneUtil::GetLocalTimeByTz($end, $tz);

		$text = gmdate(_('d/m/Y'), $localStart) . ' ' . gmdate(_('G:i'), $localStart) . ' - ';
		if (gmdate('Ymd', $localStart) !== gmdate('Ymd', $localEnd)) {
			$text .= gmdate(_('d/m/Y'), $localEnd) . ' ';
		}

		return $text . gmdate(_('G:i'), $localEnd) . ' (' . $zone . ')';
	}

	/**
	 * Marks the message as processed.
	 */
	private function setProcessed(): void {
		mapi_setprops($this->message, [PR_PROCESSED => true]);
		mapi_savechanges($this->message);
	}

	private function getAcceptedRecipients(mixed $message, bool $isDelegate, mixed $delegateMessage): array {
		if (!$isDelegate) {
			return $this->getMessageRecipients($message);
		}
		$delegate = mapi_getprops($delegateMessage, [PR_RECEIVED_BY_EMAIL_ADDRESS]);
		$restriction = [RES_PROPERTY, [
			RELOP => RELOP_NE,
			ULPROPTAG => PR_EMAIL_ADDRESS,
			VALUE => [PR_EMAIL_ADDRESS => $delegate[PR_RECEIVED_BY_EMAIL_ADDRESS]],
		]];

		return $this->getMessageRecipients($message, $restriction);
	}

	/**
	 * Gets all recipients from a message.
	 *
	 * @param resource $message     the message to get recipients from
	 * @param array    $restriction optional restriction to filter recipients
	 *
	 * @return array array of recipient rows
	 */
	private function getMessageRecipients(mixed $message, ?array $restriction = null): array {
		$recipientTable = mapi_message_getrecipienttable($message);

		return empty($restriction) ?
			mapi_table_queryallrows($recipientTable, $this->recipprops) :
			mapi_table_queryallrows($recipientTable, $this->recipprops, $restriction);
	}

	/**
	 * Ensures calendar write access and throws exception if denied.
	 *
	 * @param mixed $store the store to check calendar write access for
	 *
	 * @throws MAPIException with MAPI_E_NO_ACCESS if write access is denied
	 */
	private function ensureCalendarWriteAccess(mixed $store): void {
		if ($this->checkCalendarWriteAccess($store) !== true) {
			throw new MAPIException(_("Insufficient permissions"), MAPI_E_NO_ACCESS);
		}
	}
}