<?php
/**
 * DokuWiki Plugin extension (Helper Component)
 *
 * @license GPL 2 http://www.gnu.org/licenses/gpl-2.0.html
 * @author  Michael Hamann <michael@content-space.de>
 */

use dokuwiki\HTTP\DokuHTTPClient;
use dokuwiki\Extension\PluginController;

/**
 * Class helper_plugin_extension_extension represents a single extension (plugin or template)
 */
class helper_plugin_extension_extension extends DokuWiki_Plugin
{
    private $id;
    private $base;
    private $is_template = false;
    private $localInfo;
    private $remoteInfo;
    private $managerData;
    /** @var helper_plugin_extension_repository $repository */
    private $repository = null;

    /** @var array list of temporary directories */
    private $temporary = array();

    /** @var string where templates are installed to */
    private $tpllib = '';

    /**
     * helper_plugin_extension_extension constructor.
     */
    public function __construct()
    {
        $this->tpllib = dirname(tpl_incdir()).'/';
    }

    /**
     * Destructor
     *
     * deletes any dangling temporary directories
     */
    public function __destruct()
    {
        foreach ($this->temporary as $dir) {
            io_rmdir($dir, true);
        }
    }

    /**
     * @return bool false, this component is not a singleton
     */
    public function isSingleton()
    {
        return false;
    }

    /**
     * Set the name of the extension this instance shall represents, triggers loading the local and remote data
     *
     * @param string $id  The id of the extension (prefixed with template: for templates)
     * @return bool If some (local or remote) data was found
     */
    public function setExtension($id)
    {
        $id = cleanID($id);
        $this->id   = $id;
        $this->base = $id;

        if (substr($id, 0, 9) == 'template:') {
            $this->base = substr($id, 9);
            $this->is_template = true;
        } else {
            $this->is_template = false;
        }

        $this->localInfo = array();
        $this->managerData = array();
        $this->remoteInfo = array();

        if ($this->isInstalled()) {
            $this->readLocalData();
            $this->readManagerData();
        }

        if ($this->repository == null) {
            $this->repository = $this->loadHelper('extension_repository');
        }

        $this->remoteInfo = $this->repository->getData($this->getID());

        return ($this->localInfo || $this->remoteInfo);
    }

    /**
     * If the extension is installed locally
     *
     * @return bool If the extension is installed locally
     */
    public function isInstalled()
    {
        return is_dir($this->getInstallDir());
    }

    /**
     * If the extension is under git control
     *
     * @return bool
     */
    public function isGitControlled()
    {
        if (!$this->isInstalled()) return false;
        return is_dir($this->getInstallDir().'/.git');
    }

    /**
     * If the extension is bundled
     *
     * @return bool If the extension is bundled
     */
    public function isBundled()
    {
        if (!empty($this->remoteInfo['bundled'])) return $this->remoteInfo['bundled'];
        return in_array(
            $this->id,
            array(
                'authad', 'authldap', 'authpdo', 'authplain',
                'acl', 'config', 'extension', 'info', 'popularity', 'revert',
                'safefnrecode', 'styling', 'testing', 'usermanager', 'logviewer',
                'template:dokuwiki',
            )
        );
    }

    /**
     * If the extension is protected against any modification (disable/uninstall)
     *
     * @return bool if the extension is protected
     */
    public function isProtected()
    {
        // never allow deinstalling the current auth plugin:
        global $conf;
        if ($this->id == $conf['authtype']) return true;

        /** @var PluginController $plugin_controller */
        global $plugin_controller;
        $cascade = $plugin_controller->getCascade();
        return (isset($cascade['protected'][$this->id]) && $cascade['protected'][$this->id]);
    }

    /**
     * If the extension is installed in the correct directory
     *
     * @return bool If the extension is installed in the correct directory
     */
    public function isInWrongFolder()
    {
        return $this->base != $this->getBase();
    }

    /**
     * If the extension is enabled
     *
     * @return bool If the extension is enabled
     */
    public function isEnabled()
    {
        global $conf;
        if ($this->isTemplate()) {
            return ($conf['template'] == $this->getBase());
        }

        /* @var PluginController $plugin_controller */
        global $plugin_controller;
        return $plugin_controller->isEnabled($this->base);
    }

    /**
     * If the extension should be updated, i.e. if an updated version is available
     *
     * @return bool If an update is available
     */
    public function updateAvailable()
    {
        if (!$this->isInstalled()) return false;
        if ($this->isBundled()) return false;
        $lastupdate = $this->getLastUpdate();
        if ($lastupdate === false) return false;
        $installed  = $this->getInstalledVersion();
        if ($installed === false || $installed === $this->getLang('unknownversion')) return true;
        return $this->getInstalledVersion() < $this->getLastUpdate();
    }

    /**
     * If the extension is a template
     *
     * @return bool If this extension is a template
     */
    public function isTemplate()
    {
        return $this->is_template;
    }

    /**
     * Get the ID of the extension
     *
     * This is the same as getName() for plugins, for templates it's getName() prefixed with 'template:'
     *
     * @return string
     */
    public function getID()
    {
        return $this->id;
    }

    /**
     * Get the name of the installation directory
     *
     * @return string The name of the installation directory
     */
    public function getInstallName()
    {
        return $this->base;
    }

    // Data from plugin.info.txt/template.info.txt or the repo when not available locally
    /**
     * Get the basename of the extension
     *
     * @return string The basename
     */
    public function getBase()
    {
        if (!empty($this->localInfo['base'])) return $this->localInfo['base'];
        return $this->base;
    }

    /**
     * Get the display name of the extension
     *
     * @return string The display name
     */
    public function getDisplayName()
    {
        if (!empty($this->localInfo['name'])) return $this->localInfo['name'];
        if (!empty($this->remoteInfo['name'])) return $this->remoteInfo['name'];
        return $this->base;
    }

    /**
     * Get the author name of the extension
     *
     * @return string|bool The name of the author or false if there is none
     */
    public function getAuthor()
    {
        if (!empty($this->localInfo['author'])) return $this->localInfo['author'];
        if (!empty($this->remoteInfo['author'])) return $this->remoteInfo['author'];
        return false;
    }

    /**
     * Get the email of the author of the extension if there is any
     *
     * @return string|bool The email address or false if there is none
     */
    public function getEmail()
    {
        // email is only in the local data
        if (!empty($this->localInfo['email'])) return $this->localInfo['email'];
        return false;
    }

    /**
     * Get the email id, i.e. the md5sum of the email
     *
     * @return string|bool The md5sum of the email if there is any, false otherwise
     */
    public function getEmailID()
    {
        if (!empty($this->remoteInfo['emailid'])) return $this->remoteInfo['emailid'];
        if (!empty($this->localInfo['email'])) return md5($this->localInfo['email']);
        return false;
    }

    /**
     * Get the description of the extension
     *
     * @return string The description
     */
    public function getDescription()
    {
        if (!empty($this->localInfo['desc'])) return $this->localInfo['desc'];
        if (!empty($this->remoteInfo['description'])) return $this->remoteInfo['description'];
        return '';
    }

    /**
     * Get the URL of the extension, usually a page on dokuwiki.org
     *
     * @return string The URL
     */
    public function getURL()
    {
        if (!empty($this->localInfo['url'])) return $this->localInfo['url'];
        return 'https://www.dokuwiki.org/'.
            ($this->isTemplate() ? 'template' : 'plugin').':'.$this->getBase();
    }

    /**
     * Get the installed version of the extension
     *
     * @return string|bool The version, usually in the form yyyy-mm-dd if there is any
     */
    public function getInstalledVersion()
    {
        if (!empty($this->localInfo['date'])) return $this->localInfo['date'];
        if ($this->isInstalled()) return $this->getLang('unknownversion');
        return false;
    }

    /**
     * Get the install date of the current version
     *
     * @return string|bool The date of the last update or false if not available
     */
    public function getUpdateDate()
    {
        if (!empty($this->managerData['updated'])) return $this->managerData['updated'];
        return $this->getInstallDate();
    }

    /**
     * Get the date of the installation of the plugin
     *
     * @return string|bool The date of the installation or false if not available
     */
    public function getInstallDate()
    {
        if (!empty($this->managerData['installed'])) return $this->managerData['installed'];
        return false;
    }

    /**
     * Get the names of the dependencies of this extension
     *
     * @return array The base names of the dependencies
     */
    public function getDependencies()
    {
        if (!empty($this->remoteInfo['dependencies'])) return $this->remoteInfo['dependencies'];
        return array();
    }

    /**
     * Get the names of the missing dependencies
     *
     * @return array The base names of the missing dependencies
     */
    public function getMissingDependencies()
    {
        /* @var PluginController $plugin_controller */
        global $plugin_controller;
        $dependencies = $this->getDependencies();
        $missing_dependencies = array();
        foreach ($dependencies as $dependency) {
            if (!$plugin_controller->isEnabled($dependency)) {
                $missing_dependencies[] = $dependency;
            }
        }
        return $missing_dependencies;
    }

    /**
     * Get the names of all conflicting extensions
     *
     * @return array The names of the conflicting extensions
     */
    public function getConflicts()
    {
        if (!empty($this->remoteInfo['conflicts'])) return $this->remoteInfo['conflicts'];
        return array();
    }

    /**
     * Get the names of similar extensions
     *
     * @return array The names of similar extensions
     */
    public function getSimilarExtensions()
    {
        if (!empty($this->remoteInfo['similar'])) return $this->remoteInfo['similar'];
        return array();
    }

    /**
     * Get the names of the tags of the extension
     *
     * @return array The names of the tags of the extension
     */
    public function getTags()
    {
        if (!empty($this->remoteInfo['tags'])) return $this->remoteInfo['tags'];
        return array();
    }

    /**
     * Get the popularity information as floating point number [0,1]
     *
     * @return float|bool The popularity information or false if it isn't available
     */
    public function getPopularity()
    {
        if (!empty($this->remoteInfo['popularity'])) return $this->remoteInfo['popularity'];
        return false;
    }


    /**
     * Get the text of the security warning if there is any
     *
     * @return string|bool The security warning if there is any, false otherwise
     */
    public function getSecurityWarning()
    {
        if (!empty($this->remoteInfo['securitywarning'])) return $this->remoteInfo['securitywarning'];
        return false;
    }

    /**
     * Get the text of the security issue if there is any
     *
     * @return string|bool The security issue if there is any, false otherwise
     */
    public function getSecurityIssue()
    {
        if (!empty($this->remoteInfo['securityissue'])) return $this->remoteInfo['securityissue'];
        return false;
    }

    /**
     * Get the URL of the screenshot of the extension if there is any
     *
     * @return string|bool The screenshot URL if there is any, false otherwise
     */
    public function getScreenshotURL()
    {
        if (!empty($this->remoteInfo['screenshoturl'])) return $this->remoteInfo['screenshoturl'];
        return false;
    }

    /**
     * Get the URL of the thumbnail of the extension if there is any
     *
     * @return string|bool The thumbnail URL if there is any, false otherwise
     */
    public function getThumbnailURL()
    {
        if (!empty($this->remoteInfo['thumbnailurl'])) return $this->remoteInfo['thumbnailurl'];
        return false;
    }
    /**
     * Get the last used download URL of the extension if there is any
     *
     * @return string|bool The previously used download URL, false if the extension has been installed manually
     */
    public function getLastDownloadURL()
    {
        if (!empty($this->managerData['downloadurl'])) return $this->managerData['downloadurl'];
        return false;
    }

    /**
     * Get the download URL of the extension if there is any
     *
     * @return string|bool The download URL if there is any, false otherwise
     */
    public function getDownloadURL()
    {
        if (!empty($this->remoteInfo['downloadurl'])) return $this->remoteInfo['downloadurl'];
        return false;
    }

    /**
     * If the download URL has changed since the last download
     *
     * @return bool If the download URL has changed
     */
    public function hasDownloadURLChanged()
    {
        $lasturl = $this->getLastDownloadURL();
        $currenturl = $this->getDownloadURL();
        return ($lasturl && $currenturl && $lasturl != $currenturl);
    }

    /**
     * Get the bug tracker URL of the extension if there is any
     *
     * @return string|bool The bug tracker URL if there is any, false otherwise
     */
    public function getBugtrackerURL()
    {
        if (!empty($this->remoteInfo['bugtracker'])) return $this->remoteInfo['bugtracker'];
        return false;
    }

    /**
     * Get the URL of the source repository if there is any
     *
     * @return string|bool The URL of the source repository if there is any, false otherwise
     */
    public function getSourcerepoURL()
    {
        if (!empty($this->remoteInfo['sourcerepo'])) return $this->remoteInfo['sourcerepo'];
        return false;
    }

    /**
     * Get the donation URL of the extension if there is any
     *
     * @return string|bool The donation URL if there is any, false otherwise
     */
    public function getDonationURL()
    {
        if (!empty($this->remoteInfo['donationurl'])) return $this->remoteInfo['donationurl'];
        return false;
    }

    /**
     * Get the extension type(s)
     *
     * @return array The type(s) as array of strings
     */
    public function getTypes()
    {
        if (!empty($this->remoteInfo['types'])) return $this->remoteInfo['types'];
        if ($this->isTemplate()) return array(32 => 'template');
        return array();
    }

    /**
     * Get a list of all DokuWiki versions this extension is compatible with
     *
     * @return array The versions in the form yyyy-mm-dd => ('label' => label, 'implicit' => implicit)
     */
    public function getCompatibleVersions()
    {
        if (!empty($this->remoteInfo['compatible'])) return $this->remoteInfo['compatible'];
        return array();
    }

    /**
     * Get the date of the last available update
     *
     * @return string|bool The last available update in the form yyyy-mm-dd if there is any, false otherwise
     */
    public function getLastUpdate()
    {
        if (!empty($this->remoteInfo['lastupdate'])) return $this->remoteInfo['lastupdate'];
        return false;
    }

    /**
     * Get the base path of the extension
     *
     * @return string The base path of the extension
     */
    public function getInstallDir()
    {
        if ($this->isTemplate()) {
            return $this->tpllib.$this->base;
        } else {
            return DOKU_PLUGIN.$this->base;
        }
    }

    /**
     * The type of extension installation
     *
     * @return string One of "none", "manual", "git" or "automatic"
     */
    public function getInstallType()
    {
        if (!$this->isInstalled()) return 'none';
        if (!empty($this->managerData)) return 'automatic';
        if (is_dir($this->getInstallDir().'/.git')) return 'git';
        return 'manual';
    }

    /**
     * If the extension can probably be installed/updated or uninstalled
     *
     * @return bool|string True or error string
     */
    public function canModify()
    {
        if ($this->isInstalled()) {
            if (!is_writable($this->getInstallDir())) {
                return 'noperms';
            }
        }

        if ($this->isTemplate() && !is_writable($this->tpllib)) {
            return 'notplperms';
        } elseif (!is_writable(DOKU_PLUGIN)) {
            return 'nopluginperms';
        }
        return true;
    }

    /**
     * Install an extension from a user upload
     *
     * @param string $field name of the upload file
     * @param boolean $overwrite overwrite folder if the extension name is the same
     * @throws Exception when something goes wrong
     * @return array The list of installed extensions
     */
    public function installFromUpload($field, $overwrite = true)
    {
        if ($_FILES[$field]['error']) {
            throw new Exception($this->getLang('msg_upload_failed').' ('.$_FILES[$field]['error'].')');
        }

        $tmp = $this->mkTmpDir();
        if (!$tmp) throw new Exception($this->getLang('error_dircreate'));

        // filename may contain the plugin name for old style plugins...
        $basename = basename($_FILES[$field]['name']);
        $basename = preg_replace('/\.(tar\.gz|tar\.bz|tar\.bz2|tar|tgz|tbz|zip)$/', '', $basename);
        $basename = preg_replace('/[\W]+/', '', $basename);

        if (!move_uploaded_file($_FILES[$field]['tmp_name'], "$tmp/upload.archive")) {
            throw new Exception($this->getLang('msg_upload_failed'));
        }

        try {
            $installed = $this->installArchive("$tmp/upload.archive", $overwrite, $basename);
            $this->updateManagerData('', $installed);
            $this->removeDeletedfiles($installed);
            // purge cache
            $this->purgeCache();
        } catch (Exception $e) {
            throw $e;
        }
        return $installed;
    }

    /**
     * Install an extension from a remote URL
     *
     * @param string $url
     * @param boolean $overwrite overwrite folder if the extension name is the same
     * @throws Exception when something goes wrong
     * @return array The list of installed extensions
     */
    public function installFromURL($url, $overwrite = true)
    {
        try {
            $path      = $this->download($url);
            $installed = $this->installArchive($path, $overwrite);
            $this->updateManagerData($url, $installed);
            $this->removeDeletedfiles($installed);

            // purge cache
            $this->purgeCache();
        } catch (Exception $e) {
            throw $e;
        }
        return $installed;
    }

    /**
     * Install or update the extension
     *
     * @throws \Exception when something goes wrong
     * @return array The list of installed extensions
     */
    public function installOrUpdate()
    {
        $url       = $this->getDownloadURL();
        $path      = $this->download($url);
        $installed = $this->installArchive($path, $this->isInstalled(), $this->getBase());
        $this->updateManagerData($url, $installed);

        // refresh extension information
        if (!isset($installed[$this->getID()])) {
            throw new Exception('Error, the requested extension hasn\'t been installed or updated');
        }
        $this->removeDeletedfiles($installed);
        $this->setExtension($this->getID());
        $this->purgeCache();
        return $installed;
    }

    /**
     * Uninstall the extension
     *
     * @return bool If the plugin was sucessfully uninstalled
     */
    public function uninstall()
    {
        $this->purgeCache();
        return io_rmdir($this->getInstallDir(), true);
    }

    /**
     * Enable the extension
     *
     * @return bool|string True or an error message
     */
    public function enable()
    {
        if ($this->isTemplate()) return $this->getLang('notimplemented');
        if (!$this->isInstalled()) return $this->getLang('notinstalled');
        if ($this->isEnabled()) return $this->getLang('alreadyenabled');

        /* @var PluginController $plugin_controller */
        global $plugin_controller;
        if ($plugin_controller->enable($this->base)) {
            $this->purgeCache();
            return true;
        } else {
            return $this->getLang('pluginlistsaveerror');
        }
    }

    /**
     * Disable the extension
     *
     * @return bool|string True or an error message
     */
    public function disable()
    {
        if ($this->isTemplate()) return $this->getLang('notimplemented');

        /* @var PluginController $plugin_controller */
        global $plugin_controller;
        if (!$this->isInstalled()) return $this->getLang('notinstalled');
        if (!$this->isEnabled()) return $this->getLang('alreadydisabled');
        if ($plugin_controller->disable($this->base)) {
            $this->purgeCache();
            return true;
        } else {
            return $this->getLang('pluginlistsaveerror');
        }
    }

    /**
     * Purge the cache by touching the main configuration file
     */
    protected function purgeCache()
    {
        global $config_cascade;

        // expire dokuwiki caches
        // touching local.php expires wiki page, JS and CSS caches
        @touch(reset($config_cascade['main']['local']));
    }

    /**
     * Read local extension data either from info.txt or getInfo()
     */
    protected function readLocalData()
    {
        if ($this->isTemplate()) {
            $infopath = $this->getInstallDir().'/template.info.txt';
        } else {
            $infopath = $this->getInstallDir().'/plugin.info.txt';
        }

        if (is_readable($infopath)) {
            $this->localInfo = confToHash($infopath);
        } elseif (!$this->isTemplate() && $this->isEnabled()) {
            $path   = $this->getInstallDir().'/';
            $plugin = null;

            foreach (PluginController::PLUGIN_TYPES as $type) {
                if (file_exists($path.$type.'.php')) {
                    $plugin = plugin_load($type, $this->base);
                    if ($plugin) break;
                }

                if ($dh = @opendir($path.$type.'/')) {
                    while (false !== ($cp = readdir($dh))) {
                        if ($cp == '.' || $cp == '..' || strtolower(substr($cp, -4)) != '.php') continue;

                        $plugin = plugin_load($type, $this->base.'_'.substr($cp, 0, -4));
                        if ($plugin) break;
                    }
                    if ($plugin) break;
                    closedir($dh);
                }
            }

            if ($plugin) {
                /* @var DokuWiki_Plugin $plugin */
                $this->localInfo = $plugin->getInfo();
            }
        }
    }

    /**
     * Save the given URL and current datetime in the manager.dat file of all installed extensions
     *
     * @param string $url       Where the extension was downloaded from. (empty for manual installs via upload)
     * @param array  $installed Optional list of installed plugins
     */
    protected function updateManagerData($url = '', $installed = null)
    {
        $origID = $this->getID();

        if (is_null($installed)) {
            $installed = array($origID);
        }

        foreach ($installed as $ext => $info) {
            if ($this->getID() != $ext) $this->setExtension($ext);
            if ($url) {
                $this->managerData['downloadurl'] = $url;
            } elseif (isset($this->managerData['downloadurl'])) {
                unset($this->managerData['downloadurl']);
            }
            if (isset($this->managerData['installed'])) {
                $this->managerData['updated'] = date('r');
            } else {
                $this->managerData['installed'] = date('r');
            }
            $this->writeManagerData();
        }

        if ($this->getID() != $origID) $this->setExtension($origID);
    }

    /**
     * Read the manager.dat file
     */
    protected function readManagerData()
    {
        $managerpath = $this->getInstallDir().'/manager.dat';
        if (is_readable($managerpath)) {
            $file = @file($managerpath);
            if (!empty($file)) {
                foreach ($file as $line) {
                    list($key, $value) = explode('=', trim($line, DOKU_LF), 2);
                    $key = trim($key);
                    $value = trim($value);
                    // backwards compatible with old plugin manager
                    if ($key == 'url') $key = 'downloadurl';
                    $this->managerData[$key] = $value;
                }
            }
        }
    }

    /**
     * Write the manager.data file
     */
    protected function writeManagerData()
    {
        $managerpath = $this->getInstallDir().'/manager.dat';
        $data = '';
        foreach ($this->managerData as $k => $v) {
            $data .= $k.'='.$v.DOKU_LF;
        }
        io_saveFile($managerpath, $data);
    }

    /**
     * Returns a temporary directory
     *
     * The directory is registered for cleanup when the class is destroyed
     *
     * @return false|string
     */
    protected function mkTmpDir()
    {
        $dir = io_mktmpdir();
        if (!$dir) return false;
        $this->temporary[] = $dir;
        return $dir;
    }

    /**
     * downloads a file from the net and saves it
     *
     * - $file is the directory where the file should be saved
     * - if successful will return the name used for the saved file, false otherwise
     *
     * @author Andreas Gohr <andi@splitbrain.org>
     * @author Chris Smith <chris@jalakai.co.uk>
     *
     * @param string $url           url to download
     * @param string $file          path to file or directory where to save
     * @param string $defaultName   fallback for name of download
     * @return bool|string          if failed false, otherwise true or the name of the file in the given dir
     */
    protected function downloadToFile($url, $file, $defaultName = '')
    {
        global $conf;
        $http = new DokuHTTPClient();
        $http->max_bodysize = 0;
        $http->timeout = 25; //max. 25 sec
        $http->keep_alive = false; // we do single ops here, no need for keep-alive
        $http->agent = 'DokuWiki HTTP Client (Extension Manager)';

        $data = $http->get($url);
        if ($data === false) return false;

        $name = '';
        if (isset($http->resp_headers['content-disposition'])) {
            $content_disposition = $http->resp_headers['content-disposition'];
            $match = array();
            if (is_string($content_disposition) &&
                preg_match('/attachment;\s*filename\s*=\s*"([^"]*)"/i', $content_disposition, $match)
            ) {
                $name = \dokuwiki\Utf8\PhpString::basename($match[1]);
            }

        }

        if (!$name) {
            if (!$defaultName) return false;
            $name = $defaultName;
        }

        $file = $file.$name;

        $fileexists = file_exists($file);
        $fp = @fopen($file,"w");
        if (!$fp) return false;
        fwrite($fp, $data);
        fclose($fp);
        if (!$fileexists and $conf['fperm']) chmod($file, $conf['fperm']);
        return $name;
    }

    /**
     * Download an archive to a protected path
     *
     * @param string $url  The url to get the archive from
     * @throws Exception   when something goes wrong
     * @return string The path where the archive was saved
     */
    public function download($url)
    {
        // check the url
        if (!preg_match('/https?:\/\//i', $url)) {
            throw new Exception($this->getLang('error_badurl'));
        }

        // try to get the file from the path (used as plugin name fallback)
        $file = parse_url($url, PHP_URL_PATH);
        if (is_null($file)) {
            $file = md5($url);
        } else {
            $file = \dokuwiki\Utf8\PhpString::basename($file);
        }

        // create tmp directory for download
        if (!($tmp = $this->mkTmpDir())) {
            throw new Exception($this->getLang('error_dircreate'));
        }

        // download
        if (!$file = $this->downloadToFile($url, $tmp.'/', $file)) {
            io_rmdir($tmp, true);
            throw new Exception(sprintf($this->getLang('error_download'),
                '<bdi>'.hsc($url).'</bdi>')
            );
        }

        return $tmp.'/'.$file;
    }

    /**
     * @param string $file      The path to the archive that shall be installed
     * @param bool   $overwrite If an already installed plugin should be overwritten
     * @param string $base      The basename of the plugin if it's known
     * @throws Exception        when something went wrong
     * @return array            list of installed extensions
     */
    public function installArchive($file, $overwrite = false, $base = '')
    {
        $installed_extensions = array();

        // create tmp directory for decompression
        if (!($tmp = $this->mkTmpDir())) {
            throw new Exception($this->getLang('error_dircreate'));
        }

        // add default base folder if specified to handle case where zip doesn't contain this
        if ($base && !@mkdir($tmp.'/'.$base)) {
            throw new Exception($this->getLang('error_dircreate'));
        }

        // decompress
        $this->decompress($file, "$tmp/".$base);

        // search $tmp/$base for the folder(s) that has been created
        // move the folder(s) to lib/..
        $result = array('old'=>array(), 'new'=>array());
        $default = ($this->isTemplate() ? 'template' : 'plugin');
        if (!$this->findFolders($result, $tmp.'/'.$base, $default)) {
            throw new Exception($this->getLang('error_findfolder'));
        }

        // choose correct result array
        if (count($result['new'])) {
            $install = $result['new'];
        } else {
            $install = $result['old'];
        }

        if (!count($install)) {
            throw new Exception($this->getLang('error_findfolder'));
        }

        // now install all found items
        foreach ($install as $item) {
            // where to install?
            if ($item['type'] == 'template') {
                $target_base_dir = $this->tpllib;
            } else {
                $target_base_dir = DOKU_PLUGIN;
            }

            if (!empty($item['base'])) {
                // use base set in info.txt
            } elseif ($base && count($install) == 1) {
                $item['base'] = $base;
            } else {
                // default - use directory as found in zip
                // plugins from github/master without *.info.txt will install in wrong folder
                // but using $info->id will make 'code3' fail (which should install in lib/code/..)
                $item['base'] = basename($item['tmp']);
            }

            // check to make sure we aren't overwriting anything
            $target = $target_base_dir.$item['base'];
            if (!$overwrite && file_exists($target)) {
                // this info message is not being exposed via exception,
                // so that it's not interrupting the installation
                msg(sprintf($this->getLang('msg_nooverwrite'), $item['base']));
                continue;
            }

            $action = file_exists($target) ? 'update' : 'install';

            // copy action
            if ($this->dircopy($item['tmp'], $target)) {
                // return info
                $id = $item['base'];
                if ($item['type'] == 'template') {
                    $id = 'template:'.$id;
                }
                $installed_extensions[$id] = array(
                    'base' => $item['base'],
                    'type' => $item['type'],
                    'action' => $action
                );
            } else {
                throw new Exception(sprintf($this->getLang('error_copy').DOKU_LF,
                    '<bdi>'.$item['base'].'</bdi>')
                );
            }
        }

        // cleanup
        if ($tmp) io_rmdir($tmp, true);

        return $installed_extensions;
    }

    /**
     * Find out what was in the extracted directory
     *
     * Correct folders are searched recursively using the "*.info.txt" configs
     * as indicator for a root folder. When such a file is found, it's base
     * setting is used (when set). All folders found by this method are stored
     * in the 'new' key of the $result array.
     *
     * For backwards compatibility all found top level folders are stored as
     * in the 'old' key of the $result array.
     *
     * When no items are found in 'new' the copy mechanism should fall back
     * the 'old' list.
     *
     * @author Andreas Gohr <andi@splitbrain.org>
     * @param array $result - results are stored here
     * @param string $directory - the temp directory where the package was unpacked to
     * @param string $default_type - type used if no info.txt available
     * @param string $subdir - a subdirectory. do not set. used by recursion
     * @return bool - false on error
     */
    protected function findFolders(&$result, $directory, $default_type = 'plugin', $subdir = '')
    {
        $this_dir = "$directory$subdir";
        $dh       = @opendir($this_dir);
        if (!$dh) return false;

        $found_dirs           = array();
        $found_files          = 0;
        $found_template_parts = 0;
        while (false !== ($f = readdir($dh))) {
            if ($f == '.' || $f == '..') continue;

            if (is_dir("$this_dir/$f")) {
                $found_dirs[] = "$subdir/$f";
            } else {
                // it's a file -> check for config
                $found_files++;
                switch ($f) {
                    case 'plugin.info.txt':
                    case 'template.info.txt':
                        // we have  found a clear marker, save and return
                        $info = array();
                        $type = explode('.', $f, 2);
                        $info['type'] = $type[0];
                        $info['tmp']  = $this_dir;
                        $conf = confToHash("$this_dir/$f");
                        $info['base'] = basename($conf['base']);
                        $result['new'][] = $info;
                        return true;

                    case 'main.php':
                    case 'details.php':
                    case 'mediamanager.php':
                    case 'style.ini':
                        $found_template_parts++;
                        break;
                }
            }
        }
        closedir($dh);

        // files where found but no info.txt - use old method
        if ($found_files) {
            $info        = array();
            $info['tmp'] = $this_dir;
            // does this look like a template or should we use the default type?
            if ($found_template_parts >= 2) {
                $info['type'] = 'template';
            } else {
                $info['type'] = $default_type;
            }

            $result['old'][] = $info;
            return true;
        }

        // we have no files yet -> recurse
        foreach ($found_dirs as $found_dir) {
            $this->findFolders($result, $directory, $default_type, "$found_dir");
        }
        return true;
    }

    /**
     * Decompress a given file to the given target directory
     *
     * Determines the compression type from the file extension
     *
     * @param string $file   archive to extract
     * @param string $target directory to extract to
     * @throws Exception
     * @return bool
     */
    private function decompress($file, $target)
    {
        // decompression library doesn't like target folders ending in "/"
        if (substr($target, -1) == "/") $target = substr($target, 0, -1);

        $ext = $this->guessArchiveType($file);
        if (in_array($ext, array('tar', 'bz', 'gz'))) {
            try {
                $tar = new \splitbrain\PHPArchive\Tar();
                $tar->open($file);
                $tar->extract($target);
            } catch (\splitbrain\PHPArchive\ArchiveIOException $e) {
                throw new Exception($this->getLang('error_decompress').' '.$e->getMessage());
            }

            return true;
        } elseif ($ext == 'zip') {
            try {
                $zip = new \splitbrain\PHPArchive\Zip();
                $zip->open($file);
                $zip->extract($target);
            } catch (\splitbrain\PHPArchive\ArchiveIOException $e) {
                throw new Exception($this->getLang('error_decompress').' '.$e->getMessage());
            }

            return true;
        }

        // the only case when we don't get one of the recognized archive types is
        // when the archive file can't be read
        throw new Exception($this->getLang('error_decompress').' Couldn\'t read archive file');
    }

    /**
     * Determine the archive type of the given file
     *
     * Reads the first magic bytes of the given file for content type guessing,
     * if neither bz, gz or zip are recognized, tar is assumed.
     *
     * @author Andreas Gohr <andi@splitbrain.org>
     * @param string $file The file to analyze
     * @return string|false false if the file can't be read, otherwise an "extension"
     */
    private function guessArchiveType($file)
    {
        $fh = fopen($file, 'rb');
        if (!$fh) return false;
        $magic = fread($fh, 5);
        fclose($fh);

        if (strpos($magic, "\x42\x5a") === 0) return 'bz';
        if (strpos($magic, "\x1f\x8b") === 0) return 'gz';
        if (strpos($magic, "\x50\x4b\x03\x04") === 0) return 'zip';
        return 'tar';
    }

    /**
     * Copy with recursive sub-directory support
     *
     * @param string $src filename path to file
     * @param string $dst filename path to file
     * @return bool|int|string
     */
    private function dircopy($src, $dst)
    {
        global $conf;

        if (is_dir($src)) {
            if (!$dh = @opendir($src)) return false;

            if ($ok = io_mkdir_p($dst)) {
                while ($ok && (false !== ($f = readdir($dh)))) {
                    if ($f == '..' || $f == '.') continue;
                    $ok = $this->dircopy("$src/$f", "$dst/$f");
                }
            }

            closedir($dh);
            return $ok;
        } else {
            $existed = file_exists($dst);

            if (!@copy($src, $dst)) return false;
            if (!$existed && $conf['fperm']) chmod($dst, $conf['fperm']);
            @touch($dst, filemtime($src));
        }

        return true;
    }

    /**
     * Delete outdated files from updated plugins
     *
     * @param array $installed
     */
    private function removeDeletedfiles($installed)
    {
        foreach ($installed as $id => $extension) {
            // only on update
            if ($extension['action'] == 'install') continue;

            // get definition file
            if ($extension['type'] == 'template') {
                $extensiondir = $this->tpllib;
            } else {
                $extensiondir = DOKU_PLUGIN;
            }
            $extensiondir = $extensiondir . $extension['base'] .'/';
            $definitionfile = $extensiondir . 'deleted.files';
            if (!file_exists($definitionfile)) continue;

            // delete the old files
            $list = file($definitionfile);

            foreach ($list as $line) {
                $line = trim(preg_replace('/#.*$/', '', $line));
                if (!$line) continue;
                $file = $extensiondir . $line;
                if (!file_exists($file)) continue;

                io_rmdir($file, true);
            }
        }
    }
}

// vim:ts=4:sw=4:et: