<?php

/**

 * Zend Framework

 *

 * LICENSE

 *

 * This source file is subject to the new BSD license that is bundled

 * with this package in the file LICENSE.txt.

 * It is also available through the world-wide-web at this URL:

 * http://framework.zend.com/license/new-bsd

 * If you did not receive a copy of the license and are unable to

 * obtain it through the world-wide-web, please send an email

 * to license@zend.com so we can send you a copy immediately.

 *

 * @category  Zend

 * @package   Zend_File_Transfer

 * @copyright  Copyright (c) 2005-2010 Zend Technologies USA Inc. (http://www.zend.com)

 * @license   http://framework.zend.com/license/new-bsd     New BSD License

 * @version   $Id: Abstract.php 22371 2010-06-04 20:09:44Z thomas $

 */

/**

 * Abstract class for file transfers (Downloads and Uploads)

 *

 * @category  Zend

 * @package   Zend_File_Transfer

 * @copyright  Copyright (c) 2005-2010 Zend Technologies USA Inc. (http://www.zend.com)

 * @license   http://framework.zend.com/license/new-bsd     New BSD License

 */

abstract class Zend_File_Transfer_Adapter_Abstract

{

    /**@+

     * Plugin loader Constants

     */

    const FILTER    = 'FILTER';

    const VALIDATE  = 'VALIDATE';

    /**@-*/

    /**

     * Internal list of breaks

     *

     * @var array

     */

    protected $_break = array();

    /**

     * Internal list of filters

     *

     * @var array

     */

    protected $_filters = array();

    /**

     * Plugin loaders for filter and validation chains

     *

     * @var array

     */

    protected $_loaders = array();

    /**

     * Internal list of messages

     *

     * @var array

     */

    protected $_messages = array();

    /**

     * @var Zend_Translate

     */

    protected $_translator;

    /**

     * Is translation disabled?

     *

     * @var bool

     */

    protected $_translatorDisabled = false;

    /**

     * Internal list of validators

     * @var array

     */

    protected $_validators = array();

    /**

     * Internal list of files

     * This array looks like this:

     *     array(form => array( - Form is the name within the form or, if not set the filename

     *         name,            - Original name of this file

     *         type,            - Mime type of this file

     *         size,            - Filesize in bytes

     *         tmp_name,        - Internalally temporary filename for uploaded files

     *         error,           - Error which has occured

     *         destination,     - New destination for this file

     *         validators,      - Set validator names for this file

     *         files            - Set file names for this file

     *     ))

     *

     * @var array

     */

    protected $_files = array();

    /**

     * TMP directory

     * @var string

     */

    protected $_tmpDir;

    /**

     * Available options for file transfers

     */

    protected $_options = array(

        'ignoreNoFile'  => false,

        'useByteString' => true,

        'magicFile'     => null,

        'detectInfos'   => true,

    );

    /**

     * Send file

     *

     * @param  mixed $options

     * @return bool

     */

    abstract public function send($options = null);

    /**

     * Receive file

     *

     * @param  mixed $options

     * @return bool

     */

    abstract public function receive($options = null);

    /**

     * Is file sent?

     *

     * @param  array|string|null $files

     * @return bool

     */

    abstract public function isSent($files = null);

    /**

     * Is file received?

     *

     * @param  array|string|null $files

     * @return bool

     */

    abstract public function isReceived($files = null);

    /**

     * Has a file been uploaded ?

     *

     * @param  array|string|null $files

     * @return bool

     */

    abstract public function isUploaded($files = null);

    /**

     * Has the file been filtered ?

     *

     * @param array|string|null $files

     * @return bool

     */

    abstract public function isFiltered($files = null);

    /**

     * Retrieve progress of transfer

     *

     * @return float

     */

    public static function getProgress()

    {

        require_once 'Zend/File/Transfer/Exception.php';

        throw new Zend_File_Transfer_Exception('Method must be implemented within the adapter');

    }

    /**

     * Set plugin loader to use for validator or filter chain

     *

     * @param  Zend_Loader_PluginLoader_Interface $loader

     * @param  string $type 'filter', or 'validate'

     * @return Zend_File_Transfer_Adapter_Abstract

     * @throws Zend_File_Transfer_Exception on invalid type

     */

    public function setPluginLoader(Zend_Loader_PluginLoader_Interface $loader, $type)

    {

        $type = strtoupper($type);

        switch ($type) {

            case self::FILTER:

            case self::VALIDATE:

                $this->_loaders[$type] = $loader;

                return $this;

            default:

                require_once 'Zend/File/Transfer/Exception.php';

                throw new Zend_File_Transfer_Exception(sprintf('Invalid type "%s" provided to setPluginLoader()', $type));

        }

    }

    /**

     * Retrieve plugin loader for validator or filter chain

     *

     * Instantiates with default rules if none available for that type. Use

     * 'filter' or 'validate' for $type.

     *

     * @param  string $type

     * @return Zend_Loader_PluginLoader

     * @throws Zend_File_Transfer_Exception on invalid type.

     */

    public function getPluginLoader($type)

    {

        $type = strtoupper($type);

        switch ($type) {

            case self::FILTER:

            case self::VALIDATE:

                $prefixSegment = ucfirst(strtolower($type));

                $pathSegment   = $prefixSegment;

                if (!isset($this->_loaders[$type])) {

                    $paths         = array(

                        'Zend_' . $prefixSegment . '_'     => 'Zend/' . $pathSegment . '/',

                        'Zend_' . $prefixSegment . '_File' => 'Zend/' . $pathSegment . '/File',

                    );

                    require_once 'Zend/Loader/PluginLoader.php';

                    $this->_loaders[$type] = new Zend_Loader_PluginLoader($paths);

                } else {

                    $loader = $this->_loaders[$type];

                    $prefix = 'Zend_' . $prefixSegment . '_File_';

                    if (!$loader->getPaths($prefix)) {

                        $loader->addPrefixPath($prefix, str_replace('_', '/', $prefix));

                    }

                }

                return $this->_loaders[$type];

            default:

                require_once 'Zend/File/Transfer/Exception.php';

                throw new Zend_File_Transfer_Exception(sprintf('Invalid type "%s" provided to getPluginLoader()', $type));

        }

    }

    /**

     * Add prefix path for plugin loader

     *

     * If no $type specified, assumes it is a base path for both filters and

     * validators, and sets each according to the following rules:

     * - filters:    $prefix = $prefix . '_Filter'

     * - validators: $prefix = $prefix . '_Validate'

     *

     * Otherwise, the path prefix is set on the appropriate plugin loader.

     *

     * @param  string $prefix

     * @param  string $path

     * @param  string $type

     * @return Zend_File_Transfer_Adapter_Abstract

     * @throws Zend_File_Transfer_Exception for invalid type

     */

    public function addPrefixPath($prefix, $path, $type = null)

    {

        $type = strtoupper($type);

        switch ($type) {

            case self::FILTER:

            case self::VALIDATE:

                $loader = $this->getPluginLoader($type);

                $loader->addPrefixPath($prefix, $path);

                return $this;

            case null:

                $prefix = rtrim($prefix, '_');

                $path   = rtrim($path, DIRECTORY_SEPARATOR);

                foreach (array(self::FILTER, self::VALIDATE) as $type) {

                    $cType        = ucfirst(strtolower($type));

                    $pluginPath   = $path . DIRECTORY_SEPARATOR . $cType . DIRECTORY_SEPARATOR;

                    $pluginPrefix = $prefix . '_' . $cType;

                    $loader       = $this->getPluginLoader($type);

                    $loader->addPrefixPath($pluginPrefix, $pluginPath);

                }

                return $this;

            default:

                require_once 'Zend/File/Transfer/Exception.php';

                throw new Zend_File_Transfer_Exception(sprintf('Invalid type "%s" provided to getPluginLoader()', $type));

        }

    }

    /**

     * Add many prefix paths at once

     *

     * @param  array $spec

     * @return Zend_File_Transfer_Exception

     */

    public function addPrefixPaths(array $spec)

    {

        if (isset($spec['prefix']) && isset($spec['path'])) {

            return $this->addPrefixPath($spec['prefix'], $spec['path']);

        }

        foreach ($spec as $type => $paths) {

            if (is_numeric($type) && is_array($paths)) {

                $type = null;

                if (isset($paths['prefix']) && isset($paths['path'])) {

                    if (isset($paths['type'])) {

                        $type = $paths['type'];

                    }

                    $this->addPrefixPath($paths['prefix'], $paths['path'], $type);

                }

            } elseif (!is_numeric($type)) {

                if (!isset($paths['prefix']) || !isset($paths['path'])) {

                    foreach ($paths as $prefix => $spec) {

                        if (is_array($spec)) {

                            foreach ($spec as $path) {

                                if (!is_string($path)) {

                                    continue;

                                }

                                $this->addPrefixPath($prefix, $path, $type);

                            }

                        } elseif (is_string($spec)) {

                            $this->addPrefixPath($prefix, $spec, $type);

                        }

                    }

                } else {

                    $this->addPrefixPath($paths['prefix'], $paths['path'], $type);

                }

            }

        }

        return $this;

    }

    /**

     * Adds a new validator for this class

     *

     * @param  string|array $validator           Type of validator to add

     * @param  boolean      $breakChainOnFailure If the validation chain should stop an failure

     * @param  string|array $options             Options to set for the validator

     * @param  string|array $files               Files to limit this validator to

     * @return Zend_File_Transfer_Adapter

     */

    public function addValidator($validator, $breakChainOnFailure = false, $options = null, $files = null)

    {

        if ($validator instanceof Zend_Validate_Interface) {

            $name = get_class($validator);

        } elseif (is_string($validator)) {

            $name      = $this->getPluginLoader(self::VALIDATE)->load($validator);

            $validator = new $name($options);

            if (is_array($options) && isset($options['messages'])) {

                if (is_array($options['messages'])) {

                    $validator->setMessages($options['messages']);

                } elseif (is_string($options['messages'])) {

                    $validator->setMessage($options['messages']);

                }

                unset($options['messages']);

            }

        } else {

            require_once 'Zend/File/Transfer/Exception.php';

            throw new Zend_File_Transfer_Exception('Invalid validator provided to addValidator; must be string or Zend_Validate_Interface');

        }

        $this->_validators[$name] = $validator;

        $this->_break[$name]      = $breakChainOnFailure;

        $files                    = $this->_getFiles($files, true, true);

        foreach ($files as $file) {

            if ($name == 'NotEmpty') {

                $temp = $this->_files[$file]['validators'];

                $this->_files[$file]['validators']  = array($name);

                $this->_files[$file]['validators'] += $temp;

            } else {

                $this->_files[$file]['validators'][] = $name;

            }

            $this->_files[$file]['validated']    = false;

        }

        return $this;

    }

    /**

     * Add Multiple validators at once

     *

     * @param  array $validators

     * @param  string|array $files

     * @return Zend_File_Transfer_Adapter_Abstract

     */

    public function addValidators(array $validators, $files = null)

    {

        foreach ($validators as $name => $validatorInfo) {

            if ($validatorInfo instanceof Zend_Validate_Interface) {

                $this->addValidator($validatorInfo, null, null, $files);

            } else if (is_string($validatorInfo)) {

                if (!is_int($name)) {

                    $this->addValidator($name, null, $validatorInfo, $files);

                } else {

                    $this->addValidator($validatorInfo, null, null, $files);

                }

            } else if (is_array($validatorInfo)) {

                $argc                = count($validatorInfo);

                $breakChainOnFailure = false;

                $options             = array();

                if (isset($validatorInfo['validator'])) {

                    $validator = $validatorInfo['validator'];

                    if (isset($validatorInfo['breakChainOnFailure'])) {

                        $breakChainOnFailure = $validatorInfo['breakChainOnFailure'];

                    }

                    if (isset($validatorInfo['options'])) {

                        $options = $validatorInfo['options'];

                    }

                    $this->addValidator($validator, $breakChainOnFailure, $options, $files);

                } else {

                    if (is_string($name)) {

                        $validator = $name;

                        $options   = $validatorInfo;

                        $this->addValidator($validator, $breakChainOnFailure, $options, $files);

                    } else {

                        $file = $files;

                        switch (true) {

                            case (0 == $argc):

                                break;

                            case (1 <= $argc):

                                $validator  = array_shift($validatorInfo);

                            case (2 <= $argc):

                                $breakChainOnFailure = array_shift($validatorInfo);

                            case (3 <= $argc):

                                $options = array_shift($validatorInfo);

                            case (4 <= $argc):

                                if (!empty($validatorInfo)) {

                                    $file = array_shift($validatorInfo);

                                }

                            default:

                                $this->addValidator($validator, $breakChainOnFailure, $options, $file);

                                break;

                        }

                    }

                }