require'tango.server.copas_socket'
local random = math.random

function Frand(i)
    return random(-i,i)
end

print("start server localhost:12345")
tango.server.copas_socket.loop{
  port = 12345,
  host = "*"
}

start luajit tango_srv.lua >tango_srv.log

require'tango.client.socket'
local random = math.random
local res, time, N = 0, 0, 1000
-- 1 вычисления в цикле
-- 2 то же в функции
-- 3 то же в функции RPC

function runtest0( times)
    local begin = os.clock()
    local x=0
    for i = 1, times do
        x = x + random(-i,i)
    end
    local endtm = os.clock()
    return x, endtm - begin
end

function runtest(func, times)
    local begin = os.clock()
    local x=0
    for i = 1, times do
        x = x + func(i)
    end
    local endtm = os.clock()
    return x, endtm - begin
end

function Frand(i)
    return random(-i,i)
end

local proxy = tango.client.socket.connect{
   address = 'localhost',
   port = 12345
}

res,time = runtest0(N)
print("test loop", time)

res,time = runtest(Frand, N)
print("test Frand", time)

res,time = runtest(proxy.Frand,N)
print("test proxy.Frand", time)

luajit -joff test_tango_rpc.lua

test loop    0
test Frand    0
test proxy.Frand    0.238

-- compare checks and annotate.check
local getmetatable=getmetatable

require 'checks'
     
-- Custom checker function --
function checkers.port(p)
  return type(p)=='number' and p>0 and p<0x10000
end

-- A new named type --
socket_mt = { __type='socket', _type='socket' }
asocket = setmetatable ({ }, socket_mt)

-- Annotate
local annotate = require( "annotate" )
local check = require( "annotate.check" )
check.types.port = function( p )
  return type(p)=='number' and p>0 and p<0x10000
end

check.types.socket = function( sock )
  return (getmetatable (sock) or {})._type or type (sock)
end

-- original function
local test_func = function (n, s, t, sock, port, str)
  sock.port=port 
  if str and not sock[str] then 
     sock[str]= getmetatable(sock)
  end
  sock.n = (sock.n or 1) + 1
  return s..n
end

local function test_checks ( n, s, t, sock, port, str)
  checks ('number', 'string', 'table', 'socket', 'port', '?string')
  return test_func
end

local test_annotate = annotate[=[
test_annotate( n, s, t, sock, port, str ) => string
    n: number
    s: string
    t: table
    sock: socket
    port: port
    str:  nil/string
]=] .. test_func

-- my checks
local io_type=io.type
local function _type (x)
  return (getmetatable (x) or {})._type or io_type (x) or type (x)
end

-- assert - my best
local function test_mycheck(n, s, t, sock, port, str)
  if     type(n)~="number"  then error("wrong param #1:"..tostring(n))
  elseif type(s)~="string"   then error("wrong param #2:"..tostring(s))
  elseif type(t)~="table"   then error("wrong param #3:"..tostring(t))
  elseif not ( type( sock)=="table" and (getmetatable(sock) or {})._type=="socket" ) 
    then error("wrong param #4:"..tostring(sock))
  elseif not ( type( port)=="number" and port>0 and port<0x10000) -- "type" port
    then error("wrong param #5:"..tostring(port))
  elseif type(str)~="string"   then error("wrong param #6:"..tostring(str))
  end
  return test_func
end

function run_test(fname, fn, sock, port, str)
  local x=''
  local t={1,2,3}
  local n=1000000
  local start_time=os.clock()

  for i=1,n do
    fn( i, 'dhdh', t, sock, i%10000+1, str)
  end
  print(fname, "time:", tonumber(os.clock() - start_time))
end

print("------------------------------------")
run_test("pure test_func", test_func, asocket, 1024, "hello")
run_test("test_checks", test_checks, asocket, 1024, "hello")
run_test("test_annotate", test_annotate, asocket, 1024, "hello")
run_test("test_mycheck", test_mycheck, asocket, 1024, "hello")