<?php
/************************************************************************
 * This file is part of EspoCRM.
 *
 * EspoCRM – Open Source CRM application.
 * Copyright (C) 2014-2026 EspoCRM, Inc.
 * Website: https://www.espocrm.com
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Affero General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU Affero General Public License for more details.
 *
 * You should have received a copy of the GNU Affero General Public License
 * along with this program. If not, see <https://www.gnu.org/licenses/>.
 *
 * The interactive user interfaces in modified source and object code versions
 * of this program must display Appropriate Legal Notices, as required under
 * Section 5 of the GNU Affero General Public License version 3.
 *
 * In accordance with Section 7(b) of the GNU Affero General Public License version 3,
 * these Appropriate Legal Notices must retain the display of the "EspoCRM" word.
 ************************************************************************/

namespace Espo\Core\Mail;

use Espo\Core\FileStorage\Manager as FileStorageManager;
use Espo\Core\Mail\Exceptions\NoSmtp;
use Espo\Core\Mail\Sender\AttachmentContainer;
use Espo\Core\Mail\Sender\MessageContainer;
use Espo\Core\Mail\Sender\TransportPreparatorFactory;
use Espo\Core\ORM\Repository\Option\SaveOption;
use Espo\ORM\EntityCollection;
use Espo\Core\Field\DateTime;
use Espo\Core\Utils\Config;
use Espo\Core\Utils\Log;
use Espo\Core\Mail\Account\SendingAccountProvider;
use Espo\Core\Mail\Exceptions\SendingError;
use Espo\Entities\Attachment;
use Espo\Entities\Email;
use Espo\ORM\EntityManager;

use Symfony\Component\Mailer\Envelope;
use Symfony\Component\Mailer\Exception\TransportExceptionInterface;
use Symfony\Component\Mailer\Transport\TransportInterface;
use Symfony\Component\Mime\Address;
use Symfony\Component\Mime\Email as Message;
use Symfony\Component\Mime\Part\DataPart;

use Exception;
use LogicException;
use InvalidArgumentException;

/**
 * Sends emails. Builds parameters for sending. Should not be used directly.
 */
class Sender
{
    private ?TransportInterface $transport = null;
    private bool $isGlobal = false;
    /** @var array<string, mixed> */
    private array $params = [];
    /** @var array<string, mixed> */
    private array $overrideParams = [];
    private ?string $envelopeFromAddress = null;
    /** @var ?iterable<Attachment|AttachmentContainer> */
    private $attachmentList = null;
    /** @var array{string, string}[] */
    private array $headers = [];
    private ?MessageContainer $messageContainer = null;

    private const ATTACHMENT_ATTR_CONTENTS = 'contents';

    public function __construct(
        private Config $config,
        private EntityManager $entityManager,
        private Log $log,
        private SendingAccountProvider $accountProvider,
        private FileStorageManager $fileStorageManager,
        private ConfigDataProvider $configDataProvider,
        private TransportPreparatorFactory $transportPreparatorFactory,
    ) {
        $this->useGlobal();
    }

    private function resetParams(): void
    {
        $this->params = [];
        $this->envelopeFromAddress = null;
        $this->attachmentList = null;
        $this->overrideParams = [];
        $this->headers = [];
        $this->messageContainer = null;
    }

    /**
     * With parameters.
     *
     * @param SenderParams|array<string, mixed> $params
     */
    public function withParams($params): self
    {
        if ($params instanceof SenderParams) {
            $params = $params->toArray();
        } else if (!is_array($params)) {
            throw new InvalidArgumentException();
        }

        $paramList = [
            'fromAddress',
            'fromName',
            'replyToAddress',
            'replyToName',
        ];

        foreach (array_keys($params) as $key) {
            if (!in_array($key, $paramList)) {
                unset($params[$key]);
            }
        }

        $this->overrideParams = array_merge($this->overrideParams, $params);

        return $this;
    }

    /**
     * With specific SMTP parameters.
     *
     * @param SmtpParams|array<string, mixed> $params
     */
    public function withSmtpParams($params): self
    {
        if ($params instanceof SmtpParams) {
            $params = $params->toArray();
        } else if (!is_array($params)) {
            throw new InvalidArgumentException();
        }
        return $this->useSmtp($params);
    }

    /**
     * With specific attachments.
     *
     * @param iterable<Attachment|AttachmentContainer> $attachmentList
     */
    public function withAttachments(iterable $attachmentList): self
    {
        $this->attachmentList = $attachmentList;

        return $this;
    }

    /**
     * With an envelope from address.
     *
     * @since 9.1.0
     */
    public function withEnvelopeFromAddress(string $fromAddress): void
    {
        $this->envelopeFromAddress = $fromAddress;
    }

    /**
     * @since 9.2.0
     * @internal
     */
    public function withMessageContainer(MessageContainer $messageContainer): self
    {
        $this->messageContainer = $messageContainer;

        return $this;
    }

    /**
     * Add a header.
     *
     * @param string $name A header name.
     * @param string $value A header value.
     * @since 9.1.0
     */
    public function withAddedHeader(string $name, string $value): self
    {
        $this->headers[] = [$name, $value];

        return $this;
    }

    /**
     * @param array<string, mixed> $params
     */
    private function useSmtp(array $params = []): self
    {
        $this->isGlobal = false;

        $this->applySmtp($params);

        return $this;
    }

    private function useGlobal(): void
    {
        $this->params = [];
        $this->isGlobal = true;
    }

    /**
     * @param array<string, mixed> $params
     */
    private function applySmtp(array $params = []): void
    {
        $this->params = $params;

        $smtpParams = SmtpParams::fromArray($params);

        $preparator = $this->transportPreparatorFactory->create($smtpParams);

        $this->transport = $preparator->prepare($smtpParams);
    }

    /**
     * @throws NoSmtp
     */
    private function applyGlobal(): void
    {
        $systemAccount = $this->accountProvider->getSystem();

        if (!$systemAccount) {
            throw new NoSmtp("No system SMTP settings.");
        }

        $smtpParams = $systemAccount->getSmtpParams();

        if (!$smtpParams) {
            throw new NoSmtp("No system SMTP settings.");
        }

        $this->applySmtp($smtpParams->toArray());
    }

    /**
     * Send an email.
     *
     * @throws SendingError
     */
    public function send(Email $email): void
    {
        if ($this->isGlobal) {
            $this->applyGlobal();
        }

        $message = new Message();

        $params = array_merge($this->params, $this->overrideParams);

        $this->applyHeaders($email, $message);
        $this->applyFrom($email, $message, $params);
        $this->addRecipientAddresses($email, $message);
        $this->applyReplyTo($email, $message, $params);
        $this->applySubject($email, $message);
        $this->applyBody($email, $message);
        $this->applyMessageId($email, $message);

        if (!$this->transport) {
            throw new LogicException();
        }

        $envelope = $this->prepareEnvelope($message);

        if ($this->messageContainer) {
            $this->messageContainer->message = new Sender\Message($message);
        }

        try {
            $this->transport->send($message, $envelope);
        } catch (Exception|TransportExceptionInterface $e) {
            $this->resetParams();
            $this->useGlobal();

            $this->handleException($e);
        }

        $email
            ->setStatus(Email::STATUS_SENT)
            ->setDateSent(DateTime::createNow())
            ->setSendAt(null);

        $this->resetParams();
        $this->useGlobal();
    }

    /**
     * @return DataPart[]
     */
    private function getAttachmentParts(Email $email): array
    {
        /** @var EntityCollection<Attachment> $collection */
        $collection = $this->entityManager
            ->getCollectionFactory()
            ->create(Attachment::ENTITY_TYPE);

        if (!$email->isNew()) {
            foreach ($email->getAttachments() as $attachment) {
                $collection[] = $attachment;
            }
        }

        /** @var AttachmentContainer[] $containers */
        $containers = [];

        if ($this->attachmentList !== null) {
            foreach ($this->attachmentList as $attachment) {
                if ($attachment instanceof Attachment) {
                    $collection[] = $attachment;
                } else {
                    $containers[] = $attachment;
                }
            }
        }

        $list = [];

        foreach ($collection as $attachment) {
            $contents = $this->getAttachmentContents($attachment);

            $part = new DataPart(
                body: $contents,
                filename: $attachment->getName() ?? '',
                contentType: $attachment->getType(),
            );

            $list[] = $part;
        }

        $this->prepareContainerParts($containers, $list);

        return $list;
    }

    /**
     * @return DataPart[]
     */
    private function getInlineAttachmentParts(Email $email): array
    {
        $list = [];

        foreach ($email->getInlineAttachmentList() as $attachment) {
            $contents = $this->getAttachmentContents($attachment);

            $part = (new DataPart($contents, null, $attachment->getType()))
                ->asInline()
                ->setContentId($attachment->getId() . '@espo');

            $list[] = $part;
        }

        return $list;
    }

    /**
     * @throws SendingError
     */
    private function handleException(Exception|TransportExceptionInterface $e): never
    {
        if ($e instanceof TransportExceptionInterface) {
            $message = "unknownError";

            if (
                stripos($e->getMessage(), 'password') !== false ||
                stripos($e->getMessage(), 'credentials') !== false ||
                stripos($e->getMessage(), '5.7.8') !== false ||
                stripos($e->getMessage(), '5.7.3') !== false
            ) {
                $message = 'invalidCredentials';
            }

            $this->log->error("Email sending error: " . $e->getMessage(), ['exception' => $e]);

            throw new SendingError($message);
        }

        throw new SendingError($e->getMessage());
    }

    private function addRecipientAddresses(Email $email, Message $message): void
    {
        $value = $email->get('to');

        if ($value) {
            foreach (explode(';', $value) as $address) {
                $message->addTo(trim($address));
            }
        }

        $value = $email->get('cc');

        if ($value) {
            foreach (explode(';', $value) as $address) {
                $message->addCC(trim($address));
            }
        }

        $value = $email->get('bcc');

        if ($value) {
            foreach (explode(';', $value) as $address) {
                $message->addBCC(trim($address));
            }
        }

        $value = $email->get('replyTo');

        if ($value) {
            foreach (explode(';', $value) as $address) {
                $message->addReplyTo(trim($address));
            }
        }
    }

    /**
     * @param array<string, mixed> $params
     * @throws NoSmtp
     */
    private function applyFrom(Email $email, Message $message, array $params): void
    {
        $fromName = $params['fromName'] ?? $this->config->get('outboundEmailFromName');

        $fromAddress = $email->get('from');

        if ($fromAddress) {
            $fromAddress = trim($fromAddress);
        } else {
            if (
                empty($params['fromAddress']) &&
                !$this->configDataProvider->getSystemOutboundAddress()
            ) {
                throw new NoSmtp('outboundEmailFromAddress is not specified in config.');
            }

            $fromAddress = $params['fromAddress'] ?? $this->configDataProvider->getSystemOutboundAddress();

            $email->setFromAddress($fromAddress);
        }

        $message->addFrom(new Address($fromAddress, $fromName ?? ''));

        $fromString = '<' . $fromAddress . '>';

        if ($fromName) {
            $fromString = $fromName . ' ' . $fromString;
        }

        $email->set('fromString', $fromString);

        $message->sender($fromAddress);
    }

    /**
     * @param array<string, mixed> $params
     */
    private function applyReplyTo(Email $email, Message $message, array $params): void
    {
        $address = $params['replyToAddress'] ?? null;
        $name = $params['replyToName'] ?? null;

        if (!$address) {
            return;
        }

        $message->replyTo(new Address($address, $name ?? ''));

        $email->setReplyToAddressList([$address]);
    }

    private function applyMessageId(Email $email, Message $message): void
    {
        $messageId = $email->getMessageId();

        if (
            !$messageId ||
            strlen($messageId) < 4 ||
            str_starts_with($messageId, 'dummy:')
        ) {
            $messageId = EmailSender::generateMessageId($email);

            $email->setMessageId('<' . $messageId . '>');

            if ($email->hasId()) {
                $this->entityManager->saveEntity($email, [SaveOption::SILENT => true]);
            }
        } else {
            $messageId = substr($messageId, 1, strlen($messageId) - 2);
        }

        $message->getHeaders()->addIdHeader('Message-ID', $messageId);
    }

    private function applyBody(Email $email, Message $message): void
    {
        $message->text($email->getBodyPlainForSending());

        if ($email->isHtml()) {
            $message->html($email->getBodyForSending());
        }

        foreach ($this->getAttachmentParts($email) as $part) {
            $message->addPart($part);
        }

        foreach ($this->getInlineAttachmentParts($email) as $part) {
            $message->addPart($part);
        }
    }

    private function applySubject(Email $email, Message $message): void
    {
        $message->subject($email->getSubject() ?? '');
    }

    private function applyHeaders(Email $email, Message $message): void
    {
        foreach ($this->headers as $item) {
            $message->getHeaders()->addTextHeader($item[0], $item[1]);
        }

        if ($email->isAutoReply() && !$message->getHeaders()->has('Auto-Submitted')) {
            $message->getHeaders()->addTextHeader('Auto-Submitted', 'auto-replied');
        }
    }

    private function prepareEnvelope(Message $message): ?Envelope
    {
        if (!$this->envelopeFromAddress) {
            return null;
        }

        $recipients = [
            ...$message->getTo(),
            ...$message->getCc(),
            ...$message->getBcc(),
        ];

        return new Envelope(new Address($this->envelopeFromAddress), $recipients);
    }

    /**
     * @todo Use stream.
     *
     */
    private function getAttachmentContents(Attachment $attachment): string
    {
        return $attachment->has(self::ATTACHMENT_ATTR_CONTENTS) ?
            $attachment->get(self::ATTACHMENT_ATTR_CONTENTS) :
            $this->fileStorageManager->getContents($attachment);
    }

    /**
     * @param AttachmentContainer[] $containers
     * @param DataPart[] $list
     */
    private function prepareContainerParts(array $containers, array &$list): void
    {
        foreach ($containers as $container) {
            $attachment = $container->attachment;

            $contents = $this->getAttachmentContents($attachment);

            $part = new DataPart(
                body: $contents,
                filename: $attachment->getName() ?? '',
                contentType: $attachment->getType(),
            );

            if ($container->inline) {
                $part->asInline();
            }

            if ($container->contentTypeParams && $attachment->getType()) {
                $part->getHeaders()->addParameterizedHeader(
                    name: 'Content-Type',
                    value: $attachment->getType(),
                    params: $container->contentTypeParams,
                );
            }

            $list[] = $part;
        }
    }
}
