local function fetchRedirect(...)
    Images:processResponse(...)
end

Require('Table');
Require('Thread');
Require('Math');
Require('Events');
Require('Element');

local Images = {}

Images.WaitingQueue = {} -- queue of waiting downloads
Images.DownloadQueue = {} -- queue of downloads
Images.WaitingQueueCount = 0 -- count of waiting queue
Images.DownloadLimiter = 4 -- max downloads in the same time
Images.DelayTimer = 8000 -- delay between downloads

Images.AlterDelay = function(self, delay, returnToDefault)
    assert(type(delay) == 'number', 'Delay must be a number')
    assert(type(returnToDefault) == 'number', 'Return to default must be a number')
    self.DelayTimer = delay

    if not isTimer(self.returnToDefaulltDelay) then
        self.returnToDefaulltDelay = setTimer(function()
            self.DelayTimer = 8000
        end, returnToDefault, 1)
    else
        killTimer(self.returnToDefaulltDelay)
        self.returnToDefaulltDelay = setTimer(function()
            self.DelayTimer = 8000
        end, returnToDefault, 1)
    end
end

Images.processResponse = function(self, response, err, i)
    local data = self.DownloadQueue[i];

    if (not data) then
        return
    end

    if (not err.success) then
        if type (data.arguments) == 'table' and next(data.arguments) ~= nil then
            data.callback(false, err, unpack(data.arguments))
        else
            data.callback(false, err)
        end
    else
        if type(data.arguments) == 'table' and next(data.arguments) ~= nil then
            data.callback(response, err, unpack(data.arguments));
        else
            data.callback(response, err);
        end
    end

    self.DownloadQueue[i] = nil;

    for k, v in next, self.WaitingQueue, nil do
        self.WaitingQueueCount = self.WaitingQueueCount + 1;
        
        self.DownloadQueue[k] = v;
        self.WaitingQueue[k] = nil;

        CreateThread(function(url, data)
            local self = IMAGES;

            WaitTick(self.DelayTimer * self.WaitingQueueCount);

            self.DownloadQueue[url].fetch = fetchRemote(url, {connectionAttempts = 2, connectTimeout = 30000, method = 'GET'}, fetchRedirect, {url});
            self.WaitingQueueCount = self.WaitingQueueCount - 1;
        end, k, v);

        if (table.size(self.DownloadQueue) >= self.DownloadLimiter) then
            break
        end
    end
end

Images.prepareQueue = function(self, url, callback, args)
    if (table.size(self.DownloadQueue) < self.DownloadLimiter) then
        self.DownloadQueue[url] = {
            fetch = fetchRemote(url, {connectionAttempts = 2, connectTimeout = 30000, method = 'GET'}, fetchRedirect, {url}),
            callback = callback,
            arguments = args,
        }
    else
        self.WaitingQueue[url] = {callback = callback, arguments = args}
    end
end

Images.getExternImage = function(self, url, callback, args)
    if (self.DownloadQueue[url] or self.WaitingQueue[url]) then
        return true
    end

    if (isBrowserDomainBlocked(url)) then
        requestBrowserDomains({url}, true, function(success)
            if (success) then
                self:prepareQueue(url, callback, args)
            else
                if type (args) == 'table' and table.size(args) > 0 then
                    callback(false, {success = false, error = 'Blocked domain'}, unpack(args))
                else
                    callback(false)
                end
            end
        end)
    else
        self:prepareQueue(url, callback, args)
    end
end

_G.IMAGES = IMAGES;
_G.Images = Images;

return Images