<?php

declare(strict_types=1);

namespace KTXT\ProviderImap\Tests\Unit;

use KTXC\Db\DataStore;
use KTXF\Mail\Collection\CollectionRoles;
use KTXM\ProviderImap\Client\Mailbox;
use KTXM\ProviderImap\Providers\CachedService;
use KTXM\ProviderImap\Providers\MessageProperties;
use KTXM\ProviderImap\Service\Cache\HarmonizationService;
use KTXM\ProviderImap\Service\Cache\MessageDeltaService;
use KTXM\ProviderImap\Service\Cache\MessageIngestor;
use KTXM\ProviderImap\Service\Cache\MessageQueryBuilder;
use KTXM\ProviderImap\Service\Live\LiveMailService;
use KTXF\Resource\Identifier\EntityIdentifier;
use KTXF\Resource\Range\RangeAnchorType;
use KTXF\Resource\Range\RangeType;
use KTXF\Resource\Sort\Sort;
use KTXT\ProviderImap\Tests\Support\FakeLiveMailService;
use KTXT\ProviderImap\Tests\Support\FakeMailboxStore;
use KTXT\ProviderImap\Tests\Support\FakeMessageFileStore;
use KTXT\ProviderImap\Tests\Support\FakeMessageStore;
use PHPUnit\Framework\TestCase;

final class CachedServiceTest extends TestCase
{
    private FakeMailboxStore $mailboxes;
    private FakeMessageStore $messages;
    private FakeMessageFileStore $files;
    private FakeLiveMailService $live;
    private CachedService $service;

    protected function setUp(): void
    {
        $dataStore = $this->createStub(DataStore::class);
        $this->mailboxes = new FakeMailboxStore($dataStore);
        $messages = new FakeMessageStore($dataStore);
        $files = new FakeMessageFileStore('/nonexistent');

        $harmonizer = new HarmonizationService(
            $this->mailboxes,
            $messages,
            $files,
            new MessageIngestor($files, $messages, $this->mailboxes),
        );

        $this->messages = $messages;
        $this->files = $files;
        $this->service = new CachedServiceTestDouble(
            $this->mailboxes,
            $messages,
            $files,
            new MessageIngestor($files, $messages, $this->mailboxes),
            new MessageQueryBuilder(),
            $harmonizer,
            new MessageDeltaService($this->mailboxes, $messages),
        );
        $this->service->fromStore(['tid' => 'tenant', 'sid' => 'svc']);

        $this->live = new FakeLiveMailService($this->service);
        $this->live->uidValidity = 7;
        $this->live->uidNext = 10;
        $this->live->mailboxList = [new Mailbox('INBOX', '/', []), new Mailbox('Sent', '/', ['\\Sent'])];
        $this->service->liveMail = $this->live;
    }

    public function testCollectionListComesFromTheCacheAfterHarmonizingTheList(): void
    {
        $list = $this->service->collectionList(null);

        $this->assertSame(['INBOX', 'Sent'], array_keys($list));
        $this->assertSame(CollectionRoles::Sent, $list['Sent']->getProperties()->getRole());
        $this->assertCount(1, $this->listCalls());
    }

    public function testFreshListIsNotHarmonizedAgain(): void
    {
        $this->service->collectionList(null);
        $this->service->collectionList(null);
        $this->service->collectionFetch('INBOX');

        $this->assertCount(1, $this->listCalls());
    }

    public function testStaleListIsHarmonizedAgain(): void
    {
        $this->mailboxes->clock = time() - CachedService::FRESHNESS_WINDOW - 1;
        $this->service->collectionList(null);
        $this->mailboxes->clock = null;

        $this->live->mailboxList[] = new Mailbox('Archive', '/', []);
        $list = $this->service->collectionList(null);

        $this->assertSame(['INBOX', 'Sent', 'Archive'], array_keys($list));
        $this->assertCount(2, $this->listCalls());
    }

    public function testFilteredListGoesToTheServer(): void
    {
        $filter = $this->service->collectionListFilter();
        $filter->condition('role', CollectionRoles::Sent->value);

        $this->service->collectionList(null, $filter);

        $this->assertSame([['collectionList', [null, $filter]]], $this->live->calls);
    }

    public function testCollectionSignatureIsTheDeltaSignature(): void
    {
        $this->live->flags = [1 => [], 2 => []];
        $this->service->entityDelta('INBOX', '');

        $this->assertSame('7:2', $this->service->collectionFetch('INBOX')?->signature());
    }

    public function testCollectionExtantUsesTheCache(): void
    {
        $this->assertSame(['INBOX' => true, 'Missing' => false], $this->service->collectionExtant('INBOX', 'Missing'));
    }

    public function testDeltaHarmonizesWhenStaleOnly(): void
    {
        $this->live->flags = [1 => []];
        $first = $this->service->entityDelta('INBOX', '');

        $this->live->flags = [1 => [], 2 => []];
        $second = $this->service->entityDelta('INBOX', $first->signature);

        $this->assertSame('7:1', $first->signature);
        $this->assertSame('7:1', $second->signature, 'fresh mailbox is not harmonized again');

        $this->mailboxes->updateState('svc', 'INBOX', ['harmonizedAt' => time() - CachedService::FRESHNESS_WINDOW]);
        $third = $this->service->entityDelta('INBOX', $first->signature);

        $this->assertSame('7:2', $third->signature);
        $this->assertSame(['2'], json_decode(json_encode($third->additions), true));
    }

    public function testDeltaIsAnsweredFromTheCacheWhenTheServerFails(): void
    {
        $this->live->flags = [1 => []];
        $signature = $this->service->entityDelta('INBOX', '')->signature;

        $this->mailboxes->updateState('svc', 'INBOX', ['harmonizedAt' => 0]);
        $this->live->uidValidity = null; // harmonization throws

        $this->assertSame($signature, $this->service->entityDelta('INBOX', $signature)->signature);
    }

    public function testWritesGoThroughTheLiveService(): void
    {
        $properties = new MessageProperties([]);
        $properties->setFlag('seen', true);

        $this->service->entityPatch($properties, new EntityIdentifier('imap', 'svc', 'INBOX', '5'));

        $patches = array_values(array_filter($this->live->calls, static fn (array $call): bool => $call[0] === 'entityPatch'));
        $this->assertCount(1, $patches);
        [$collection, $added, , $uids] = $patches[0][1];
        $this->assertSame('INBOX', $collection);
        $this->assertContains('seen', $added);
        $this->assertSame([5], $uids);
    }

    public function testListOfANotHarmonizedMailboxStreamsFromTheServerAndCaches(): void
    {
        $this->live->flags = [1 => [], 2 => ['\\Seen']];

        $uids = $this->listedUids($this->service->entityListStream('INBOX'));

        $this->assertSame([1, 2], $uids);
        $this->assertCount(1, $this->calls('messageList'));
        $this->assertSame([1, 2], $this->files->uids(7));
        $this->assertSame([1 => [], 2 => ['seen']], $this->messages->flags('svc', 'INBOX', 7));
    }

    public function testListOfAHarmonizedMailboxComesFromTheCache(): void
    {
        $this->harmonized([1 => [], 2 => ['\\Seen'], 3 => []]);

        $entities = iterator_to_array($this->service->entityListStream('INBOX'), false);

        $this->assertSame([1, 2, 3], array_map(static fn ($entity): int => (int) $entity->identifier(), $entities));
        $this->assertSame([], $this->calls('messageList'));
        $this->assertSame(['seen' => true], $entities[1]->getProperties()->getFlags());
        $this->assertSame('INBOX', $entities[1]->collection());
    }

    public function testListRangeIsAppliedLikeTheLiveService(): void
    {
        $this->harmonized([1 => [], 2 => [], 3 => [], 4 => []]);

        $absolute = $this->service->entityListRange(RangeType::TALLY);
        $absolute->setAnchor(RangeAnchorType::ABSOLUTE);
        $absolute->setPosition(1);
        $absolute->setTally(2);

        $relative = $this->service->entityListRange(RangeType::TALLY);
        $relative->setAnchor(RangeAnchorType::RELATIVE);
        $relative->setPosition(3);
        $relative->setTally(2);

        $this->assertSame([2, 3], $this->listedUids($this->service->entityListStream('INBOX', null, null, $absolute)));
        $this->assertSame([3, 4], $this->listedUids($this->service->entityListStream('INBOX', null, null, $relative)));
    }

    public function testMessagesMissingFromTheContentStoreAreFetchedAndCached(): void
    {
        $this->harmonized([1 => [], 2 => []]);
        $this->files->delete('tenant', 'svc', 'INBOX', 7, 2);
        $this->live->fetchBatches = [];

        $this->assertSame([1, 2], $this->listedUids($this->service->entityListStream('INBOX')));
        $this->assertSame([[2]], $this->live->fetchBatches);
        $this->assertSame([1, 2], $this->files->uids(7));
    }

    public function testBodyFilterHasTheServerFindTheUids(): void
    {
        $this->harmonized([1 => [], 2 => [], 3 => []]);
        $this->live->found = [3, 1];
        $this->live->fetchBatches = [];

        $filter = $this->service->entityListFilter();
        $filter->condition('body', 'invoice');

        $this->assertSame([3, 1], $this->listedUids($this->service->entityListStream('INBOX', $filter)));
        $this->assertCount(1, $this->calls('entityFind'));
        $this->assertSame([], $this->live->fetchBatches, 'content comes from the cache');
    }

    public function testOtherFiltersAreTranslatedForTheMetaStore(): void
    {
        $this->harmonized([1 => []]);

        $filter = $this->service->entityListFilter();
        $filter->condition('subject', 'report');
        // keyed attributes: entityListSort() passes a plain list, which Sort::condition() ignores (existing bug)
        $sort = new Sort(['received' => true]);
        $sort->condition('received', false);

        iterator_to_array($this->service->entityListStream('INBOX', $filter, $sort));

        $this->assertSame([], $this->calls('entityFind'));
        $this->assertArrayHasKey('subject', $this->messages->lastQuery[0]);
        $this->assertSame(['received' => -1, 'uid' => 1], $this->messages->lastQuery[1]);
    }

    public function testListBulkIsTheStreamCollected(): void
    {
        $this->harmonized([1 => [], 2 => []]);

        $this->assertCount(2, $this->service->entityListBulk('INBOX'));
    }

    public function testFetchComesFromTheCache(): void
    {
        $this->harmonized([1 => [], 2 => ['\\Flagged']]);
        $this->live->fetchBatches = [];

        $entities = array_values($this->service->entityFetchBulk(
            new EntityIdentifier('imap', 'svc', 'INBOX', '2'),
        ));

        $this->assertCount(1, $entities);
        $this->assertSame(['flagged' => true], $entities[0]->getProperties()->getFlags());
        $this->assertSame([], $this->live->fetchBatches);
    }

    public function testFetchOfAnUncachedMessageGoesToTheServerAndCaches(): void
    {
        $this->harmonized([1 => []]);
        $this->live->flags[5] = [];
        $this->live->fetchBatches = [];

        $entities = array_values($this->service->entityFetchBulk(new EntityIdentifier('imap', 'svc', 'INBOX', '5')));

        $this->assertSame('5', (string) $entities[0]->identifier());
        $this->assertSame([[5]], $this->live->fetchBatches);
        $this->assertContains(5, $this->files->uids(7));
    }

    public function testFetchFromANeverHarmonizedMailboxIsReadFromTheServer(): void
    {
        $this->live->flags = [3 => []];

        $entities = array_values($this->service->entityFetchBulk(new EntityIdentifier('imap', 'svc', 'Sent', '3')));

        $this->assertSame('3', (string) $entities[0]->identifier());
        $this->assertSame([], $this->files->uids(7), 'nothing is cached without a mailbox generation');
    }

    public function testFetchRejectsIdentifiersOfAnotherService(): void
    {
        $this->expectException(\InvalidArgumentException::class);
        iterator_to_array($this->service->entityFetchStream(new EntityIdentifier('imap', 'other', 'INBOX', '1')));
    }

    public function testIncompleteSectionsAreCompletedOnceAndStored(): void
    {
        $this->harmonized([1 => []]);
        $content = $this->files->content(7, 1);
        $content['incomplete'] = ['1'];
        $content['properties']['body'] = ['partId' => '1', 'type' => 'text/plain', 'content' => 'Hello wor'];
        $this->files->write('tenant', 'svc', 'INBOX', 7, 1, $content);
        $this->live->sections = [1 => ['1' => 'Hello world, the full text.']];

        $listed = array_values(iterator_to_array($this->service->entityListStream('INBOX'), false));
        $fetched = array_values($this->service->entityFetchBulk(new EntityIdentifier('imap', 'svc', 'INBOX', '1')));

        $this->assertSame('Hello world, the full text.', $listed[0]->getProperties()->getBodyTextPlain());
        $this->assertSame('Hello world, the full text.', $fetched[0]->getProperties()->getBodyTextPlain());
        $this->assertSame([], $this->files->content(7, 1)['incomplete']);
        $this->assertCount(1, $this->calls('messageSections'), 'completed once, then served from the cache');
    }

    public function testIncompleteSectionsStayCutOffWhenTheServerDoesNotReturnThem(): void
    {
        $this->harmonized([1 => []]);
        $content = $this->files->content(7, 1);
        $content['incomplete'] = ['1'];
        $content['properties']['body'] = ['partId' => '1', 'type' => 'text/plain', 'content' => 'Hello wor'];
        $this->files->write('tenant', 'svc', 'INBOX', 7, 1, $content);

        $fetched = array_values($this->service->entityFetchBulk(new EntityIdentifier('imap', 'svc', 'INBOX', '1')));

        $this->assertSame('Hello wor', $fetched[0]->getProperties()->getBodyTextPlain());
        $this->assertSame(['1'], $this->files->content(7, 1)['incomplete']);
    }

    /**
     * Harmonize INBOX with the given server UIDs and flags.
     *
     * @param array<int, list<string>> $flags
     */
    private function harmonized(array $flags): void
    {
        $this->live->flags = $flags;
        $this->service->entityDelta('INBOX', '');
    }

    /**
     * @return int[]
     */
    private function listedUids(iterable $entities): array
    {
        $uids = [];
        foreach ($entities as $entity) {
            $uids[] = (int) $entity->identifier();
        }
        return $uids;
    }

    /**
     * @return list<array>
     */
    private function calls(string $method): array
    {
        return array_values(array_filter($this->live->calls, static fn (array $call): bool => $call[0] === $method));
    }

    /**
     * @return list<array>
     */
    private function listCalls(): array
    {
        return array_values(array_filter($this->live->calls, static fn (array $call): bool => $call[0] === 'collectionList'));
    }
}

/**
 * CachedService with a replaceable IMAP side.
 */
final class CachedServiceTestDouble extends CachedService
{
    public ?LiveMailService $liveMail = null;

    protected function liveMail(): LiveMailService
    {
        return $this->liveMail;
    }
}