<?php

declare(strict_types=1);

namespace OCA\MailCalendarSync\Service;

use OCA\MailCalendarSync\Db\ProcessedMessageMapper;
use Psr\Log\LoggerInterface;
use OCP\IDBConnection;
use Sabre\VObject\Reader;

/**
 * Service that connects to the Nextcloud Mail app's database and IMAP
 * to find and extract iCalendar (ICS) attachments from incoming mail.
 *
 * NOTE: Emails are NEVER deleted or modified. We only read them.
 * Requires the Nextcloud Mail app to be installed (provides Horde libraries).
 */
class MailService {

    public function __construct(
        private IDBConnection $db,
        private ProcessedMessageMapper $processedMapper,
        private LoggerInterface $logger,
    ) {
    }

    /**
     * Check whether the Horde IMAP libraries are available (provided by Mail app).
     */
    public function isImapAvailable(): bool {
        return class_exists(\Horde_Imap_Client_Socket::class);
    }

    /**
     * Get mail accounts for a user from the Mail app's database.
     *
     * @return array<array{id: int, name: string, email: string}>
     */
    public function getMailAccounts(string $userId): array {
        $qb = $this->db->getQueryBuilder();
        $qb->select('id', 'name', 'email')
            ->from('mail_accounts')
            ->where($qb->expr()->eq('user_id', $qb->createNamedParameter($userId)));

        $result = $qb->executeQuery();
        $accounts = [];

        while ($row = $result->fetch()) {
            $accounts[] = [
                'id' => (int)$row['id'],
                'name' => $row['name'] ?? $row['email'],
                'email' => $row['email'],
            ];
        }

        $result->closeCursor();
        return $accounts;
    }

    /**
     * Get IMAP connection details for a mail account.
     */
    public function getMailAccountDetails(int $accountId, string $userId): ?array {
        $qb = $this->db->getQueryBuilder();
        $qb->select('*')
            ->from('mail_accounts')
            ->where($qb->expr()->eq('id', $qb->createNamedParameter($accountId)))
            ->andWhere($qb->expr()->eq('user_id', $qb->createNamedParameter($userId)));

        $result = $qb->executeQuery();
        $row = $result->fetch();
        $result->closeCursor();

        return $row === false ? null : $row;
    }

    /**
     * Find recent messages with iMIP/calendar content in the INBOX.
     *
     * @return array<array{messageId: string, subject: string, uid: int, mailboxId: int}>
     */
    public function findRecentImipMessages(string $userId, int $mailAccountId, int $lookbackDays = 7): array {
        // First, find the INBOX mailbox ID for this account
        $qb = $this->db->getQueryBuilder();
        $qb->select('id')
            ->from('mail_mailboxes')
            ->where($qb->expr()->eq('account_id', $qb->createNamedParameter($mailAccountId)))
            ->andWhere($qb->expr()->like(
                $qb->func()->lower('name'),
                $qb->createNamedParameter('inbox')
            ));

        $result = $qb->executeQuery();
        $inboxRow = $result->fetch();
        $result->closeCursor();

        if ($inboxRow === false) {
            $this->logger->debug('No INBOX found for mail account', [
                'accountId' => $mailAccountId,
                'userId' => $userId,
            ]);
            return [];
        }

        $inboxId = (int)$inboxRow['id'];

        // Find recent messages flagged as iMip by the Mail app
        // The column is called `imip_message` (boolean), NOT `flag_imip`
        $cutoff = new \DateTime("-{$lookbackDays} days");
        $qb = $this->db->getQueryBuilder();
        $qb->select('m.uid', 'm.message_id', 'm.subject', 'm.sent_at')
            ->from('mail_messages', 'm')
            ->where($qb->expr()->eq('m.mailbox_id', $qb->createNamedParameter($inboxId)))
            ->andWhere($qb->expr()->gte('m.sent_at', $qb->createNamedParameter(
                $cutoff->getTimestamp()
            )))
            ->andWhere($qb->expr()->eq('m.imip_message', $qb->createNamedParameter(
                1, \OCP\DB\QueryBuilder\IQueryBuilder::PARAM_INT
            )))
            ->orderBy('m.sent_at', 'DESC')
            ->setMaxResults(100);

        $result = $qb->executeQuery();
        $messages = [];

        while ($row = $result->fetch()) {
            $messageId = $row['message_id'] ?? '';

            // Skip already-processed messages
            if ($messageId !== '' && $this->processedMapper->isProcessed($userId, $mailAccountId, $messageId)) {
                continue;
            }

            $messages[] = [
                'uid' => (int)$row['uid'],
                'messageId' => $messageId,
                'subject' => $row['subject'] ?? '',
                'mailboxId' => $inboxId,
            ];
        }

        $result->closeCursor();
        return $messages;
    }

    /**
     * Fetch ICS data from multiple messages using a SINGLE IMAP connection.
     *
     * This is much more efficient than connecting per-message.
     * NOTE: This is READ-ONLY. Emails are never deleted or modified.
     *
     * @param array $messages Array of message arrays from findRecentImipMessages
     * @return array<int, array<array{ics: string, method: string, from: string}>> Keyed by message index
     */
    public function fetchIcsFromMessages(int $mailAccountId, string $userId, array $messages): array {
        if (empty($messages)) {
            return [];
        }

        if (!$this->isImapAvailable()) {
            throw new \RuntimeException(
                'Horde IMAP libraries not available. Is the Nextcloud Mail app installed?'
            );
        }

        $accountDetails = $this->getMailAccountDetails($mailAccountId, $userId);
        if ($accountDetails === null) {
            throw new \RuntimeException("Mail account {$mailAccountId} not found for user {$userId}");
        }

        $password = $this->decryptPassword($accountDetails['inbound_password'] ?? '');
        if (empty($password)) {
            throw new \RuntimeException('Failed to decrypt IMAP password for account ' . $mailAccountId);
        }

        $imapHost = $accountDetails['inbound_host'] ?? '';
        $imapPort = (int)($accountDetails['inbound_port'] ?? 993);
        $imapUser = $accountDetails['inbound_user'] ?? $accountDetails['email'];
        $imapSsl = $this->mapSslMode($accountDetails['inbound_ssl_mode'] ?? 'ssl');

        if (empty($imapHost)) {
            throw new \RuntimeException('No IMAP host configured for account ' . $mailAccountId);
        }

        $client = new \Horde_Imap_Client_Socket([
            'username' => $imapUser,
            'password' => $password,
            'hostspec' => $imapHost,
            'port' => $imapPort,
            'secure' => $imapSsl,
        ]);

        $allResults = [];

        try {
            // Group messages by mailbox for efficient fetching
            $byMailbox = [];
            foreach ($messages as $idx => $message) {
                $mailboxId = $message['mailboxId'];
                if (!isset($byMailbox[$mailboxId])) {
                    $byMailbox[$mailboxId] = [];
                }
                $byMailbox[$mailboxId][$idx] = $message;
            }

            foreach ($byMailbox as $mailboxId => $mailboxMessages) {
                $mailboxName = $this->getMailboxName($mailboxId);
                if ($mailboxName === null) {
                    $this->logger->warning("Mailbox ID {$mailboxId} not found in database");
                    continue;
                }

                $mailbox = new \Horde_Imap_Client_Mailbox($mailboxName);

                // Fetch all messages in this mailbox at once
                $uids = array_map(fn($m) => $m['uid'], $mailboxMessages);
                $ids = new \Horde_Imap_Client_Ids($uids);

                $query = new \Horde_Imap_Client_Fetch_Query();
                $query->structure();
                $query->envelope();
                $query->fullText(['peek' => true]);

                $fetchResults = $client->fetch($mailbox, $query, ['ids' => $ids]);

                // Map results back to message indices
                foreach ($mailboxMessages as $idx => $message) {
                    $uid = $message['uid'];
                    if (!isset($fetchResults[$uid])) {
                        continue;
                    }

                    $fetchData = $fetchResults[$uid];
                    $icsResults = $this->extractIcsFromFetchData($fetchData);
                    if (!empty($icsResults)) {
                        $allResults[$idx] = $icsResults;
                    }
                }
            }
        } finally {
            try {
                $client->logout();
            } catch (\Throwable $e) {
                // ignore logout errors
            }
        }

        return $allResults;
    }

    /**
     * Fetch ICS data from a single message via IMAP.
     * Convenience wrapper around fetchIcsFromMessages for single-message use.
     *
     * @return array<array{ics: string, method: string, from: string}>
     */
    public function fetchIcsFromMessage(int $mailAccountId, string $userId, int $mailboxId, int $messageUid): array {
        $messages = [[
            'uid' => $messageUid,
            'mailboxId' => $mailboxId,
            'messageId' => '',
            'subject' => '',
        ]];

        $results = $this->fetchIcsFromMessages($mailAccountId, $userId, $messages);
        return $results[0] ?? [];
    }

    /**
     * Extract ICS data from a Horde fetch result.
     *
     * @return array<array{ics: string, method: string, from: string}>
     */
    private function extractIcsFromFetchData($fetchData): array {
        $envelope = $fetchData->getEnvelope();
        $fromAddresses = $envelope->from ?? [];
        $from = '';
        if (count($fromAddresses) > 0) {
            $firstFrom = $fromAddresses[0];
            $from = ($firstFrom->bare_address ?? '');
        }

        $fullText = $fetchData->getFullMsg();
        if ($fullText === null) {
            return [];
        }

        $mimeMessage = \Horde_Mime_Part::parseMessage($fullText);
        $icsParts = $this->findCalendarParts($mimeMessage);

        $results = [];
        foreach ($icsParts as $icsPart) {
            $icsData = $icsPart->getContents();
            if (empty($icsData)) {
                continue;
            }

            $method = 'REQUEST';
            try {
                $vcal = Reader::read($icsData);
                if (isset($vcal->METHOD)) {
                    $method = strtoupper((string)$vcal->METHOD);
                }
            } catch (\Throwable $e) {
                $this->logger->warning('Failed to parse ICS to determine method', [
                    'exception' => $e,
                ]);
            }

            $results[] = [
                'ics' => $icsData,
                'method' => $method,
                'from' => $from,
            ];
        }

        return $results;
    }

    /**
     * Recursively find text/calendar MIME parts.
     *
     * @return \Horde_Mime_Part[]
     */
    private function findCalendarParts(\Horde_Mime_Part $part): array {
        $results = [];
        $contentType = strtolower($part->getType());

        if ($contentType === 'text/calendar' || $contentType === 'application/ics') {
            $results[] = $part;
        }

        foreach ($part->getParts() as $subPart) {
            $results = array_merge($results, $this->findCalendarParts($subPart));
        }

        return $results;
    }

    /**
     * Get mailbox name by ID from the Mail app's database.
     */
    private function getMailboxName(int $mailboxId): ?string {
        $qb = $this->db->getQueryBuilder();
        $qb->select('name')
            ->from('mail_mailboxes')
            ->where($qb->expr()->eq('id', $qb->createNamedParameter($mailboxId)));

        $result = $qb->executeQuery();
        $row = $result->fetch();
        $result->closeCursor();

        return $row ? ($row['name'] ?? null) : null;
    }

    /**
     * Decrypt the stored password using Nextcloud's crypto.
     */
    private function decryptPassword(string $encrypted): string {
        if (empty($encrypted)) {
            return '';
        }

        try {
            $crypto = \OC::$server->getCrypto();
            return $crypto->decrypt($encrypted);
        } catch (\Throwable $e) {
            $this->logger->warning('Failed to decrypt mail password', [
                'exception' => $e,
            ]);
            return '';
        }
    }

    /**
     * Map Nextcloud Mail's SSL mode strings to Horde constants.
     */
    private function mapSslMode(string $mode): string {
        return match (strtolower($mode)) {
            'ssl' => 'ssl',
            'tls', 'starttls' => 'tls',
            default => '',
        };
    }
}