<?php
/**
 * @brief translater, a plugin for Dotclear 2
 * 
 * @package Dotclear
 * @subpackage Plugin
 * 
 * @author Jean-Christian Denis & contributors
 * 
 * @copyright Jean-Christian Denis
 * @copyright GPL-2.0 https://www.gnu.org/licenses/gpl-2.0.html
 */

if (!defined('DC_CONTEXT_ADMIN')) {
    return;
}

/**
 * Translater tools.
 */
class dcTranslater
{
    public $core;
    public $proposal;

    /** @var array $iso List of l10n code/name allowed from clearbricks l10n class */
    protected static $iso = [];

    /** @var array $allowed_backup_folders List of allowed backup folder */
    public static $allowed_backup_folders = [
        'public',
        'module',
        'plugin',
        'cache',
        'translater'
    ];

    /** @var array $allowed_l10n_groups List of place of tranlsations */
    public static $allowed_l10n_groups = [
        'main',
        'public',
        'theme',
        'admin',
        'date',
        'error'
    ];

    /** @var array $allowed_user_informations List of user info can be parsed */
    public static $allowed_user_informations = [
        'firstname',
        'displayname',
        'name',
        'email',
        'url'
    ];

    /** @var array $default_settings Plugins default settings */
    private $default_settings = [
        'plugin_menu' => [
            'id' => 'translater_plugin_menu',
            'value' => 0,
            'type' => 'boolean',
            'label' => 'Put an link in plugins page'
        ],
        'theme_menu' => [
            'id' => 'translater_theme_menu',
            'value' => 0,
            'type' => 'boolean',
            'label' => 'Put a link in themes page'
        ],
        'backup_auto' => [
            'id' => 'translater_backup_auto',
            'value' => 1,
            'type' => 'boolean',
            'label' => 'Make a backup of languages old files when there are modified'
        ],
        'backup_limit' => [
            'id' => 'translater_backup_limit',
            'value' => 20,
            'type' => 'string',
            'label' => 'Maximum backups per module'
        ],
        'backup_folder' => [
            'id' => 'translater_backup_folder',
            'value' => 'module',
            'type' => 'string',
            'label' => 'In which folder to store backups'
        ],
        'start_page' => [
            'id' => 'translater_start_page',
            'value' => 'setting',
            'type' => 'string',
            'label' => 'Page to start on'
        ],
        'write_po' => [
            'id' => 'translater_write_po',
            'value' => 1,
            'type' => 'boolean',
            'label' => 'Write .po languages files'
        ],
        'write_langphp' => [
            'id' => 'translater_write_langphp',
            'value' => 1,
            'type' => 'boolean',
            'label' => 'Write .lang.php languages files'
        ],
        'scan_tpl' => [
            'id' => 'translater_scan_tpl',
            'value' => 0,
            'type' => 'boolean',
            'label' => 'Translate strings of templates files'
        ],
        'parse_nodc' => [
            'id' => 'translater_parse_nodc',
            'value' => 1,
            'type' => 'boolean',
            'label' => 'Translate only untranslated strings of Dotclear',
        ],
        'hide_default' => [
            'id' => 'translater_hide_default',
            'value' => 1,
            'type' => 'boolean',
            'label' => 'Hide default modules of Dotclear',
        ],
        'parse_comment' => [
            'id' => 'translater_parse_comment',
            'value' => 1,
            'type' => 'boolean',
            'label' => 'Write comments and strings informations in lang files'
        ],
        'parse_user' => [
            'id' => 'translater_parse_user',
            'value' => 1,
            'type' => 'boolean',
            'label' => 'Write inforamtions about author in lang files'
        ],
        'parse_userinfo' => [
            'id' => 'translater_parse_userinfo',
            'value' => 'displayname, email',
            'type' => 'string',
            'label' => 'Type of informations about user to write'
        ],
        'import_overwrite' => [
            'id' => 'translater_import_overwrite',
            'value' => 0,
            'type' => 'boolean',
            'label' => 'Overwrite existing languages when import packages'
        ],
        'export_filename' => [
            'id' => 'translater_export_filename',
            'value' => 'type-module-l10n-timestamp',
            'type' => 'string',
            'label' => 'Name of files of exported package'
        ],
        'proposal_tool' => [
            'id' => 'translater_proposal_tool',
            'value' => 'google',
            'type' => 'string',
            'label' => 'Id of default tool for proposed translation'
        ],
        'proposal_lang' => [
            'id' => 'translater_proposal_lang',
            'value' => 'en',
            'type' => 'string',
            'label' => 'Default source language for proposed translation'
        ]
    ];

    /** @var array $default_dotclear_modules List of distributed plugins and themes */
    public static $default_dotclear_modules = ['plugin' => [], 'theme' => []];

    /** @var array $modules List of modules we could work on */
    private $modules = [];

    /** @var array $module Module to work on */
    private $module = [];

    /**
     * Main translater object
     * 
     * @param dcCore $core dcCore instance
     */
    public function __construct(dcCore $core)
    {
        self::$default_dotclear_modules = [
            'plugin' => explode(',', DC_DISTRIB_PLUGINS), 
            'theme' => explode(',', DC_DISTRIB_THEMES)
        ];
        $this->core = $core;
        $core->blog->settings->addNamespace('translater');
        $this->loadModules();
        $this->proposal = new translaterProposals($core);
    }

    /// @name settings methods
    //@{
    /**
     * Get array of default settings
     * 
     * @return array All default settings
     */
    public function getDefaultSettings(): array
    {
        return $this->default_settings;
    }

    /**
     * Get a setting according to default settings list
     * 
     * @param  string $id The settings short id
     * @return mixed     The setting value if exists or null
     */
    public function getSetting(string $id)
    {
        if (!isset($this->default_settings[$id])) {
            return null;
        }
        return $this->core->blog->settings->translater->get(
            $this->default_settings[$id]['id']
        );
    }

    /**
     * Magic getSetting
     */
    public function __get($id)
    {
        return $this->getSetting($id);
    }

    /**
     * Set a setting according to default settings list
     * 
     * @param string $k The setting short id
     * @param mixed $v The setting value
     */
    public function setSetting(string $k, $v)
    {
        if (!isset($this->default_settings[$k])) {
            return false;
        }

        $this->core->blog->settings->translater->drop($id);
        $this->core->blog->settings->translater->put(
            $this->default_settings[$k]['id'],
            $v,
            $this->default_settings[$k]['type'],
            $this->default_settings[$k]['label'],
            true,
            true
        );
        return true;
    }

    /**
     * Magis setSetting
     */
    public function __set($k, $v)
    {
        return $this->setSetting($k, $v);
    }
    //@}

    /// @name modules methods
    //@{
    /**
     * Retrieve a particular info for a given module
     * 
     * @param  string $id   The module id
     * @param  string $info The module info
     * @return mixed       The module info value or null
     */
    public function moduleInfo(string $id, string $info)
    {
        if (isset($this->modules['plugin'][$id])) {
            $type = 'plugin';
        } elseif (isset($this->modules['theme'][$id])) {
            $type = 'theme';
        } else {
            return null;
        }

        if ($info == 'type') {
            return $type;
        }

        return isset($this->modules[$type][$id][$info]) ? $this->modules[$type][$id][$info] : null;
    }

    /** 
     * Load array of modules infos by type of modules
     */
    private function loadModules()
    {
        $themes = new dcThemes($this->core);
        $themes->loadModules($this->core->blog->themes_path, null);
        $this->modules['theme'] = $this->modules['plugin'] = [];

        $m = $themes->getModules();
        foreach($m AS $k => $v) {
            if (!$v['root_writable']) {
                continue;
            }
            $this->modules['theme'][$k] = $v;
            $this->modules['theme'][$k]['id'] = $k;
            $this->modules['theme'][$k]['type'] = 'theme';
        }

        $m = $this->core->plugins->getModules();
        foreach($m AS $k => $v) {
            if (!$v['root_writable']) {
                continue;
            }
            $this->modules['plugin'][$k] = $v;
            $this->modules['plugin'][$k]['id'] = $k;
            $this->modules['plugin'][$k]['type'] = 'plugin';
        }
    }

    /** 
     * Return array of modules infos by type of modules
     * 
     * @param  string $type The module type
     * @return array       The list of modules infos
     */
    public function listModules(string $type = '')
    {
        return in_array($type, ['plugin', 'theme']) ? 
            $this->modules[$type] : 
            array_merge($this->modules['theme'], $this->modules['plugin']);
    }

    /** 
     * Return array object of a particular module for a given type of module
     * 
     * @param  string $id     The module id
     * @param  string $type   The module type
     * @return ArrayObject    The module info
     */
    public function getModule(string $id = '', string $type = '')
    {
        $o = new ArrayObject();

        # Load nothing?
        if (empty($id)) {
            return false;
        }

        # Unknow type?
        $modules = !in_array($type, ['plugin', 'theme']) ?
            array_merge($this->modules['theme'], $this->modules['plugin']) :
            $this->modules[$type];

        # Unknow module?
        if (!isset($modules[$id])) {
            throw new Exception(
                sprintf(__('Cannot find module %s'), $id)
            );
            return false;
        }

        # Module info
        foreach($modules[$id] as $a => $b) {
            $o->{$a} = $b;
        }
        $o->root = path::real($o->root);
        # Locales path
        $o->locales = $o->root . '/locales';
        # Module exists
        $o->exists = true;
        # Module Basename
        $i = path::info($o->root);
        $o->basename = $i['basename'];

        return $o;
    }
    //@}

    /**
     * Find backup folder of a module
     * 
     * @param  string  $id    The module id
     * @param  boolean $throw Silently failed
     * @return mixed          The backup folder directory or false
     */
    public function getBackupFolder(string $id, bool $throw = false)
    {
        $dir = false;
        switch($this->backup_folder) {
            case 'module':
                # plugin
                if (isset($this->modules['plugin'][$id]) 
                    && $this->modules['plugin'][$id]['root_writable']
                ) {
                    $dir = path::real($this->modules['plugin'][$id]['root']) . '/locales';
                #theme
                } elseif (isset($this->modules['theme'][$id]) 
                    && $this->modules['theme'][$id]['root_writable']
                ) {
                    $dir = path::real($this->modules['theme'][$id]['root']) . '/locales';
                }
            break;

            case 'plugin':
                $tmp = path::real(array_pop(explode(PATH_SEPARATOR, DC_PLUGINS_ROOT)));
                if ($tmp && is_writable($tmp)) {
                    $dir = $tmp;
                }
            break;

            case 'public':
                $tmp = path::real($this->core->blog->public_path);
                if ($tmp && is_writable($tmp)) {
                    $dir = $tmp;
                }
            break;

            case 'cache':
                $tmp = path::real(DC_TPL_CACHE);
                if ($tmp && is_writable($tmp)) {
                    @mkDir($tmp . '/l10n');
                    $dir = $tmp . '/l10n';
                }
            break;

            case 'translater':
            $tmp = path::real($this->modules['plugin']['translater']['root']);
            if ($tmp && is_writable($tmp)) {
                @mkDir($tmp . '/locales');
                $dir = $tmp . '/locales';
            }
            break;
        }
        if (!$dir && $throw) {
            throw new Exception(sprintf(
                __('Cannot find backups folder for module %s'), $id
            ));
        }

        return $dir;
    }

    /**
     * Find language path of a module
     * 
     * @param  string  $id     The module id
     * @param  boolean $throw  Silently failed
     * @return mixed          The module language path or false
     */
    public function getLangsFolder(string $id = '', bool $throw = false)
    {
        $dir = $id == 'dotclear' ?
            DC_ROOT :
            self::getModuleFolder($id, false);

        if (!$dir && $throw)  {
            throw new Exception(
                sprintf(__('Cannot find languages folder for module %s'), $id)
            );
        }

        return !$dir ? false : $dir . '/locales';
    }

    /**
     * Find root path of a module
     * 
     * @param  string  $module The module id
     * @param  boolean $throw  Silently failed
     * @return mixed           The module root path or false
     */
    public function getModuleFolder($id = '', $throw = false)
    {
        $dir = false;
        if ((isset($this->modules['plugin'][$id]['root'])
                && ($tmp = path::real($this->modules['plugin'][$id]['root']))) 
            || (isset($this->modules['theme'][$id]['root'])
                && ($tmp = path::real($this->modules['theme'][$id]['root']))
        )) {
            $dir = $tmp;
        }
        if (!$dir && $throw) {
            throw new Exception(
                sprintf(__('Cannot find root folder for module %s'), $id)
            );
        }

        return $dir;
    }

    /**
     * Check limit number of backup for a module
     * 
     * @param  string  $id     The module id
     * @param  boolean $throw  Silently failed
     * @return boolean         True if limit is riched
     */
    public function isBackupLimit(string $id, bool $throw = false): bool
    {
        # Find folder of backups
        $backup = self::getBackupFolder($id, true);

        # Count backup files
        $count = 0;
        foreach(self::scandir($backup) AS $file) {
            if (!is_dir($backup . '/' . $file)
                && preg_match('/^(l10n-'. $id . '(.*?).bck.zip)$/', $backup)
            ) {
                $count++;
            }
        }

        # Limite exceed
        if ($count >= $this->backup_limit) {
            if ($throw) {
                throw new Exception(
                    sprintf(__('Limit of %s backups for module %s exceed'), $this->backup_limit, $id)
                );
            }
            return true;
        }
        return false;
    }

    /**
     * Get a list of available backups
     * 
     * @param  string       $id              The module id
     * @param  bool|boolean $return_filename Return only filenames
     * @return array                         The module backups info
     */
    public function listBackups(string $id, bool $return_filename = false): array
    {
        # Not a module installed
        self::getLangsFolder($id, true);

        # No backup folder for this module
        $backup = self::getBackupFolder($id, false);
        if (!$backup) {
            return [];
        }

        # Scan files for backups
        $res = $sort = [];
        $files = self::scandir($backup);
        foreach($files AS $file) {
            # Not a bakcup file
            $is_backup = preg_match(
                '/^(l10n-(' . $id . ')-(.*?)-([0-9]*?).bck.zip)$/', $file, $m
            );

            if (is_dir($backup . '/' . $file) 
                || !$is_backup 
                || !self::isIsoCode($m[3])
            ) {
                continue;
            }

            # Backup infos
            if ($return_filename) {
                $res[] = $file;
            } else {
                $res[$m[3]][$file] = path::info($backup . '/' . $file);
                $res[$m[3]][$file]['time']= filemtime($backup . '/' . $file);
                $res[$m[3]][$file]['size'] = filesize($backup . '/' . $file);
                $res[$m[3]][$file]['module'] = $id;
            }
        }
        return $res;
    }

    /**
     * Create a backup
     * 
     * @param  string $id   The module id
     * @param  string $lang The backup lang
     * @return boolean       True on success
     */
    public function createBackup(string $id, string $lang): bool
    {
        # Not a module installed
        $locales = self::getLangsFolder($id, true);

        # No backup folder for this module
        $backup = self::getBackupFolder($id, true);

        # Not an existing lang
        if (!is_dir($locales . '/' . $lang)) {
            throw new Exception(sprintf(
                __('Cannot find language folder %s for module %s') ,$lang, $id
            ));
        }

        # Scan files for a lang
        $res = [];
        $files = self::scandir($locales . '/' . $lang);
        foreach($files as $file) {
            # Only lang file
            if (!is_dir($locales . '/' . $lang . '/' . $file) 
            && (self::isLangphpFile($file) 
             || self::isPoFile($file))) {
                $res[$locales . '/' . $lang . '/' . $file] = 
                    $id . '/locales/' . $lang . '/' . $file;
            }
        }

        # Do Zip 
        if (!empty($res)) {
            self::isBackupLimit($id, true);

            @set_time_limit(300);
            $fp = fopen($backup . '/l10n-' . $id . '-' . $lang . '-' . time() . '.bck.zip', 'wb');
            $zip = new fileZip($fp);
            foreach($res AS $src => $dest) {
                $zip->addFile($src, $dest);
            }
            $zip->write();
            $zip->close();
            unset($zip);

            return true;
        }
    }

    /**
     * Delete a module backup
     * 
     * @param  string $id     The module id
     * @param  string $file   The backup filename
     * @return boolean        True on success
     */
    public function deleteBackup(string $id, string $file): bool
    {
        # Not a module installed
        self::getLangsFolder($id, true);

        # No backup folder for this module
        $backup = self::getBackupFolder($id, true);

        # Not a bakcup file
        $is_backup = preg_match('/^(l10n-(' . $id . ')-(.*?)-([0-9]*?).bck.zip)$/', $file, $m);

        if (is_dir($backup . '/' . $file) 
            || !$is_backup 
            || !self::isIsoCode($m[3])
        ) {
            return false;
        }

        if (!files::isDeletable($backup . '/' . $file)) {
            throw new Exception(sprintf(
                __('Cannot delete backup file %s'), $file
            ));
        }

        unlink($backup . '/' . $file);

        return true;
    }

    /**
     * Retore a backup
     * 
     * @param  string $module The module id
     * @param  string $file   The backup filename
     * @return boolean        True on success
     */
    public function restoreBackup(string $id, string $file): bool
    {
        # Not a module installed
        $locales = self::getModuleFolder($id, true);

        # No backup folder for this module
        $backup = self::getBackupFolder($id, true);

        if (!file_exists($backup . '/' . $file)) {
            throw new Exception(sprintf(
                __('Cannot find backup file %s'), $file
            ));
        }

        $zip = new fileUnzip($backup . '/' . $file);
        $zip_files = $zip->getFilesList();

        foreach($zip_files AS $zip_file) {
            $f = self::explodeZipFilename($zip_file, true);
            if ($id != $f['module']) {
                continue;
            }

            $zip->unzip($zip_file, $locales . '/locales/' . $f['lang'] . '/' . $f['group'] . $f['ext']);
            $done = true;
        }
        $zip->close();
        unset($zip);

        return true;
    }

    /**
     * Export (to output) language pack
     * 
     * @param  array $modules  The modules to work on
     * @param  array $langs     Langs to export
     */
    public function exportPack(array $modules, array $langs)
    {
        # Not a query well formed
        if (!is_array($modules) || 1 > count($modules)
            || !is_array($langs) || 1 > count($langs)
        ) {
            throw new Exception(
                __('Wrong export query')
            );
        }

        # Filter default filename
        $filename = files::tidyFileName($this->export_filename);

        # Not a filename good formed
        if (empty($filename)) {
            throw new Exception(
                sprintf(__('Cannot use export mask %s'), $this->export_filename)
            );
        }

        # Modules folders
        $res = $count = [];
        foreach($modules AS $module) {
            # Not a module installed
            $locales = self::getLangsFolder($module, false);
            if (!$locales) {
                continue;
            }

            # Langs folders
            foreach($langs AS $lang) {
                # Not a lang folder
                if (!is_dir($locales . '/' . $lang)) {
                    continue;
                }

                # Scan files for a lang
                $files = self::scandir($locales . '/' . $lang);
                foreach($files as $file) {
                    # Not a lang file
                    if (is_dir($locales . '/' . $lang . '/' . $file) 
                        || !self::isLangphpFile($file) 
                        && !self::isPoFile($file)
                    ) {
                        continue;
                    }

                    # Add file to zip in format "module/locales/lang/filename"
                    $res[$locales . '/' . $lang . '/' . $file] = 
                        $module . '/locales/' . $lang . '/' . $file;

                    $count[$module] = 1;
                }
            }
        }

        # Nothing to do
        if (empty($res)) {
            throw new Exception('Nothing to export');
        }

        # Prepare files to zip
        @set_time_limit(300);
        $fp = fopen('php://output', 'wb');
        $zip = new fileZip($fp);
        foreach($res as $from => $to) {
            $zip->addFile($from,$to);
        }

        # Set filename
        $file_infos = 1 < count($count) ? 
            [time(), 'modules', 'multi', self::$dcTranslaterVersion] : 
            [
                time(),
                $modules[0],
                self::moduleInfo($modules[0], 'type'),
                self::moduleInfo($modules[0], 'version')
            ];
        $filename = 
            files::tidyFileName(
                dt::str(
                    str_replace(
                        ['timestamp', 'module', 'type', 'version'],
                        $file_infos,
                        $this->export_filename
                    )
                )
            );

        # Send Zip
        header('Content-Disposition: attachment;filename=' . $filename . '.zip');
        header('Content-Type: application/x-zip');
        $zip->write();
        unset($zip);
        exit;
    }

    /**
     * Import a language pack
     * 
     * @param  array $modules  The modules to work on
     * @param  array $zip_file The uploaded file info
     * @return boolean         True on success
     */
    public function importPack($modules, $zip_file)
    {
        # Not a file uploaded
        files::uploadStatus($zip_file);

        # No modules to update
        if (!is_array($modules) || 1 > count($modules)) {
            throw new Exception(__('Wrong import query'));
        }

        $done = false;
        $res = [];

        # Load Unzip object
        $zip = new fileUnzip($zip_file['tmp_name']);
        $files = $zip->getFilesList();

        # Scan zip
        foreach($files AS $file) {
            $f = self::explodeZipFilename($file, false);

            # Not a requested module
            if (!is_array($f) 
                || !in_array($f['module'],$modules)
            ) {
                continue;
            }

            # Get locales folder (even if "locales" is not set)
            if (!$dir = self::getModuleFolder($f['module'], false)) {
                continue;
            }
            $locales = $dir . '/locales';

            # Not allow overwrite
            if (!$this->import_overwrite 
                && file_exists($locales . '/' . $f['lang'] . '/' . $f['group'] . $f['ext'])
            ) {
                continue;
            }

            $res[] = [
                'from' => $file, 
                'root' => $locales . '/' . $f['lang'], 
                'to'   => $locales . '/' . $f['lang'] . '/' . $f['group'] . $f['ext']
            ];
        }
        # Unzip files
        foreach ($res AS $rs) {
            if (!is_dir($rs['root'])) {
                files::makeDir($rs['root'], true);
            }

            $zip->unzip($rs['from'], $rs['to']);
            $done = true;
        }
        $zip->close();
        unlink($zip_file['tmp_name']);

        # No file unzip
        if (!$done) {
            throw new Exception(
                sprintf(__('Nothing to import for these modules in pack %s'), $zip_file['name'])
            );
        }
        return true;
    }

    /**
     * Parse zip filename to module, lang info
     * 
     * @param  string  $file  The zip filename
     * @param  boolean $throw Silently failed
     * @return mixed          Array of file info or false
     */
    public function explodeZipFilename(string $file = '', bool $throw = false)
    {
        # module/locales/lang/group.ext
        $is_file = preg_match(
            '/^(.*?)\/locales\/(.*?)\/(.*?)(.po|.lang.php)$/', $file, $f
        );

        # Explode file to infos
        if ($is_file) {
            $module = null !== self::moduleInfo($f[1], 'name') ? 
                $f[1] : false;
            $lang = self::isIsoCode($f[2]) ? 
                $f[2] : false;
            $group = in_array($f[3], self::$allowed_l10n_groups) ? 
                $f[3] : false;
            $ext = self::isLangphpFile($f[4]) || self::isPoFile($f[4]) ? 
                $f[4] : false;
        }
        # Not good formed
        if (!$is_file || !$module || !$lang || !$group || !$ext) {
            if ($throw) {
                throw new Exception(
                    sprintf(__('Zip file %s is not in translater format'), $file)
                );
            }
            return false;
        }
        return [
            'module' => $module,
            'lang'   => $lang,
            'group'  => $group,
            'ext'    => $ext
        ];
    }

    /**
     * List available langs of a module
     * 
     * @param  string  $id          The module id
     * @param  boolean $return_path Return path or name
     * @return array                The lang list
     */
    public function listLangs(string $id, bool $return_path = false)
    {
        $res = [];

        # Not a module installed
        $locales = self::getLangsFolder($id, true);

        # Add prefix "locales" as scandir remove it
        $prefix = preg_match('/(locales(.*))$/', $locales) ? 'locales' : '';

        # Retrieve langs folders
        $files = self::scandir($locales);
        foreach($files as $file) {
            if (!preg_match(
                '/(.*?(locales\/)([^\/]*?)\/([^\/]*?)(.lang.php|.po))$/',
                $prefix . $file, $m
            )) {
                continue;
            }

            if (!self::isIsoCode($m[3])) {
                continue;
            }

            if ($return_path) {
                $res[$m[3]][] = $file; # Path
            } else {
                $res[$m[3]] = self::$iso[$m[3]]; # Lang name
            }
        }
        return $res;
    }

    /**
     * Add a lang to a module
     * 
     * @param string $module    The module id
     * @param string $lang      The lang id
     * @param string $from_lang The lang to copy from
     */
    public function addLang(string $id, string $lang, string $from_lang = '')
    {
        # Not a module installed
        $locales = self::getLangsFolder($id, true);

        # Path is right formed
        self::isIsoCode($lang, true);

        # Retrieve langs folders
        $langs = self::listLangs($id);

        # Lang folder is not present
        if (isset($langs[$lang])) {
            throw new Exception(
                sprintf(__('Language %s already exists for module %s'), $lang, $id)
            );
        }

        # Create new lang directory
        files::makeDir($locales . '/' . $lang, true);

        # Verify folder of other lang
        if (!empty($from_lang) && !isset($langs[$from_lang])) {
            throw new Exception(
                sprintf(__('Cannot copy file from language %s for module %s'), $from_lang, $id)
            );
        }

        # Copy files from other lang
        if (!empty($from_lang) 
            && isset($langs[$from_lang])
        ) {
            $files = self::scandir($locales . '/' . $from_lang);
            foreach($files as $file) {
                if (is_dir($locales . '/' . $from_lang . '/' . $file) 
                    || !self::isLangphpFile($file) 
                    && !self::isPoFile($file)
                ) {
                    continue;
                }

                files::putContent($locales . '/' . $lang . '/' . $file,
                    file_get_contents($locales . '/' . $from_lang . '/' . $file)
                );
            }
        } else {
            # Create basic empty lang file as translater need these files to be present
            self::setLangphpFile($id, $lang, 'main', []);
            self::setPoFile($id, $lang, 'main', []);
        }
    }

    /**
     * Update an existing lang
     * 
     * @param  string $module The module id
     * @param  string $lang   The lang
     * @param  array $msgs    The messages
     */
    public function updLang(string $id, string $lang, array $msgs)
    {
        # Not a module installed
        $locales = self::getLangsFolder($id, true);

        # Path is right formed
        self::isIsoCode($lang, true);

        # Retrieve langs folders
        $langs = self::listLangs($id);

        # Lang folder is not present
        if (!isset($langs[$lang])) {
            throw new Exception(sprintf(
                __('Cannot find language folder %s for module %s'), $lang, $id
            ));
        }

        # Sort msgids by groups
        $rs = [];
        foreach($msgs as $msg) {
            $msg['group'] = isset($msg['group']) ? $msg['group'] : '';
            $msg['msgid'] = isset($msg['msgid']) ? $msg['msgid'] : '';
            $msg['msgstr'] = isset($msg['msgstr']) ? trim($msg['msgstr']) : '';
/*
            if (get_magic_quotes_gpc()) {
                $msg['msgid'] = stripcslashes($msg['msgid']);
                $msg['msgstr'] = stripcslashes($msg['msgstr']);
            }
*/          if ($msg['msgstr'] == '') {
                continue;
            }

            $rs[$msg['group']][$msg['msgid']] = $msg['msgstr'];
        }

        # Backup files if auto-backup is on
        if ($this->backup_auto) {
            self::createBackup($id, $lang);
        }

        # Delete empty files (files with no group)
        foreach(self::$allowed_l10n_groups AS $group) {
            if (isset($rs[$group])) {
                continue;
            }

            $po_file = $locales . '/' . $lang . '/' . $group . '.po';
            $langphp_file = $locales . '/' . $lang . '/' . $group . '.lang.php';

            if (file_exists($po_file)) {
                unlink($po_file);
            }
            if (file_exists($langphp_file)) {
                unlink($langphp_file);
            }
        }

        # No msgstr to write
        if (empty($rs)) {
            throw new Exception(sprintf(
                __('No string to write, language %s deleted for module %s'),
                $lang, $id
            ));
        }

        # Write .po and .lang.php files
        foreach($rs AS $group => $msgs) {
            self::setLangphpFile($id, $lang, $group, $msgs);
            self::setPoFile($id, $lang, $group, $msgs);
        }
    }

    public function delLang($module, $lang, $del_empty_dir = true)
    {
        # Not a module installed
        $locales = self::getLangsFolder($module, true);

        # Path is right formed
        self::isIsoCode($lang, true);

        # Retrieve langs folders
        $files = self::listLangs($module, true);

        # Lang folder is not present
        if (!isset($files[$lang])) {
            throw new Exception(sprintf(
                __('Cannot find language folder %s for module %s'), $lang, $module
            ));
        }

        # Delete .po and .lang.php files
        foreach($files[$lang] as $file) {
            unlink($locales . '/' . $file);
        }

        # Delete lang folder if empty
        $dir = self::scandir($locales . '/' . $lang);
        if (empty($dir)) {
            rmdir($locales . '/' . $lang);
        }

        # Delete locales folder if empty
        $loc = self::scandir($locales);
        if (empty($loc)) {
            rmdir($locales);
        }
    }

    public static function encodeMsg($str)
    {
        return text::toUTF8(stripslashes(trim($str)));
    }

    /* Scan a module folder to find all l10n strings in .php files */
    public function getMsgIds($module)
    {
        $res = array();

        # Not a module installed
        $dir = self::getModuleFolder($module, true);

        $files = self::scandir($dir);

        $scan_ext = array('php');
        if ($this->scan_tpl) {
            $scan_ext[] = 'html';
        }

        foreach($files AS $file) {
            if (is_dir($dir . '/' . $file) 
             || !in_array(files::getExtension($file),$scan_ext)) {
                continue;
            }

            $contents = file($dir . '/' . $file);
            foreach($contents AS $line => $content) {
                # php files
                //if (preg_match_all("|__\((['\"]{1})(.*)([\"']{1})\)|U", $content, $matches))
                if (preg_match_all("|__\((['\"]{1})(.*?)([\"']{1})\)|", $content, $matches)) {
                    foreach($matches[2] as $id) {
                        $res[] = array(
                            'msgid' => self::encodeMsg($id),
                            'file' => $file,
                            'line' => $line + 1
                        );
                    }
                }
                # tpl files
                if ($this->scan_tpl 
                 && preg_match_all('/\{\{tpl:lang\s([^}]+)\}\}/', $content, $matches)) {
                    foreach($matches[1] as $id) {
                        $res[] = array(
                            'msgid' => self::encodeMsg($id),
                            'file' => $file,
                            'line' => $line + 1
                        );
                    }
                }
            }
            unset($contents);
        }
        return $res;
    }

    /* Scan a lang folder to find l10n translations in files */
    public function getMsgStrs($module, $requested_lang = '')
    {
        $res = array();

        # Not a module installed
        $locales = self::getLangsFolder($module, true);

        $langs = self::listLangs($module, true);

        # Not an existing lang
        if (!isset($langs[$requested_lang])) {
            return $res;
        }

        # Lang files
        $exists = array();
        foreach($langs[$requested_lang] as $file) {
            if (in_array($file,$exists)) {
                continue;
            }
            $exists[] = $file;
            $path = path::clean($locales . '/' . $file);

            # .po files
            if (self::isPoFile($file)) {
                $po = self::getPoFile($path);
                if (!is_array($po)) {
                    continue;
                }

                foreach($po as $id => $str) {
                    $is_po[$requested_lang][$id] = 1;

                    $res[] = array(
                        'msgid' => self::encodeMsg($id),
                        'msgstr' => self::encodeMsg($str),
                        'lang' => $requested_lang,
                        'type' => 'po',
                        'path' => $path,
                        'file' => basename($file),
                        'group'=> str_replace('.po', '', basename($file))
                    );
                }
            # .lang.php files
            } elseif (self::isLangphpFile($file)) {
                $php = self::getLangphpFile($path);
                foreach($php AS $id => $str) {
                    # Don't overwrite .po
                    if (isset($is_po[$requested_lang][$id])) {
                        continue;
                    }
                    $res[] = array(
                        'msgid' => self::encodeMsg($id),
                        'msgstr' => self::encodeMsg($str), 
                        'lang' => $requested_lang,
                        'type' => 'php',
                        'path' => $path,
                        'file' => basename($file),
                        'group'=> str_replace('.lang.php', '', basename($file))
                    );
                }
            }
        }
        return $res;
    }

    public function getMsgs($module, $requested_lang = '')
    {
        # Get messages ids of a module
        $m_msgids = self::getMsgIds($module);

        # Get messages translations for a module
        $m_msgstrs = self::getMsgStrs($module, $requested_lang);

        # Get messages translations for others modules
        foreach(self::listModules() AS $o_module => $o_infos) {
            if ($o_module == $module) continue;
            $m_o_msgstrs[$o_module] = self::getMsgStrs($o_module, $requested_lang);
        }
        $m_o_msgstrs['dotclear'] = self::getMsgStrs('dotclear', $requested_lang);

        # Only one lang or all
        $langs = '' == $requested_lang ? 
            self::listLangs($module) :
            array($requested_lang => self::isIsoCode($requested_lang));

        # Let's go reorder the mixture
        $res = array();
        foreach($langs AS $lang => $iso) {
            $res[$lang] = array();

            # From id list
            foreach($m_msgids AS $rs) {
                $res[$lang][$rs['msgid']]['files'][] = array(trim($rs['file'],'/'), $rs['line']);
                $res[$lang][$rs['msgid']]['group'] = 'main';
                $res[$lang][$rs['msgid']]['msgstr'] = '';
                $res[$lang][$rs['msgid']]['in_dc'] = false;
                $res[$lang][$rs['msgid']]['o_msgstrs'] = array();
            }

            # From str list
            foreach($m_msgstrs AS $rs) {
                if ($rs['lang'] != $lang) {
                    continue;
                }

                if (!isset($res[$lang][$rs['msgid']])) {
                    $res[$lang][$rs['msgid']]['files'][] = array();
                    $res[$lang][$rs['msgid']]['in_dc'] = false;
                    $res[$lang][$rs['msgid']]['o_msgstrs'] = array();
                }
                $res[$lang][$rs['msgid']]['group'] = $rs['group'];
                $res[$lang][$rs['msgid']]['msgstr'] = $rs['msgstr'];
                $res[$lang][$rs['msgid']]['in_dc'] = false;
            }

            # From others str list
            foreach($m_o_msgstrs AS $o_module => $o_msgstrs) {
                foreach($o_msgstrs AS $rs) {
                    if ($rs['lang'] != $lang) {
                        continue;
                    }

                    if (!isset($res[$lang][$rs['msgid']])) {
                        continue;
                    }

                    $res[$lang][$rs['msgid']]['o_msgstrs'][] = array(
                        'msgstr' => $rs['msgstr'],
                        'module' => $o_module,
                        'file' => $rs['file']
                    );
                    if ($o_module == 'dotclear') {
                        $res[$lang][$rs['msgid']]['in_dc'] = true;
                    }
                }
            }
        }
        return '' == $requested_lang ? $res : $res[$requested_lang];
    }

    /* Write a lang file */
    private function writeLangFile($dir, $content, $throw)
    {
        $path = path::info($dir);
        if (is_dir($path['dirname']) && !is_writable($path['dirname']) 
         || file_exists($dir) && !is_writable($dir)) {
            throw new Exception(sprintf(
                __('Cannot grant write acces on lang file %s'), $dir
            ));
        }

        # -- BEHAVIOR -- dcTranslaterBeforeWriteLangFile
        $this->core->callBehavior('dcTranslaterBeforeWriteLangFile', $dir, $content, $throw);

        $f = @files::putContent($dir,$content);
        if (!$f && $throw) {
            throw new Exception(sprintf(
                __('Cannot write lang file %s'), $dir
            ));
        }

        # -- BEHAVIOR -- dcTranslaterAfterWriteLangFile
        $this->core->callBehavior('dcTranslaterAfterWriteLangFile', $f, $dir, $content, $throw);

        return $f;
    }

    /* Try if a file is a .lang.php file */
    public static function isLangphpFile($file)
    {
        return files::getExtension($file) == 'php' && stristr($file, '.lang.php');
    }

    /* Get and parse a .lang.php file */
    public static function getLangphpFile($file)
    {
        if (!file_exists($file)) {
            return array();
        }

        $res = array();
        $content = implode('',file($file));
        $count = preg_match_all('/(\$GLOBALS\[\'__l10n\'\]\[\'(.*?)\'\]\s*\x3D\s*\'(.*?)\';)/', $content, $m);

        if (!$count) {
            return array();
        }

        for ($i = 0; $i < $count; $i++) {
            $id = $m[2][$i];
            $str = self::langphpString($m[3][$i]);

            if ($str) {
                $res[self::langphpString($id)] = $str;
            }
        }
        if (!empty($res[''])) {
            $res = array_diff_key($res,array(''=>1));
        }
        return $res;
    }

    /* Construct and write a .lang.php file */
    private function setLangphpFile($module, $lang, $group, $fields)
    {
        if (!$this->write_langphp) {
            return;
        }

        # Not a module installed
        $locales = self::getLangsFolder($module, true);

        # Path is right formed
        $lang_name = self::isIsoCode($lang, true);

        $l = "<?php\n";
        if ($this->parse_comment) {
            $l .= 
            '// Language: ' . $lang_name . " \n" .
            '// Module: ' . $module . " - " . self::moduleInfo($module, 'version') . "\n" .
            '// Date: ' . dt::str('%Y-%m-%d %H:%M:%S') . " \n";

            if ($this->parse_user && !empty($this->parse_userinfo)) {
                $search = self::$allowed_user_informations;
                foreach($search AS $n) {
                    $replace[] = $this->core->auth->getInfo('user_' . $n);
                }               
                $info = trim(str_replace($search,$replace,$this->parse_userinfo));
                if (!empty($info)) {
                    $l .= '// Author: ' . html::escapeHTML($info) . "\n";
                }
            }
            $l .= 
            '// Translated with dcTranslater - ' . $this->core->plugins->moduleInfo('translater', 'version') . " \n\n";
        }
        if ($this->parse_comment) {
            $infos = self::getMsgids($module);
            foreach($infos AS $info) {
                if (isset($fields[$info['msgid']])) {
                    $comments[$info['msgid']] = (isset($comments[$info['msgid']]) ?
                        $comments[$info['msgid']] : '') .
                        '#'.trim($info['file'],'/') . ':' . $info['line'] . "\n";
                }
            }
        }

        foreach($fields as $id => $str) {
            if ($this->parse_comment && isset($comments[$id])) {
                $l .= $comments[$id];
            }

            $l .= 
            '$GLOBALS[\'__l10n\'][\'' . addcslashes($id, "'") . '\'] = ' .
            '\'' . self::langphpString($str, true) . "';\n";

            if ($this->parse_comment) {
                $l .= "\n";
            }
        }
        $l .= "";

        self::writeLangFile($locales . '/' . $lang . '/' . $group . '.lang.php', $l, true);
    }

    /* Parse a .lang.php string */
    private static function langphpString($string, $reverse = false)
    {
        if ($reverse) {
            $smap = array('\'', "\n", "\t", "\r");
            $rmap = array('\\\'', '\\n"' . "\n" . '"', '\\t', '\\r');
            return trim((string) str_replace($smap, $rmap, $string));
        } else {
            $smap = array('/\\\\n/', '/\\\\r/', '/\\\\t/', "/\\\'/");
            $rmap = array("\n", "\r", "\t", "'");
            return trim((string) preg_replace($smap, $rmap, $string));
        }
    }

    /* Try if a file is a .po file */
    public static function isPoFile($file)
    {
        return files::getExtension($file) == 'po';
    }

    /* Get and parse a .po file */
    public static function getPoFile($file)
    {
        if (!file_exists($file)) {
            return false;
        }

        $res = array();
        $content = implode('',file($file));

        $count = preg_match_all('/msgid\s(.*(?:\n".*")*)\nmsgstr\s(.*(?:\n".*")*)/', $content, $m); 

        if (!$count) return false;

        for ($i = 0; $i < $count; $i++) {
            $id = preg_replace('/"(.*)"/s','\\1', $m[1][$i]);
            $str= preg_replace('/"(.*)"/s','\\1', $m[2][$i]);

            $str = self::poString($str);

            if ($str) {
                $res[self::poString($id)] = $str;
            }
        }

        if (!empty($res[''])) {
            $res = array_diff_key($res, array(''=>1));       
        }
        return $res;
    }
    /* Construct and parse a .po file */
    private function setPoFile($module, $lang, $group, $fields)
    {
        if (!$this->write_po) {
            return;
        }

        # Not a module installed
        $locales = self::getLangsFolder($module, true);

        # Path is right formed
        self::isIsoCode($lang, true);

        $l = '';
        if ($this->parse_comment) {
            $l .= 
            '# Language: ' . self::$iso[$lang] . "\n" .
            '# Module: ' . $module . " - " . self::moduleInfo($module, 'version') . "\n" .
            '# Date: ' . dt::str('%Y-%m-%d %H:%M:%S') . "\n";

            if ($this->parse_user && !empty($this->parse_userinfo)) {
                $search = self::$allowed_user_informations;
                foreach($search AS $n) {
                    $replace[] = $this->core->auth->getInfo('user_' . $n);
                }
                $info = trim(str_replace($search, $replace, $this->parse_userinfo));
                if (!empty($info)) {
                    $l .= '# Author: ' . html::escapeHTML($info) . "\n";
                }
            }
            $l .= 
            '# Translated with translater ' . $this->core->plugins->moduleInfo('translater', 'version') . "\n";
        }
        $l .= 
        "\n".
        "msgid \"\"\n" .
        "msgstr \"\"\n" .
        '"Content-Type: text/plain; charset=UTF-8\n"' . "\n" .
        '"Project-Id-Version: ' . $module . ' ' . self::moduleInfo($module, 'version') . '\n"' . "\n" .
        '"POT-Creation-Date: \n"' . "\n" .
        '"PO-Revision-Date: ' . date('c') . '\n"' . "\n" .
        '"Last-Translator: ' . $this->core->auth->getInfo('user_cn') . '\n"' . "\n" .
        '"Language-Team: \n"' . "\n" .
        '"MIME-Version: 1.0\n"' . "\n" .
        '"Content-Transfer-Encoding: 8bit\n"' . "\n" .
        '"Plural-Forms: nplurals=2; plural=(n > 1);\n"' . "\n\n";

        if ($this->parse_comment) {
            $infos = self::getMsgids($module);
            foreach($infos AS $info) {
                if (isset($fields[$info['msgid']])) {
                    $comments[$info['msgid']] = (isset($comments[$info['msgid']]) ?
                        $comments[$info['msgid']] : '') .
                        '#: '.trim($info['file'],'/') . ':' . $info['line'] . "\n";
                }
            }
        }

        foreach($fields as $id => $str) {
            if ($this->parse_comment && isset($comments[$id])) {
                $l .= $comments[$id];
            }
            $l .= 
            'msgid "' . self::poString($id, true) . '"' . "\n" .
            'msgstr "' . self::poString($str, true) . '"' . "\n\n";
        }

        self::writeLangFile($locales . '/' . $lang . '/' . $group . '.po', $l, true);
    }

    /* Parse .po string */
    private static function poString($string, $reverse = false)
    {
        if ($reverse) {
            $smap = array('"', "\n", "\t", "\r");
            $rmap = array('\\"', '\\n"' . "\n" . '"', '\\t', '\\r');
            return trim((string) str_replace($smap, $rmap, $string));
        } else {
            $smap = array('/"\s+"/', '/\\\\n/', '/\\\\r/', '/\\\\t/', '/\\\"/');
            $rmap = array('', "\n", "\r", "\t", '"');
            return trim((string) preg_replace($smap, $rmap, $string));
        }
    }

    /* Scan recursively a folder and return files and folders names */
    public static function scandir($path, $dir = '', $res = array())
    {
        $path = path::real($path);
        if (!is_dir($path) || !is_readable($path)) {
            return array();
        }

        $files = files::scandir($path);

        foreach($files AS $file) {
            if ($file == '.' || $file == '..') {
                continue;
            }

            if (is_dir($path . '/' . $file)) {
                $res[] = $file;
                $res = self::scanDir($path . '/' . $file, $dir . '/' . $file, $res);
            } else {
                $res[] = empty($dir) ? $file : $dir . '/' . $file;
            }
        }
        return $res;
    }

    /* Return array of langs like in clearbreaks l10n */
    public static function getIsoCodes($flip = false, $name_with_code = false)
    {
        if (empty(self::$iso)) {
            self::$iso = l10n::getISOcodes($flip, $name_with_code);
        }
        return self::$iso;
    }

    /* Find if lang code exists or lang name */
    public static function isIsoCode($iso, $throw = false)
    {
        $codes = self::getIsoCodes();
        $code = isset($codes[$iso]) ? $codes[$iso] : false;
        if (!$code && $throw) {
            throw new Exception(sprintf(
                __('Cannot find language for code %s'), $iso
            ));
        }
        return $code;
    }
}