--[[

        server.lua by blastbeat

        - this script contains the server loop of the program

        - other scripts can reg a server here

]]--

-- // wrapping luadch stuff // --

local use = function( what )

    return _G[ what ]

end

local clean = function( tbl )

    for i, k in pairs( tbl ) do

        tbl[ i ] = nil

    end

end

local log, table_concat = require ("util.logger").init("socket"), table.concat;

local out_put = function (...) return log("debug", table_concat{...}); end

local out_error = function (...) return log("warn", table_concat{...}); end

local mem_free = collectgarbage

----------------------------------// DECLARATION //--

--// constants //--

local STAT_UNIT = 1    -- byte

--// lua functions //--

local type = use "type"

local pairs = use "pairs"

local ipairs = use "ipairs"

local tostring = use "tostring"

local collectgarbage = use "collectgarbage"

--// lua libs //--

local os = use "os"

local table = use "table"

local string = use "string"

local coroutine = use "coroutine"

--// lua lib methods //--

local os_time = os.time

local os_difftime = os.difftime

local table_concat = table.concat

local table_remove = table.remove

local string_len = string.len

local string_sub = string.sub

local coroutine_wrap = coroutine.wrap

local coroutine_yield = coroutine.yield

--// extern libs //--

local luasec = select( 2, pcall( require, "ssl" ) )

local luasocket = require "socket"

--// extern lib methods //--

local ssl_wrap = ( luasec and luasec.wrap )

local socket_bind = luasocket.bind

local socket_sleep = luasocket.sleep

local socket_select = luasocket.select

local ssl_newcontext = ( luasec and luasec.newcontext )

--// functions //--

local id

local loop

local stats

local idfalse

local addtimer

local closeall

local addserver

local wrapserver

local getsettings

local closesocket

local removesocket

local removeserver

local changetimeout

local wrapconnection

local changesettings

--// tables //--

local _server

local _readlist

local _timerlist

local _sendlist

local _socketlist

local _closelist

local _readtimes

local _writetimes

--// simple data types //--

local _

local _readlistlen

local _sendlistlen

local _timerlistlen

local _sendtraffic

local _readtraffic

local _selecttimeout

local _sleeptime

local _starttime

local _currenttime

local _maxsendlen

local _maxreadlen

local _checkinterval

local _sendtimeout

local _readtimeout

local _cleanqueue

local _timer

local _maxclientsperserver

----------------------------------// DEFINITION //--

_server = { }    -- key = port, value = table; list of listening servers

_readlist = { }    -- array with sockets to read from

_sendlist = { }    -- arrary with sockets to write to

_timerlist = { }    -- array of timer functions

_socketlist = { }    -- key = socket, value = wrapped socket (handlers)

_readtimes = { }   -- key = handler, value = timestamp of last data reading

_writetimes = { }   -- key = handler, value = timestamp of last data writing/sending

_closelist = { }    -- handlers to close

_readlistlen = 0    -- length of readlist

_sendlistlen = 0    -- length of sendlist

_timerlistlen = 0    -- lenght of timerlist

_sendtraffic = 0    -- some stats

_readtraffic = 0

_selecttimeout = 1    -- timeout of socket.select

_sleeptime = 0    -- time to wait at the end of every loop

_maxsendlen = 51000 * 1024    -- max len of send buffer

_maxreadlen = 25000 * 1024    -- max len of read buffer

_checkinterval = 1200000    -- interval in secs to check idle clients

_sendtimeout = 60000    -- allowed send idle time in secs

_readtimeout = 6 * 60 * 60    -- allowed read idle time in secs

_cleanqueue = false    -- clean bufferqueue after using

_maxclientsperserver = 1000

----------------------------------// PRIVATE //--

wrapserver = function( listeners, socket, ip, serverport, pattern, sslctx, maxconnections, startssl )    -- this function wraps a server

    maxconnections = maxconnections or _maxclientsperserver

    local connections = 0

    local dispatch, disconnect = listeners.incoming or listeners.listener, listeners.disconnect

    local err

    local ssl = false

    if sslctx then

        if not ssl_newcontext then

            return nil, "luasec not found"

        end

        if type( sslctx ) ~= "table" then

            out_error "server.lua: wrong server sslctx"

            return nil, "wrong server sslctx"

        end

        sslctx, err = ssl_newcontext( sslctx )

        if not sslctx then

            err = err or "wrong sslctx parameters"

            out_error( "server.lua: ", err )

            return nil, err

        end

        ssl = true

    else

	out_put("server.lua: ", "ssl not enabled on ", serverport);

    end

    local accept = socket.accept

    --// public methods of the object //--

    local handler = { }

    handler.shutdown = function( ) end

    handler.ssl = function( )

        return ssl

    end

    handler.remove = function( )

        connections = connections - 1

    end

    handler.close = function( )

        for _, handler in pairs( _socketlist ) do

            if handler.serverport == serverport then

                handler.disconnect( handler, "server closed" )

                handler.close( true )

            end

        end

        socket:close( )

        _sendlistlen = removesocket( _sendlist, socket, _sendlistlen )

        _readlistlen = removesocket( _readlist, socket, _readlistlen )

        _socketlist[ socket ] = nil

        handler = nil

        socket = nil

        mem_free( )

        out_put "server.lua: closed server handler and removed sockets from list"

    end

    handler.ip = function( )

        return ip

    end

    handler.serverport = function( )

        return serverport

    end

    handler.socket = function( )

        return socket

    end

    handler.readbuffer = function( )

        if connections > maxconnections then

            out_put( "server.lua: refused new client connection: server full" )

            return false

        end

        local client, err = accept( socket )    -- try to accept

        if client then

            local ip, clientport = client:getpeername( )

            client:settimeout( 0 )

            local handler, client, err = wrapconnection( handler, listeners, client, ip, serverport, clientport, pattern, sslctx, startssl )    -- wrap new client socket

            if err then    -- error while wrapping ssl socket

                return false

            end

            connections = connections + 1

            out_put( "server.lua: accepted new client connection from ", tostring(ip), ":", tostring(clientport), " to ", tostring(serverport))

            return dispatch( handler )

        elseif err then    -- maybe timeout or something else

            out_put( "server.lua: error with new client connection: ", tostring(err) )

            return false

        end

    end

    return handler

end

wrapconnection = function( server, listeners, socket, ip, serverport, clientport, pattern, sslctx, startssl )    -- this function wraps a client to a handler object

    socket:settimeout( 0 )

    --// local import of socket methods //--

    local send

    local receive

    local shutdown

    --// private closures of the object //--

    local ssl

    local dispatch = listeners.incoming or listeners.listener

    local disconnect = listeners.disconnect

    local bufferqueue = { }    -- buffer array

    local bufferqueuelen = 0    -- end of buffer array

    local toclose

    local fatalerror

    local needtls

    local bufferlen = 0

    local noread = false

    local nosend = false

    local sendtraffic, readtraffic = 0, 0

    local maxsendlen = _maxsendlen

    local maxreadlen = _maxreadlen

    --// public methods of the object //--

    local handler = bufferqueue    -- saves a table ^_^

    handler.dispatch = function( )

        return dispatch

    end

    handler.disconnect = function( )

        return disconnect

    end

    handler.setlistener = function( listeners )

        dispatch = listeners.incoming

        disconnect = listeners.disconnect

    end

    handler.getstats = function( )

        return readtraffic, sendtraffic

    end

    handler.ssl = function( )

        return ssl

    end

    handler.send = function( _, data, i, j )

        return send( socket, data, i, j )

    end

    handler.receive = function( pattern, prefix )

        return receive( socket, pattern, prefix )

    end

    handler.shutdown = function( pattern )

        return shutdown( socket, pattern )

    end

    handler.close = function( forced )

        if not handler then return true; end

        _readlistlen = removesocket( _readlist, socket, _readlistlen )

        _readtimes[ handler ] = nil

        if bufferqueuelen ~= 0 then

            if not ( forced or fatalerror ) then

                handler.sendbuffer( )

                if bufferqueuelen ~= 0 then   -- try again...

                    if handler then

                        handler.write = nil    -- ... but no further writing allowed

                    end

                    toclose = true

                    return false

                end

            else

                send( socket, table_concat( bufferqueue, "", 1, bufferqueuelen ), 1, bufferlen )    -- forced send

            end

        end

        _ = shutdown and shutdown( socket )

        socket:close( )

        _sendlistlen = removesocket( _sendlist, socket, _sendlistlen )

        _socketlist[ socket ] = nil

        if handler then

            _writetimes[ handler ] = nil

            _closelist[ handler ] = nil

            handler = nil

        end

        socket = nil

        mem_free( )

	if server then

		server.remove( )

	end

        out_put "server.lua: closed client handler and removed socket from list"

        return true

    end

    handler.ip = function( )

        return ip

    end

    handler.serverport = function( )

        return serverport

    end

    handler.clientport = function( )

        return clientport

    end

    local write = function( data )

        bufferlen = bufferlen + string_len( data )

        if bufferlen > maxsendlen then

            _closelist[ handler ] = "send buffer exceeded"   -- cannot close the client at the moment, have to wait to the end of the cycle

            handler.write = idfalse    -- dont write anymore

            return false

        elseif socket and not _sendlist[ socket ] then

            _sendlistlen = _sendlistlen + 1

            _sendlist[ _sendlistlen ] = socket

            _sendlist[ socket ] = _sendlistlen

        end

        bufferqueuelen = bufferqueuelen + 1

        bufferqueue[ bufferqueuelen ] = data

        if handler then

        	_writetimes[ handler ] = _writetimes[ handler ] or _currenttime

        end

        return true

    end

    handler.write = write

    handler.bufferqueue = function( )

        return bufferqueue

    end

    handler.socket = function( )

        return socket

    end

    handler.pattern = function( new )

        pattern = new or pattern

        return pattern

    end

    handler.setsend = function ( newsend )

        send = newsend or send

        return send

    end

    handler.bufferlen = function( readlen, sendlen )

        maxsendlen = sendlen or maxsendlen

        maxreadlen = readlen or maxreadlen

        return maxreadlen, maxsendlen

    end

    handler.lock = function( switch )

        if switch == true then

            handler.write = idfalse