/**
 * Обертка для document.getElementById.
 * @return {mixed} Возвращает элемент либо null.
 **/
function g(id) { return document.getElementById(id); }

/**
 * Экранирует символы: \, ', ".
 * @param {string} str
 * @return {string}
 */
function addSlashes(str)
{
    return str.replace(/([\\'"])/g, '\\$1');
}

/**
 * Обратная функция для addSlashes.
 * @param {string} str
 * @return {string}
 */
function stripSlashes(str)
{
    return str.replace(/\\([\\'"])/g, '$1');
}

/**
 * Заменяет на HTML-сущности спецсимволы: &, <, >, ".
 * @param {string} str
 * @return {string}
 */
function escapeHTML(str)
{
    return str.replace(/[&"<>]/g, function (x) {
        return '&' + {'&': 'amp', '"': 'quot', '<': 'lt', '>': 'gt'}[x] + ';';
    });
}

/**
 * Возвращает случайное число с дробной частью.
 * @param {number} min Минимальное значение.
 * @param {number} max Максимальное значение.
 * @return {number} Случайное число.
 **/
function rand(min, max)
{
    return Math.random() * (max - min + 1) + min;
}

/**
 * Возвращает случайное число без дробной частью.
 * @param {number} min Минимальное значение.
 * @param {number} max Максимальное значение.
 * @return {number} Случайное число.
 **/
function randInt(min, max)
{
    return Math.floor(rand(min, max));
}

/**
 * Возвращает случайный элемент массива.
 * @param {array} arr Исходный массив.
 * @return {object} Случайный элемент массива.
 **/
function randElem(arr)
{
    return arr[randInt(0, arr.length - 1)];
}

/**
 * Генерирует случайную строку.
 * @param {number} len Длина строки. По-умолчанию 8 символов.
 * @param {string} chars Набор символов. По-умолчанию используются цифры и ASCII буквы.
 * @return {string}
 **/
function randStr(len, chars)
{
    if (len == undefined)  {
        len = 8;
    }
    if (chars == undefined) {
        chars = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz';
    }
    var ret = '';
    var last = chars.length - 1;
    for (var i = 0; i < len; ++i) {
        ret += chars.charAt(randInt(0, last));
    }
    return ret;
}

/**
 * Перемешивает элементы массива.
 * @param {array} arr Исходный массив.
 * @return {array} Новый массив.
 **/
function shuffle(arr)
{
    return arr.sort(function () {
        return 0.5 > Math.random();
    });
}

/**
 * "Переворачивает" строку.
 * @param {string} str
 * @return {string}
 **/
function reverseStr(str)
{
    return str.split(/|/).reverse().join('');
}

/**
 * Повторяет строку n-раз.
 * @param {string} str
 * @param {number} n Сколько раз повторить строку.
 * @return {string}
 **/
function repeatStr(str, n)
{
    return new Array(++n).join(str);
}

/**
 * Устанавливает cookie.
 * @param {string} name Имя.
 * @param {string} value Значение.
 * @param {number} days Количество дней.
 **/
function setCookie(name, value, days)
{
    document.cookie = encodeURIComponent(name) + '=' + encodeURIComponent(value) + '; Expires=' + new Date(new Date().getTime() + days * 86400000).toUTCString();
}

/**
 * Удаляет cookie.
 * @param {string} name Имя.
 **/
function deleteCookie(name)
{
    setCookie(name, '', -1);
}

querystring = new (function QueryString() {
    var self = this;

    /**
     * Декодирует компонент URI.
     * @param {string} str Исходная строка.
     * @return {string}
     **/
    self.unescape = function (str) {
        return decodeURIComponent(str.replace(/\+/g, ' '));
    };

    /**
     * Парсит URI-параметры.
     * @param {string} str Исходная строка.
     * @param {string} sep Разделитель параметров.
     * @param {string} eq Разделитель пар ключ-значение.
     * @return {object}
     **/
    self.parse = function (str, sep, eq) {
        sep = sep || '&';
        eq = eq || '=';
        var parts = str.split(sep);
        var part;
        var pos;
        var key;
        var keys;
        var value;
        var cur;
        var name;
        var ret = {};
        for (var i = 0; i < parts.length; ++i) {
            part = parts[i];
            pos = part.indexOf(eq);
            pos = pos == -1 ? part.length : pos
            keys = parseParamName(part.slice(0, pos));
            value = self.unescape(part.slice(++pos));
            cur = ret;
            while ((key = keys.shift()) != null) {
                name = self.unescape(key);
                // console.log(name);
                if (keys.length) {
                    if (!cur[name]) {
                        cur[name] = /^(|\d|[1-9]\d+)$/.test(name) ? [] : {};
                    }
                    cur = cur[name];
                }
            }
            cur[name] = value;
        }
        return ret;
    };

    /**
     * Разбивает имя параметра на части.
     * foo[bar] -> ['foo', 'bar']
     * @param {string} str Имя параметра.
     * @return {array}
     **/
    function parseParamName(str) {
        var a = [];
        var p;
        var p1 = 0;
        while (~(p = str.indexOf('[', p1))) {
            if (!a.length) {
                a.push(0, p);
            }
            p1 = p1 && p1 > p ? -1 : str.indexOf(']', ++p);
            if (-1 == p1) {
                throw 'Bad parameter name';
            }
            a.push(p, p1++);
        }
        if (a.length) {
            var a1 = [];
            for (var i = 0; i < a.length; i += 2) {
                a1.push(str.slice(a[i], a[i + 1]));
            }
            return a1;
        }
        return [str];
    }

    /**
     * Создает из объекта строку с параметрами.
     * @param {string} obj Параметры.
     * @param {string} sep Разделитель параметров.
     * @param {string} eq Разделитель пар ключ-значение.
     * @return {string}
     **/
    self.stringify = function (obj, sep, eq) {
        var pairs = [];
        var name;
        var value;
        eq = eq || '=';
        for (var i in obj) {
            if (obj.hasOwnProperty(i)) {
                name = encodeURIComponent(i);
                value = encodeURIComponent(obj[i]);
                pairs.push(name + eq + value);
            }
        }
        return pairs.join(sep || '&');
    };
})();

ajax = new (function Ajax() {
    var self = this;

    /**
     * Отправляет произвольный запрос.
     * @param {string} m Метод.
     * @param {string} u Адрес.
     * @param {function} cb function (xhr) { ... } Функция, которая будет вызвана после получения ответа сервера.
     * @param {mixed} d Данные.
     * @param {string} t Тип данных.
     **/
    self.send = function (m, u, cb, d, t) {
        var r = new XMLHttpRequest;
        r.open(m, u);
        r.onload = function () {
            cb(r);
        };
        if (t) {
            req.setRequestHeader('Content-Type', t);
        }
        r.setRequestHeader('X-Requested-With', 'XMLHttpRequest');
        r.send(d);
    };

    /**
     * Отправляет GET-запрос.
     * @param {string} u Адрес.
     * @param {function} cb function (xhr) { ... } Функция, которая будет вызвана после получения ответа сервера.
     **/
    self.get = function (u, cb) {
        self.send('GET', u, cb);
    };

    /**
     * Отправляет POST-запрос.
     * @param {string} u Адрес.
     * @param {function} cb function (xhr) { ... } Функция, которая будет вызвана после получения ответа сервера.
     * @param {mixed} d Данные: строка, хэш, HTMLFormElement, FormData.
     **/
    self.post = function (u, cb, d) {
        if (d instanceof HTMLFormElement) {
            d = new FormData(d);
        }
        else if (d.constructor == Object) {
            d = querystring.stringify(d);
        }
        self.send('POST', u, cb, d, !(d instanceof FormData) ? 'application/x-www-form-urlencoded': null);
    };

    /**
     * Загружает содержимое в контейнер.
     * @param {string} u Адрес.
     * @param {mixed} el Элемент либо id элемента.
     **/
    self.load = function (u, el) {
        if (typeof el == 'string') {
            el = g(el);
        }
        if (el) {
            var f = function (r) {
                if (r.status == 200) {
                    el.innerHTML = r.response;
                }
                else {
                    throw 'Server has returned an unexpected response: (' + r.status + ') ' + r.statusText + '.';
                }
            };
            self.get(u, f);
        }
    };
})();

/**
 * Экранирует специальные символы, используемые в регулярном выражении.
 * @param {string} str
 * @return {string}
 */
function escapeRegExp(str)
{
    return str.replace(/([.?*+^$[\]\\(){}|-])/g, '\\$1');
}

/**
 * Сохраняет файл по ссылке под определенным именем.
 * @param {string} name Имя сохраняемого файла.
 * @param {string} url Путь до файла на сервере либо Data URI.
 */
function saveFile(name, url)
{
    var link = document.createElement('a');
    link.setAttribute('download', name);
    link.href = url;
    link.onclick = function () {
        document.body.removeChild(this);
    };
    link.style.display = 'none';
    document.body.appendChild(link);
    link.click();
}

/**
 * Парсит url и возвращает объект.
 * @param {string} url Путь до файла на сервере.
 * @return {object}
 */
function parseURL(url)
{
    var link = document.createElement('a');
    link.href = url;
    var obj = {
        hash: '',
        host: '',
        hostname: '',
        href: '',
        origin: '',
        pathname: '',
        port: '',
        protocol: '',
        search: ''
    };
    for (var i in obj) {
        obj[i] = link[i];
    }
    return obj;
}

/**
 * Возвращает изображение с холста в виде Blob.
 * @param {HTMLCanvasElement} canvas
 * @param {string} MIME-тип в который хотим преобразовать изображение на холсте.
 * @param {number} quality Качество JPEG-изображения, число с плавающей точкой в диапазоне от 0 до 1.
 * @return {Blob}
 */
function canvasToBlob(canvas, type, quality)
{
    var data = canvas.toDataURL(type, quality);
    data = atob(data.substr(data.indexOf(',') + 1));
    var i = data.length;
    var arr = new Uint8Array(i);
    while (i--) {
        arr[i] = data.charCodeAt(i);
    }
    return new Blob([arr], {type: type});
}