<?php

declare(strict_types=1);

namespace OpenStack\ObjectStore\v1\Models;

use GuzzleHttp\Promise\Promise;
use GuzzleHttp\Psr7\LimitStream;
use Psr\Http\Message\ResponseInterface;
use OpenStack\Common\Error\BadResponseError;
use OpenStack\Common\Resource\OperatorResource;
use OpenStack\Common\Resource\Creatable;
use OpenStack\Common\Resource\Deletable;
use OpenStack\Common\Resource\HasMetadata;
use OpenStack\Common\Resource\Listable;
use OpenStack\Common\Resource\Retrievable;

/**
 * @property \OpenStack\ObjectStore\v1\Api $api
 */
class Container extends OperatorResource implements Creatable, Deletable, Retrievable, Listable, HasMetadata
{
    use MetadataTrait;

    const METADATA_PREFIX = 'X-Container-Meta-';

    /** @var int */
    public $objectCount;

    /** @var int */
    public $bytesUsed;

    /** @var string */
    public $name;

    /** @var array */
    public $metadata;

    protected $markerKey = 'name';

    /**
     * {@inheritdoc}
     */
    public function populateFromResponse(ResponseInterface $response): self
    {
        parent::populateFromResponse($response);

        $this->objectCount = $response->getHeaderLine('X-Container-Object-Count');
        $this->bytesUsed   = $response->getHeaderLine('X-Container-Bytes-Used');
        $this->metadata    = $this->parseMetadata($response);

        return $this;
    }

    /**
     * Retrieves a collection of object resources in the form of a generator.
     *
     * @param array         $options {@see \OpenStack\ObjectStore\v1\Api::getContainer}
     * @param callable|null $mapFn   allows a function to be mapped over each element
     *
     * @return \Generator
     */
    public function listObjects(array $options = [], callable $mapFn = null): \Generator
    {
        $options = array_merge($options, ['name' => $this->name, 'format' => 'json']);

        $appendContainerNameFn = function (StorageObject $resource) use ($mapFn) {
            $resource->containerName = $this->name;
            if ($mapFn) {
                call_user_func_array($mapFn, [&$resource]);
            }
        };

        return $this->model(StorageObject::class)->enumerate($this->api->getContainer(), $options, $appendContainerNameFn);
    }

    /**
     * {@inheritdoc}
     */
    public function retrieve()
    {
        $response = $this->executeWithState($this->api->headContainer());
        $this->populateFromResponse($response);
    }

    /**
     * @param array $data {@see \OpenStack\ObjectStore\v1\Api::putContainer}
     *
     * @return $this
     */
    public function create(array $data): Creatable
    {
        $response = $this->execute($this->api->putContainer(), $data);

        $this->populateFromResponse($response);
        $this->name = $data['name'];

        return $this;
    }

    /**
     * {@inheritdoc}
     */
    public function delete()
    {
        $this->executeWithState($this->api->deleteContainer());
    }

    /**
     * {@inheritdoc}
     */
    public function mergeMetadata(array $metadata)
    {
        $response       = $this->execute($this->api->postContainer(), ['name' => $this->name, 'metadata' => $metadata]);
        $this->metadata = $this->parseMetadata($response);
    }

    /**
     * {@inheritdoc}
     */
    public function resetMetadata(array $metadata)
    {
        $options = [
            'name'           => $this->name,
            'removeMetadata' => [],
            'metadata'       => $metadata,
        ];

        foreach ($this->getMetadata() as $key => $val) {
            if (!array_key_exists($key, $metadata)) {
                $options['removeMetadata'][$key] = 'True';
            }
        }

        $response       = $this->execute($this->api->postContainer(), $options);
        $this->metadata = $this->parseMetadata($response);
    }

    /**
     * {@inheritdoc}
     */
    public function getMetadata(): array
    {
        $response = $this->executeWithState($this->api->headContainer());

        return $this->parseMetadata($response);
    }

    /**
     * Retrieves an StorageObject and populates its `name` and `containerName` properties according to the name provided and
     * the name of this container. A HTTP call will not be executed by default - you need to call
     * {@see StorageObject::retrieve} or {@see StorageObject::download} on the returned StorageObject object to do that.
     *
     * @param string $name The name of the object
     *
     * @return StorageObject
     */
    public function getObject($name): StorageObject
    {
        return $this->model(StorageObject::class, ['containerName' => $this->name, 'name' => $name]);
    }

    /**
     * Identifies whether an object exists in this container.
     *
     * @param string $name the name of the object
     *
     * @return bool TRUE if the object exists, FALSE if it does not
     *
     * @throws BadResponseError for any other HTTP error which does not have a 404 Not Found status
     * @throws \Exception       for any other type of fatal error
     */
    public function objectExists(string $name): bool
    {
        try {
            $this->getObject($name)->retrieve();

            return true;
        } catch (BadResponseError $e) {
            if (404 === $e->getResponse()->getStatusCode()) {
                return false;
            }
            throw $e;
        }
    }

    /**
     * Creates a single object according to the values provided.
     *
     * @param array $data {@see \OpenStack\ObjectStore\v1\Api::putObject}
     *
     * @return object
     */
    public function createObject(array $data): StorageObject
    {
        return $this->model(StorageObject::class)->create($data + ['containerName' => $this->name]);
    }

    /**
     * Creates a Dynamic Large Object by chunking a file into smaller segments and uploading them into a holding
     * container. When this completes, a manifest file is uploaded which references the prefix of the segments,
     * allowing concatenation when a request is executed against the manifest.
     *
     * @param array  $data                     {@see \OpenStack\ObjectStore\v1\Api::putObject}
     * @param int    $data['segmentSize']      The size in Bytes of each segment
     * @param string $data['segmentContainer'] The container to which each segment will be uploaded
     * @param string $data['segmentPrefix']    The prefix that will come before each segment. If omitted, a default
     *                                         is used: name/timestamp/filesize
     *
     * @return StorageObject
     */
    public function createLargeObject(array $data): StorageObject
    {
        /** @var \Psr\Http\Message\StreamInterface $stream */
        $stream = $data['stream'];

        $segmentSize      = isset($data['segmentSize']) ? $data['segmentSize'] : 1073741824;
        $segmentContainer = isset($data['segmentContainer']) ? $data['segmentContainer'] : $this->name.'_segments';
        $segmentPrefix    = isset($data['segmentPrefix'])
            ? $data['segmentPrefix']
            : sprintf('%s/%s/%d', $data['name'], microtime(true), $stream->getSize());

        /** @var \OpenStack\ObjectStore\v1\Service $service */
        $service = $this->getService();
        if (!$service->containerExists($segmentContainer)) {
            $service->createContainer(['name' => $segmentContainer]);
        }

        $promises      = [];
        $count         = 0;
        $totalSegments = $stream->getSize() / $segmentSize;

        while (!$stream->eof() && $count < $totalSegments) {
            $promises[] = $this->model(StorageObject::class)->createAsync([
                'name'          => sprintf('%s/%d', $segmentPrefix, ++$count),
                'stream'        => new LimitStream($stream, $segmentSize, ($count - 1) * $segmentSize),
                'containerName' => $segmentContainer,
            ]);
        }

        /** @var Promise $p */
        $p = \GuzzleHttp\Promise\all($promises);
        $p->wait();

        return $this->createObject([
            'name'           => $data['name'],
            'objectManifest' => sprintf('%s/%s', $segmentContainer, $segmentPrefix),
        ]);
    }
}
