<?php

declare(strict_types=1);

/**
 * SPDX-FileCopyrightText: Sebastian Krupinski <krupinski01@gmail.com>
 * SPDX-License-Identifier: AGPL-3.0-or-later
 */

namespace KTXM\ProviderJmapc\Providers\Mail;

use KTXF\Mail\Collection\CollectionBaseInterface;
use KTXF\Mail\Collection\CollectionMutableInterface;
use KTXF\Mail\Object\Address;
use KTXF\Mail\Object\AddressInterface;
use KTXF\Mail\Service\ServiceBaseInterface;
use KTXF\Mail\Service\ServiceCollectionMutableInterface;
use KTXF\Mail\Service\ServiceConfigurableInterface;
use KTXF\Mail\Service\ServiceMutableInterface;
use KTXF\Resource\Provider\ResourceServiceIdentityInterface;
use KTXF\Resource\Provider\ResourceServiceLocationInterface;
use KTXF\Resource\Delta\Delta;
use KTXF\Resource\Filter\Filter;
use KTXF\Resource\Filter\IFilter;
use KTXF\Resource\Range\IRange;
use KTXF\Resource\Range\Range;
use KTXF\Resource\Range\RangeType;
use KTXF\Resource\Sort\ISort;
use KTXF\Resource\Sort\Sort;
use KTXM\ProviderJmapc\Providers\ServiceIdentityBasic;
use KTXM\ProviderJmapc\Providers\ServiceLocation;
use KTXM\ProviderJmapc\Service\Remote\RemoteMailService;
use KTXM\ProviderJmapc\Service\Remote\RemoteService;

/**
 * JMAP Service
 * 
 * Represents a configured JMAP account
 */
class Service implements ServiceBaseInterface, ServiceMutableInterface, ServiceConfigurableInterface, ServiceCollectionMutableInterface
{
    public const JSON_TYPE = ServiceBaseInterface::JSON_TYPE;

    private const PROVIDER_IDENTIFIER = 'jmap';

    private ?string $serviceTenantId = null;
	private ?string $serviceUserId = null;
    private ?string $serviceIdentifier = null;
    private ?string $serviceLabel = null;
	private bool $serviceEnabled = false;
    private bool $serviceDebug = false;
    private string $primaryAddress = '';
    private array $secondaryAddresses = [];
    private ?ServiceLocation $location = null;
    private ?ServiceIdentityBasic $identity = null;
    private array $auxiliary = [];

    private array $serviceAbilities = [
		self::CAPABILITY_COLLECTION_LIST => true,
		self::CAPABILITY_COLLECTION_LIST_FILTER => [
            self::CAPABILITY_COLLECTION_FILTER_LABEL => 's:100:256:256',
            self::CAPABILITY_COLLECTION_FILTER_ROLE => 's:100:256:256',
		],
		self::CAPABILITY_COLLECTION_LIST_SORT => [
            self::CAPABILITY_COLLECTION_SORT_LABEL,
            self::CAPABILITY_COLLECTION_SORT_RANK,
		],
		self::CAPABILITY_COLLECTION_EXTANT => true,
		self::CAPABILITY_COLLECTION_FETCH => true,
        self::CAPABILITY_COLLECTION_CREATE => true,
        self::CAPABILITY_COLLECTION_MODIFY => true,
        self::CAPABILITY_COLLECTION_DESTROY => true,
		self::CAPABILITY_ENTITY_LIST => true,
		self::CAPABILITY_ENTITY_LIST_FILTER => [
			self::CAPABILITY_ENTITY_FILTER_ALL => 's:200:256:256',
            self::CAPABILITY_ENTITY_FILTER_FROM => 's:100:256:256',
            self::CAPABILITY_ENTITY_FILTER_TO => 's:100:256:256',
            self::CAPABILITY_ENTITY_FILTER_CC => 's:100:256:256',
            self::CAPABILITY_ENTITY_FILTER_BCC => 's:100:256:256',
            self::CAPABILITY_ENTITY_FILTER_SUBJECT => 's:200:256:256',
            self::CAPABILITY_ENTITY_FILTER_BODY => 's:200:256:256',
            self::CAPABILITY_ENTITY_FILTER_DATE_BEFORE => 'd:0:32:32',
            self::CAPABILITY_ENTITY_FILTER_DATE_AFTER => 'd:0:16:16',
            self::CAPABILITY_ENTITY_FILTER_SIZE_MIN => 'i:0:16:16',
            self::CAPABILITY_ENTITY_FILTER_SIZE_MAX => 'i:0:32:32',
		],
		self::CAPABILITY_ENTITY_LIST_SORT => [
            self::CAPABILITY_ENTITY_SORT_FROM,
            self::CAPABILITY_ENTITY_SORT_TO,
            self::CAPABILITY_ENTITY_SORT_SUBJECT,
            self::CAPABILITY_ENTITY_SORT_DATE_RECEIVED,
            self::CAPABILITY_ENTITY_SORT_DATE_SENT,
            self::CAPABILITY_ENTITY_SORT_SIZE,
		],
		self::CAPABILITY_ENTITY_LIST_RANGE => [
			'tally' => ['absolute', 'relative']
		],
		self::CAPABILITY_ENTITY_DELTA => true,
		self::CAPABILITY_ENTITY_EXTANT => true,
		self::CAPABILITY_ENTITY_FETCH => true,
	];

    private readonly RemoteMailService $mailService;

    public function __construct(
    ) {}

    private function initialize(): void
    {
        if (!isset($this->mailService)) {
            $client = RemoteService::freshClient($this);
            $this->mailService = RemoteService::mailService($client);
        }
    }

    public function toStore(): array
    {
        return array_filter([
            'tid' => $this->serviceTenantId,
            'uid' => $this->serviceUserId,
            'sid' => $this->serviceIdentifier,
            'label' => $this->serviceLabel,
            'enabled' => $this->serviceEnabled,
            'debug' => $this->serviceDebug,
            'primaryAddress' => $this->primaryAddress,
            'secondaryAddresses' => $this->secondaryAddresses,
            'location' => $this->location?->toStore(),
            'identity' => $this->identity?->toStore(),
            'auxiliary' => $this->auxiliary,
        ], fn($v) => $v !== null);
    }

    public function fromStore(array $data): static
    {
        $this->serviceTenantId = $data['tid'] ?? null;
        $this->serviceUserId = $data['uid'] ?? null;
        $this->serviceIdentifier = $data['sid'];
        $this->serviceLabel = $data['label'] ?? '';
        $this->serviceEnabled = $data['enabled'] ?? false;
        $this->serviceDebug = $data['debug'] ?? false;

        if (isset($data['primaryAddress'])) {
            $this->primaryAddress = $data['primaryAddress'];
        }
        if (isset($data['secondaryAddresses']) && is_array($data['secondaryAddresses'])) {
            $this->secondaryAddresses = $data['secondaryAddresses'];
        }

        if (isset($data['location'])) {
            $this->location = (new ServiceLocation())->fromStore($data['location']);
        }

        if (isset($data['identity'])) {
            $this->identity = (new ServiceIdentityBasic())->fromStore($data['identity']);
        }
        if (isset($data['auxiliary']) && is_array($data['auxiliary'])) {
            $this->auxiliary = $data['auxiliary'];
        }

        return $this;
    }

    public function jsonSerialize(): array
    {
        return array_filter([
            self::JSON_PROPERTY_TYPE => self::JSON_TYPE,
            self::JSON_PROPERTY_PROVIDER => self::PROVIDER_IDENTIFIER,
            self::JSON_PROPERTY_IDENTIFIER => $this->serviceIdentifier,
            self::JSON_PROPERTY_LABEL => $this->serviceLabel,
            self::JSON_PROPERTY_ENABLED => $this->serviceEnabled,
            self::JSON_PROPERTY_CAPABILITIES => $this->serviceAbilities,
            self::JSON_PROPERTY_PRIMARY_ADDRESS => $this->primaryAddress,
            self::JSON_PROPERTY_SECONDARY_ADDRESSES => $this->secondaryAddresses,
            self::JSON_PROPERTY_LOCATION => $this->location?->jsonSerialize(),
            self::JSON_PROPERTY_IDENTITY => $this->identity?->jsonSerialize(),
            self::JSON_PROPERTY_AUXILIARY => $this->auxiliary,
        ], fn($v) => $v !== null);
    }

    public function jsonDeserialize(array|string $data): static
    {
        if (is_string($data)) {
            $data = json_decode($data, true, 512, JSON_THROW_ON_ERROR);
        }

        if (isset($data[self::JSON_PROPERTY_LABEL])) {
            $this->setLabel($data[self::JSON_PROPERTY_LABEL]);
        }
        if (isset($data[self::JSON_PROPERTY_ENABLED])) {
            $this->setEnabled($data[self::JSON_PROPERTY_ENABLED]);
        }
        if (isset($data[self::JSON_PROPERTY_LOCATION])) {
            $this->setLocation($this->freshLocation(null, $data[self::JSON_PROPERTY_LOCATION]));
        }
        if (isset($data[self::JSON_PROPERTY_IDENTITY])) {
            $this->setIdentity($this->freshIdentity(null, $data[self::JSON_PROPERTY_IDENTITY]));
        }
        if (isset($data[self::JSON_PROPERTY_PRIMARY_ADDRESS]) && is_string($data[self::JSON_PROPERTY_PRIMARY_ADDRESS])) {
            if (is_array($data[self::JSON_PROPERTY_PRIMARY_ADDRESS]) && isset($data[self::JSON_PROPERTY_PRIMARY_ADDRESS]['address'])) {
                $this->setPrimaryAddress(new Address($data[self::JSON_PROPERTY_PRIMARY_ADDRESS]));
            }
        }
        if (isset($data[self::JSON_PROPERTY_SECONDARY_ADDRESSES]) && is_array($data[self::JSON_PROPERTY_SECONDARY_ADDRESSES])) {
            $this->setSecondaryAddresses(array_map(
                fn($addr) => new Address($addr['address']),
                $data[self::JSON_PROPERTY_SECONDARY_ADDRESSES]
            ));
        }
        if (isset($data[self::JSON_PROPERTY_AUXILIARY]) && is_array($data[self::JSON_PROPERTY_AUXILIARY])) {
            $this->setAuxiliary($data[self::JSON_PROPERTY_AUXILIARY]);
        }

        return $this;
    }

    public function capable(string $value): bool
    {
        return isset($this->serviceAbilities[$value]);
    }

    public function capabilities(): array
    {
        $caps = [];
        foreach (array_keys($this->serviceAbilities) as $cap) {
            $caps[$cap] = true;
        }
        return $caps;
    }

    public function provider(): string
    {
        return self::PROVIDER_IDENTIFIER;
    }

    public function identifier(): string|int
    {
        return $this->serviceIdentifier;
    }

    public function getLabel(): string|null
    {
        return $this->serviceLabel;
    }

    public function setLabel(string $label): static
    {
        $this->serviceLabel = $label;
        return $this;
    }

    public function getEnabled(): bool
    {
        return $this->serviceEnabled;
    }

    public function setEnabled(bool $enabled): static
    {
        $this->serviceEnabled = $enabled;
        return $this;
    }

    public function getPrimaryAddress(): AddressInterface
    {
        return new Address($this->primaryAddress);
    }

    public function setPrimaryAddress(AddressInterface $value): static
    {
        $this->primaryAddress = $value->getAddress();
        return $this;
    }

    public function getSecondaryAddresses(): array
    {
        return $this->secondaryAddresses;
    }

    public function setSecondaryAddresses(array $addresses): static
    {
        $this->secondaryAddresses = $addresses;
        return $this;
    }

    public function hasAddress(string $address): bool
    {
        $address = strtolower(trim($address));
        
        if ($this->primaryAddress && strtolower($this->primaryAddress) === $address) {
            return true;
        }
        
        foreach ($this->secondaryAddresses as $secondaryAddress) {
            if (strtolower($secondaryAddress->getAddress()) === $address) {
                return true;
            }
        }
        
        return false;
    }

    public function getLocation(): ServiceLocation
    {
        return $this->location;
    }

    public function setLocation(ResourceServiceLocationInterface $location): static
    {
        $this->location = $location;
        return $this;
    }

    public function freshLocation(string|null $type = null, array $data = []): ServiceLocation
    {
        $location = new ServiceLocation();
        $location->jsonDeserialize($data);
        return $location;
    }

    public function getIdentity(): ServiceIdentityBasic
    {
        return $this->identity;
    }

    public function setIdentity(ResourceServiceIdentityInterface $identity): static
    {
        $this->identity = $identity;
        return $this;
    }

    public function freshIdentity(string|null $type, array $data = []): ServiceIdentityBasic
    {
        $identity = new ServiceIdentityBasic();
        $identity->jsonDeserialize($data);
        return $identity;
    }

    public function getDebug(): bool
    {
        return $this->serviceDebug;
    }

    public function setDebug(bool $debug): static
    {
        $this->serviceDebug = $debug;
        return $this;
    }

    public function getAuxiliary(): array
    {
        return $this->auxiliary;
    }

    public function setAuxiliary(array $auxiliary): static
    {
        $this->auxiliary = $auxiliary;
        return $this;
    }

    // Collection operations

    public function collectionList(string|int|null $location, ?IFilter $filter = null, ?ISort $sort = null): array
    {
        $this->initialize();
        
        $collections = $this->mailService->collectionList($location, $filter, $sort);

        foreach ($collections as &$collection) {
            if (is_array($collection) && isset($collection['id'])) {
                $object = new CollectionResource(provider: $this->provider(), service: $this->identifier());
                $object->fromJmap($collection);
                $collection = $object;
            }
        }
        
        return $collections;
    }

    public function collectionListFilter(): Filter
    {
        return new Filter($this->serviceAbilities[self::CAPABILITY_COLLECTION_LIST_FILTER] ?? []);
    }

    public function collectionListSort(): Sort
    {
        return new Sort($this->serviceAbilities[self::CAPABILITY_COLLECTION_LIST_SORT] ?? []);
    }

    public function collectionExtant(string|int ...$identifiers): array
    {
        $this->initialize();
        
        return $this->mailService->collectionExtant(...$identifiers);
    }

    public function collectionFetch(string|int $identifier): ?CollectionBaseInterface
    {
        $this->initialize();
        
        $collection = $this->mailService->collectionFetch($identifier);
        
        if (is_array($collection) && isset($collection['id'])) {
            $object = new CollectionResource(provider: $this->provider(), service: $this->identifier());
            $object->fromJmap($collection);
            $collection = $object;
        }

        return $collection;
    }

    public function collectionFresh(): CollectionMutableInterface
    {
        return new CollectionResource(provider: $this->provider(), service: $this->identifier());
    }

    public function collectionCreate(string|int|null $location, CollectionMutableInterface $collection, array $options = []): CollectionBaseInterface
    {
        $this->initialize();

        if ($collection instanceof CollectionResource === false) {
            $object = new CollectionResource(provider: $this->provider(), service: $this->identifier());
            $object->jsonDeserialize($collection->jsonSerialize());
            $collection = $object;
        }

        $collection = $collection->toJmap();
        $collection = $this->mailService->collectionCreate($location, $collection, $options);

        $object = new CollectionResource(provider: $this->provider(), service: $this->identifier());
        $object->fromJmap($collection);

        return $object;
    }

    public function collectionModify(string|int $identifier, CollectionMutableInterface $collection): CollectionBaseInterface
    {
        $this->initialize();

        if ($collection instanceof CollectionResource === false) {
            $object = new CollectionResource(provider: $this->provider(), service: $this->identifier());
            $object->jsonDeserialize($collection->jsonSerialize());
            $collection = $object;
        }

        $collection = $collection->toJmap();
        $collection = $this->mailService->collectionModify($identifier, $collection);

        $object = new CollectionResource(provider: $this->provider(), service: $this->identifier());
        $object->fromJmap($collection);

        return $object;
    }

    public function collectionDestroy(string|int $identifier, bool $force = false, bool $recursive = false): bool
    {
        $this->initialize();

        return $this->mailService->collectionDestroy($identifier, $force, $recursive) !== null;
    }

    public function collectionMove(string|int $identifier, string|int|null $targetLocation): CollectionBaseInterface
    {
        // TODO: Implement collection move
        $this->initialize();
        $collection = new CollectionResource(provider: $this->provider(), service: $this->identifier());
        return $collection;
    }

    // Entity operations

    public function entityList(string|int $collection, ?IFilter $filter = null, ?ISort $sort = null, ?IRange $range = null, ?array $properties = null): array
    {
        $this->initialize();
        
        $result = $this->mailService->entityList($collection, $filter, $sort, $range, $properties);

        $list = [];
        foreach ($result['list'] as $index => $entry) {
            if (is_array($entry) && isset($entry['id'])) {
                $object = new EntityResource(provider: $this->provider(), service: $this->identifier());
                $object->fromJmap($entry);
                $list[$object->identifier()] = $object;
            }
            unset($result['list'][$index]);
        }

        return $list;
    }

    public function entityListFilter(): Filter
    {
        return new Filter($this->serviceAbilities[self::CAPABILITY_ENTITY_LIST_FILTER] ?? []);
    }

    public function entityListSort(): Sort
    {
        return new Sort($this->serviceAbilities[self::CAPABILITY_ENTITY_LIST_SORT] ?? []);
    }

    public function entityListRange(RangeType $type): IRange
    {
        return new Range();
    }

    public function entityDelta(string|int $collection, string $signature, string $detail = 'ids'): Delta
    {
        $this->initialize();

        return $this->mailService->entityDelta($collection, $signature, $detail);
    }

    public function entityExtant(string|int $collection, string|int ...$identifiers): array
    {
        $this->initialize();

        return $this->mailService->entityExtant(...$identifiers);
    }

    public function entityFetch(string|int $collection, string|int ...$identifiers): array
    {
        $this->initialize();

        $entities = $this->mailService->entityFetch(...$identifiers);
        
        foreach ($entities as &$entity) {
            if (is_array($entity) && isset($entity['id'])) {
                $object = new EntityResource(provider: $this->provider(), service: $this->identifier());
                $object->fromJmap($entity);
                $entity = $object;
            }
        }

        return $entities;
    }

}