<?php
namespace Kant\Filesystem;

use Kant\Kant;
use Closure;
use Aws\S3\S3Client;
use OpenCloud\Rackspace;
use Kant\Support\Arr;
use Kant\Exception\InvalidArgumentException;
use League\Flysystem\AdapterInterface;
use League\Flysystem\FilesystemInterface;
use League\Flysystem\Filesystem as Flysystem;
use League\Flysystem\Adapter\Ftp as FtpAdapter;
use League\Flysystem\Rackspace\RackspaceAdapter;
use League\Flysystem\Adapter\Local as LocalAdapter;
use League\Flysystem\AwsS3v3\AwsS3Adapter as S3Adapter;

class FilesystemManager
{

    /**
     * The array of resolved filesystem drivers.
     *
     * @var array
     */
    protected $disks = [];

    /**
     * The registered custom driver creators.
     *
     * @var array
     */
    protected $customCreators = [];

    /**
     * Create a new filesystem manager instance.
     */
    public function __construct()
    {}

    /**
     * Get a filesystem instance.
     *
     * @param string $name            
     * @return \Kant\Filesystem\Contracts\Filesystem
     */
    public function drive($name = null)
    {
        return $this->disk($name);
    }

    /**
     * Get a filesystem instance.
     *
     * @param string $name            
     * @return \Kant\Filesystem\Contracts\Filesystem
     */
    public function disk($name = null)
    {
        $name = $name ?  : $this->getDefaultDriver();
        return $this->disks[$name] = $this->get($name);
    }

    /**
     * Get a default cloud filesystem instance.
     *
     * @return \Kant\Filesystem\Contracts\Filesystem
     */
    public function cloud()
    {
        $name = $this->getDefaultCloudDriver();
        
        return $this->disks[$name] = $this->get($name);
    }

    /**
     * Attempt to get the disk from the local cache.
     *
     * @param string $name            
     * @return \Kant\Filesystem\Contracts\Filesystem
     */
    protected function get($name)
    {
        return isset($this->disks[$name]) ? $this->disks[$name] : $this->resolve($name);
    }

    /**
     * Resolve the given disk.
     *
     * @param string $name            
     * @return \Kant\Filesystem\Contracts\Filesystem
     *
     * @throws \Kant\Exception\InvalidArgumentException
     */
    protected function resolve($name)
    {
        $config = $this->getConfig($name);
        if (isset($this->customCreators[$config['driver']])) {
            return $this->callCustomCreator($config);
        }
        $driverMethod = 'create' . ucfirst($config['driver']) . 'Driver';
        
        if (method_exists($this, $driverMethod)) {
            return $this->{$driverMethod}($config);
        } else {
            throw new InvalidArgumentException("Driver [{$config['driver']}] is not supported.");
        }
    }

    /**
     * Call a custom driver creator.
     *
     * @param array $config            
     * @return \Kant\Filesystem\Contracts\Filesystem
     */
    protected function callCustomCreator(array $config)
    {
        $driver = $this->customCreators[$config['driver']]($config);
        
        if ($driver instanceof FilesystemInterface) {
            return $this->adapt($driver);
        }
        
        return $driver;
    }

    /**
     * Create an instance of the local driver.
     *
     * @param array $config            
     * @return \Kant\Filesystem\Contracts\Filesystem
     */
    public function createLocalDriver(array $config)
    {
        $permissions = isset($config['permissions']) ? $config['permissions'] : [];
        
        $links = Arr::get($config, 'links') === 'skip' ? LocalAdapter::SKIP_LINKS : LocalAdapter::DISALLOW_LINKS;
        
        return $this->adapt($this->createFlysystem(new LocalAdapter($config['root'], LOCK_EX, $links, $permissions), $config));
    }

    /**
     * Create an instance of the ftp driver.
     *
     * @param array $config            
     * @return \Kant\Filesystem\Contracts\Filesystem
     */
    public function createFtpDriver(array $config)
    {
        $ftpConfig = Arr::only($config, [
            'host',
            'username',
            'password',
            'port',
            'root',
            'passive',
            'ssl',
            'timeout'
        ]);
        
        return $this->adapt($this->createFlysystem(new FtpAdapter($ftpConfig), $config));
    }

    /**
     * Create an instance of the Amazon S3 driver.
     *
     * @param array $config            
     * @return \Kant\Filesystem\Contracts\Cloud
     */
    public function createS3Driver(array $config)
    {
        $s3Config = $this->formatS3Config($config);
        
        $root = isset($s3Config['root']) ? $s3Config['root'] : null;
        
        $options = isset($config['options']) ? $config['options'] : [];
        
        return $this->adapt($this->createFlysystem(new S3Adapter(new S3Client($s3Config), $s3Config['bucket'], $root, $options), $config));
    }

    /**
     * Format the given S3 configuration with the default options.
     *
     * @param array $config            
     * @return array
     */
    protected function formatS3Config(array $config)
    {
        $config += [
            'version' => 'latest'
        ];
        
        if ($config['key'] && $config['secret']) {
            $config['credentials'] = Arr::only($config, [
                'key',
                'secret'
            ]);
        }
        
        return $config;
    }

    /**
     * Create an instance of the Rackspace driver.
     *
     * @param array $config            
     * @return \Kant\Filesystem\Contracts\Cloud
     */
    public function createRackspaceDriver(array $config)
    {
        $client = new Rackspace($config['endpoint'], [
            'username' => $config['username'],
            'apiKey' => $config['key']
        ]);
        
        $root = isset($config['root']) ? $config['root'] : null;
        
        return $this->adapt($this->createFlysystem(new RackspaceAdapter($this->getRackspaceContainer($client, $config), $root), $config));
    }

    /**
     * Get the Rackspace Cloud Files container.
     *
     * @param \OpenCloud\Rackspace $client            
     * @param array $config            
     * @return \OpenCloud\ObjectStore\Resource\Container
     */
    protected function getRackspaceContainer(Rackspace $client, array $config)
    {
        $urlType = Arr::get($config, 'url_type');
        
        $store = $client->objectStoreService('cloudFiles', $config['region'], $urlType);
        
        return $store->getContainer($config['container']);
    }

    /**
     * Create a Flysystem instance with the given adapter.
     *
     * @param \League\Flysystem\AdapterInterface $adapter            
     * @param array $config            
     * @return \League\Flysystem\FlysystemInterface
     */
    protected function createFlysystem(AdapterInterface $adapter, array $config)
    {
        $config = Arr::only($config, [
            'visibility',
            'disable_asserts',
            'url'
        ]);
        
        return new Flysystem($adapter, count($config) > 0 ? $config : null);
    }

    /**
     * Adapt the filesystem implementation.
     *
     * @param \League\Flysystem\FilesystemInterface $filesystem            
     * @return \Kant\Filesystem\Contracts\Filesystem
     */
    protected function adapt(FilesystemInterface $filesystem)
    {
        return new FilesystemAdapter($filesystem);
    }

    /**
     * Get the filesystem connection configuration.
     *
     * @param string $name            
     * @return array
     */
    protected function getConfig($name)
    {
        return Kant::$app->config->get("filesystems.disks.{$name}");
    }

    /**
     * Get the default driver name.
     *
     * @return string
     */
    public function getDefaultDriver()
    {
        return Kant::$app->config->get('filesystems.default');
    }

    /**
     * Get the default cloud driver name.
     *
     * @return string
     */
    public function getDefaultCloudDriver()
    {
        return Kant::$app->config->get('filesystems.cloud');
    }

    /**
     * Register a custom driver creator Closure.
     *
     * @param string $driver            
     * @param \Closure $callback            
     * @return $this
     */
    public function extend($driver, Closure $callback)
    {
        $this->customCreators[$driver] = $callback;
        
        return $this;
    }

    /**
     * Dynamically call the default driver instance.
     *
     * @param string $method            
     * @param array $parameters            
     * @return mixed
     */
    public function __call($method, $parameters)
    {
        return call_user_func_array([
            $this->disk(),
            $method
        ], $parameters);
    }
}
