<?php

namespace DirectoryTree\ImapEngine;

use BackedEnum;

use Carbon\Carbon;

use Carbon\CarbonInterface;

use DirectoryTree\ImapEngine\Connection\Responses\Data\ListData;

use DirectoryTree\ImapEngine\Connection\Responses\MessageResponseParser;

use DirectoryTree\ImapEngine\Exceptions\ImapCapabilityException;

use DirectoryTree\ImapEngine\Support\Str;

use Illuminate\Contracts\Support\Arrayable;

use JsonSerializable;

use ZBateson\MailMimeParser\Header\DateHeader;

use ZBateson\MailMimeParser\Header\HeaderConsts;

use ZBateson\MailMimeParser\Header\IHeader;

use ZBateson\MailMimeParser\Header\IHeaderPart;

use ZBateson\MailMimeParser\Header\Part\AddressPart;

use ZBateson\MailMimeParser\Header\Part\ContainerPart;

use ZBateson\MailMimeParser\Header\Part\NameValuePart;

class Message implements Arrayable, JsonSerializable, MessageInterface

{

use HasFlags, HasParsedMessage;

/**

* The parsed body structure.

*/

protected ?BodyStructureCollection $bodyStructure = null;

/**

* Constructor.

*/

public function __construct(

protected FolderInterface $folder,

protected int $uid,

protected array $flags,

protected string $head,

protected string $body,

protected ?int $size = null,

protected ?ListData $bodyStructureData = null,

) {}

/**

* Get the names of properties that should be serialized.

*/

public function __sleep(): array

{

// We don't want to serialize the parsed message.

return ['folder', 'uid', 'flags', 'head', 'body', 'size'];

}

/**

* Get the message's folder.

*/

public function folder(): FolderInterface

{

return $this->folder;

}

/**

* Get the message's identifier.

*/

public function uid(): int

{

return $this->uid;

}

/**

* Get the message's size in bytes (RFC822.SIZE).

*/

public function size(): ?int

{

return $this->size;

}

/**

* Get the message's flags.

*/

public function flags(): array

{

return $this->flags;

}

/**

* Get the message's raw headers.

*/

public function head(bool $fetch = false): string

{

if (! $this->head && $fetch) {

$this->head = $this->fetchHead() ?? '';

}

return $this->head;

}

/**

* Determine if the message has headers.

*/

public function hasHead(): bool

{

return ! empty($this->head);

}

/**

* Get the message's raw body.

*/

public function body(): string

{

return $this->body;

}

/**

* Determine if the message has contents.

*/

public function hasBody(): bool

{

return ! empty($this->body);

}

/**

* Get the message's body structure.

*/

public function bodyStructure(bool $fetch = false): ?BodyStructureCollection

{

if ($this->bodyStructure) {

return $this->bodyStructure;

}

if (! $this->bodyStructureData && $fetch) {

$this->bodyStructureData = $this->fetchBodyStructureData();

}

if (! $tokens = $this->bodyStructureData?->tokens()) {

return null;

}

// If the first token is a list, it's a multipart message.

return $this->bodyStructure = head($tokens) instanceof ListData

? BodyStructureCollection::fromListData($this->bodyStructureData)

: new BodyStructureCollection(parts: [BodyStructurePart::fromListData($this->bodyStructureData)]);

}

/**

* Determine if the message has body structure data.

*/

public function hasBodyStructure(): bool

{

return (bool) $this->bodyStructureData;

}

/**

* {@inheritDoc}

*/

public function is(MessageInterface $message): bool

{

return $message instanceof self

&& $this->uid === $message->uid

&& $this->folder->is($message->folder);

}

/**

* Add or remove a flag from the message.

*/

public function flag(BackedEnum|string $flag, string $operation, bool $expunge = false): void

{

$flag = Str::enum($flag);

$this->folder->mailbox()

->connection()

->store($flag, $this->uid, mode: $operation);

if ($expunge) {

$this->folder->expunge();

}

$this->flags = match ($operation) {

'+' => array_unique(array_merge($this->flags, [$flag])),

'-' => array_diff($this->flags, [$flag]),

};

}

/**

* Copy the message to the given folder.

*/

public function copy(string $folder): ?int

{

$mailbox = $this->folder->mailbox();

$capabilities = $mailbox->capabilities();

if (! in_array('UIDPLUS', $capabilities)) {

throw new ImapCapabilityException(

'Unable to copy message. IMAP server does not support UIDPLUS capability'

);

}

$response = $mailbox->connection()->copy($folder, $this->uid);

return MessageResponseParser::getUidFromCopy($response);

}

/**

* Move the message to the given folder.

*

* @throws ImapCapabilityException

*/

public function move(string $folder, bool $expunge = false): ?int

{

$mailbox = $this->folder->mailbox();

$capabilities = $mailbox->capabilities();

switch (true) {

case in_array('MOVE', $capabilities):

$response = $mailbox->connection()->move($folder, $this->uid);

if ($expunge) {

$this->folder->expunge();

}

return MessageResponseParser::getUidFromCopy($response);

case in_array('UIDPLUS', $capabilities):

$uid = $this->copy($folder);

$this->delete($expunge);

return $uid;

default:

throw new ImapCapabilityException(

'Unable to move message. IMAP server does not support MOVE or UIDPLUS capabilities'

);

}

}

/**

* Get a header from the message.

*/

public function header(string $name, int $offset = 0, bool $fetch = false): ?IHeader

{

if ($fetch && ! $this->hasHead()) {

$this->head(fetch: true);

}

if ($this->isEmpty()) {

return null;

}

return $this->parse()->getHeader($name, $offset);

}

/**

* Get the message date and time.

*/

public function date(bool $fetch = false): ?CarbonInterface

{

if (! $header = $this->header(HeaderConsts::DATE, fetch: $fetch)) {

return null;

}

if (! $header instanceof DateHeader) {

return null;

}

if (! $date = $header->getDateTime()) {

return null;

}

return Carbon::instance($date);

}

/**

* Get the message's message-id.

*/

public function messageId(bool $fetch = false): ?string

{

return $this->header(HeaderConsts::MESSAGE_ID, fetch: $fetch)?->getValue();

}

/**

* Get the message's subject.

*/

public function subject(bool $fetch = false): ?string

{

return $this->header(HeaderConsts::SUBJECT, fetch: $fetch)?->getValue();

}

/**

* Get the FROM address.

*/

public function from(bool $fetch = false): ?Address

{

return head($this->addresses(HeaderConsts::FROM, fetch: $fetch)) ?: null;

}

/**

* Get the SENDER address.

*/

public function sender(bool $fetch = false): ?Address

{

return head($this->addresses(HeaderConsts::SENDER, fetch: $fetch)) ?: null;

}

/**

* Get the REPLY-TO address.

*/

public function replyTo(bool $fetch = false): ?Address

{

return head($this->addresses(HeaderConsts::REPLY_TO, fetch: $fetch)) ?: null;

}

/**

* Get the IN-REPLY-TO message identifier(s).

*

* @return string[]

*/

public function inReplyTo(bool $fetch = false): array

{

$parts = $this->header(HeaderConsts::IN_REPLY_TO, fetch: $fetch)?->getParts() ?? [];

$values = array_map(fn (IHeaderPart $part) => $part->getValue(), $parts);

return array_values(array_filter($values));

}

/**

* Get the TO addresses.

*

* @return Address[]

*/

public function to(bool $fetch = false): array

{

return $this->addresses(HeaderConsts::TO, fetch: $fetch);

}

/**

* Get the CC addresses.

*

* @return Address[]

*/

public function cc(bool $fetch = false): array

{

return $this->addresses(HeaderConsts::CC, fetch: $fetch);

}

/**

* Get the BCC addresses.

*

* @return Address[]

*/

public function bcc(bool $fetch = false): array

{

return $this->addresses(HeaderConsts::BCC, fetch: $fetch);

}

/**

* Get addresses from the given header.

*

* @return Address[]

*/

public function addresses(string $header, bool $fetch = false): array

{

$parts = $this->header($header, fetch: $fetch)?->getParts() ?? [];

$addresses = array_map(fn (IHeaderPart $part) => match (true) {

$part instanceof AddressPart => new Address($part->getEmail(), $part->getName()),

$part instanceof NameValuePart => new Address($part->getName(), $part->getValue()),

$part instanceof ContainerPart => new Address($part->getValue(), ''),

default => null,

}, $parts);

return array_filter($addresses);

}

/**

* Get the message's text content.

*/

public function text(bool $fetch = false): ?string

{

if ($fetch && ! $this->hasBody()) {

if ($part = $this->bodyStructure(fetch: true)?->text()) {

return Support\BodyPartDecoder::text($part, $this->bodyPart($part->partNumber()));

}

}

if ($this->isEmpty()) {

return null;

}

return $this->parse()->getTextContent();

}

/**

* Get the message's HTML content.

*/

public function html(bool $fetch = false): ?string

{

if ($fetch && ! $this->hasBody()) {

if ($part = $this->bodyStructure(fetch: true)?->html()) {

return Support\BodyPartDecoder::text($part, $this->bodyPart($part->partNumber()));

}

}

if ($this->isEmpty()) {

return null;

}

return $this->parse()->getHtmlContent();

}

/**

* Get the message's attachments.

*

* @return Attachment[]

*/

public function attachments(bool $fetch = false): array

{

if ($fetch && ! $this->hasBody()) {

return Attachment::lazy($this);

}

if ($this->isEmpty()) {

return [];

}

return Attachment::parsed($this);

}

/**

* Determine if the message has attachments.

*/

public function hasAttachments(): bool

{

return $this->attachmentCount() > 0;

}

/**

* Get the count of attachments.

*/

public function attachmentCount(): int

{

if ($this->isEmpty()) {

return 0;

}

return $this->parse()->getAttachmentCount();

}

/**

* Fetch a specific body part by part number.

*/

public function bodyPart(string $partNumber, bool $peek = true): ?string

{

$response = $this->folder->mailbox()

->connection()

->bodyPart($partNumber, $this->uid, $peek);

if ($response->isEmpty()) {

return null;

}

$data = $response->first()->tokenAt(3);

if (! $data instanceof ListData) {

return null;

}

return $data->lookup("[$partNumber]")?->value;

}

/**

* Delete the message.

*/

public function delete(bool $expunge = false): void

{

$this->markDeleted($expunge);

}

/**

* Restore the message.

*/

public function restore(): void

{

$this->unmarkDeleted();

}

/**

* Get the array representation of the message.

*/

public function toArray(): array

{

return [

'uid' => $this->uid,

'flags' => $this->flags,

'head' => $this->head,

'body' => $this->body,

'size' => $this->size,

];

}

/**

* Get the string representation of the message.

*/

public function __toString(): string

{

return implode("\r\n\r\n", array_filter([

rtrim($this->head),

ltrim($this->body),

]));

}

/**

* Get the JSON representation of the message.

*/

public function jsonSerialize(): array

{

return $this->toArray();

}

/**

* Determine if the message is empty.

*/

public function isEmpty(): bool

{

return ! $this->hasHead() && ! $this->hasBody();

}

/**

* Fetch the headers from the server.

*/

protected function fetchHead(): ?string

{

$response = $this->folder

->mailbox()

->connection()

->bodyHeader($this->uid);

if ($response->isEmpty()) {

return null;

}

$data = $response->first()->tokenAt(3);

if (! $data instanceof ListData) {

return null;

}

return $data->lookup('[HEADER]')?->value;

}

/**

* Fetch the body structure data from the server.

*/

protected function fetchBodyStructureData(): ?ListData

{

$response = $this->folder

->mailbox()

->connection()

->bodyStructure($this->uid);

if ($response->isEmpty()) {

return null;

}

$data = $response->first()->tokenAt(3);

if (! $data instanceof ListData) {

return null;

}

return $data->lookup('BODYSTRUCTURE');

}

}