local ipairs = ipairs
local table = table
local math = math
local next = next
local string = string
local redisproxy = redisproxy
local MsgPack = MsgPack
local getRandomName = getRandomName
local mcast_util = mcast_util
local string_format = string.format
local tonumber = tonumber
local require = require

local _M = {}

function _M.listRpc(agent, data)
    local role = agent.role
    local msg = MsgPack.unpack(data)
    local typ = msg.typ
    local id = msg.id

    local capsules = {}
    if typ == 1 then
        local ret = skynet.call(agent.capsule_serv, "lua", "list", id)
        if next(ret) then
            for k, v in pairs(ret) do
                capsules[k] = v
            end
        end
    elseif typ == 0 then
        local ret = role:getCapsuleList(id)
        if next(ret) then
            for k, v in pairs(ret) do
                capsules[k] = v
            end
        end
    end

    SendPacket(actionCodes.Capsule_listRpc, MsgPack.pack(capsules))
    return true
end

function _M.joinRpc(agent, data)
    local role = agent.role
    local msg = MsgPack.unpack(data)
    local roleId = role:getProperty("id")
    local capsuleId = msg.capsule_id --如果刷新则需要传递当前扭蛋机id
    local typ = msg.typ or 1

    local ret = {}
    if typ == 1 then
        ret = skynet.call(agent.capsule_serv, "lua", "join", roleId, capsuleId)
    elseif typ == 0 then
        ret = role:joinCapsule(roleId, capsuleId)
    end
    SendPacket(actionCodes.Capsule_joinRpc, MsgPack.pack(ret))
    return true
end

function _M.exitRpc(agent, data)
    local role = agent.role
    local msg = MsgPack.unpack(data)
    local roleId = role:getProperty("id")
    local capsuleId = msg.capsule_id --如果刷新则需要传递当前扭蛋机id
    local typ = msg.typ or 1

    local ret = {}
    if typ == 1 then
        ret = skynet.call(agent.capsule_serv, "lua", "exit", roleId, capsuleId)
    elseif typ == 0 then
        ret = role:exitCapsule()
    end

    SendPacket(actionCodes.Capsule_exitRpc, MsgPack.pack(ret))
    return true
end

function _M.registerRpc(agent, data)
    local role = agent.role
    local msg = MsgPack.unpack(data)
    local roleId = role:getProperty("id")
    local capsuleId = msg.capsule_id

    local ret = skynet.call(agent.capsule_serv, "lua", "register", roleId, capsuleId)
    if not ret then return 1 end
    SendPacket(actionCodes.Capsule_registerRpc, MsgPack.pack(ret))
    return true
end

function _M.drawRpc(agent, data)
    local role = agent.role
    local msg = MsgPack.unpack(data)
    local roleId = role:getProperty("id")
    local capsuleId = msg.capsule_id
    local typ = msg.typ --0=独享，1= 公开
    local full = msg.full or 0-- 0=单次，1=十连抽 2=全收
    local cares = msg.cares

    local ret, token,  change, drawReward, capsule

    --检查库存
    if typ == 1 then
        ret, token = skynet.call(agent.capsule_serv, "lua", "goods_stock", capsuleId)
    else
        ret, token = role:goodStock(capsuleId)
    end
    if ret == 0 then skynet.error("零库存 " .. capsuleId) return 0 end

    --检查余额
    if not next(token) then skynet.error("代币未配置 " .. capsuleId) return 1 end
    local cost, drawsNum = {}, 0
    if full == 0 then
        drawsNum = 1
    elseif full == 1 then
        if ret < 10 then
            drawsNum = ret
        else
            drawsNum = 10
        end
    elseif full == 2 then
        drawsNum = ret
    end
    cost[token[1]] = drawsNum * token[2]

    if not role:checkItemEnough(cost) then return 2 end
    role:costItems(cost, {log = {desc = "CapsuleCoinCost", int1 = token[1], int2 = cost[token[1]]}})

    --开始抽奖
    if typ == 1 then
        ret, drawReward, capsule = skynet.call(agent.capsule_serv, "lua", "draw_capsule", roleId, capsuleId, full, cares)
    else
        ret, drawReward, capsule = role:drawCapsule(capsuleId, full, cares)
    end
    if ret < 5 then
        return ret
    end

    if ret == 5 then
        SendPacket(actionCodes.Capsule_drawRpc, MsgPack.pack({change = drawReward, capsule = capsule}))
        return true
    end

    if drawReward["reward"] and next(drawReward["reward"]) then
        _, change = role:award(drawReward["reward"], {log = {desc = "CapsuleReward", int1 = tonumber(capsuleId), int2 = roleId}})
        drawReward["capsule"] = capsule
        SendPacket(actionCodes.Capsule_drawRpc, MsgPack.pack(drawReward))
    else
        return ret
    end
    return true
end

function _M.getDataRpc(agent, data)
    local role = agent.role
    local msg = MsgPack.unpack(data)
    local capsuleId = msg.capsule_id
    local typ = msg.typ --0=独享，1= 公开
    local roleId = role:getProperty("id")

    local capsule
    if typ == 1 then
        capsule = skynet.call(agent.capsule_serv, "lua", "capsule_data", roleId,  capsuleId)
    else
        capsule = role:getCapsuleData(roleId, capsuleId)
    end
    if not capsule then return 1 end

    SendPacket(actionCodes.Capsule_getDataRpc, MsgPack.pack({capsule = capsule}))
    return true

end

function _M.convertCapsuleRpc(agent, data)
    local role = agent.role
    local msg = MsgPack.unpack(data)
    local coin = msg.coin
    local count = msg.count or 1

    local cost, convert = {}
    for k, v in pairs(globalCsv.ichibankuji_buy_cost)do
        if k == coin then
            convert = v:toArray(true, "=")
            break
        end
    end
    cost[convert[1]] = convert[2] * count
    if not role:checkItemEnough(cost) then return 1 end
    role:costItems(cost, {log = {desc = "CapsuleConvert", int1 = convert[1], int2 = cost[convert[1]]}})


    local reward, change = role:award({[coin]= count}, {log = {desc = "CapsuleConvert"}})
    SendPacket(actionCodes.Capsule_convertCapsuleRpc, MsgPack.pack(role:packReward(reward, change)))
    return true
end

function _M.pageRecordRpc(agent, data)
    local role = agent.role
    local msg = MsgPack.unpack(data)
    local idx = msg.idx
    local up = msg.up or 0
    local capsuleId = msg.capsule_id
    local typ = msg.typ --0=独享，1= 公开

    local record
    if typ == 1 then
        record = skynet.call(agent.capsule_serv, "lua", "page_record", capsuleId, up, idx)
    else
        record = role:pageRecord(capsuleId, up, idx)
    end
    if not record then return 1 end

    SendPacket(actionCodes.Capsule_pageRecordRpc, MsgPack.pack({record = record}))
    return true
end

function _M.specialRewardRpc(agent, data)
    local role = agent.role
    local msg = MsgPack.unpack(data)
    local capsuleId = msg.capsule_id
    local typ = msg.typ or 1 --0=独享，1= 公开
    local roleId = role:getProperty("id")

    local ret
    if typ == 1 then
        ret = skynet.call(agent.capsule_serv, "lua", "get_special_nty", roleId, capsuleId)
    else
        ret = role:getSpecialNotify(roleId, capsuleId)
    end
    if not ret or not next(ret) then return 1 end

    SendPacket(actionCodes.Capsule_specialRewardRpc, MsgPack.pack({special= ret}))
    return true
end

function _M.clearSpecialNtyRpc(agent, data)
    local role = agent.role
    local msg = MsgPack.unpack(data)
    local capsuleId = msg.capsule_id
    local typ = msg.typ --0=独享，1= 公开
    local good_ids = msg.good_ids
    local roleId = role:getProperty("id")

    local ret
    if typ == 1 then
        ret = skynet.call(agent.capsule_serv, "lua", "clear_special_nty", roleId, capsuleId, good_ids)
    end
    if not ret or not next(ret) then return 1 end

    SendPacket(actionCodes.Capsule_clearSpecialNtyRpc, MsgPack.pack({}))
    return true
end

return _M