require "ProtocolCode"
require "shared.init"
require "GlobalVar"
require "RedisKeys"
require "skynet.manager"
skynet = require "skynet"
csvdb = require "shared.csvdata"
redisproxy = require "shared.redisproxy"
datacenter = require "skynet.datacenter"

local capsules = {}
local CMD = {}

NotifyChangeType = {
    JOIN = 1,
    EXIT = 2,
    DRAW = 3,
    SPECIAL = 4,
}

skynet.register_protocol {
    name = "role",
    id = 101,
    pack = skynet.pack,
    unpack = skynet.unpack,
}

local function rpcRole(roleId, funcName, ...)
    local fields = ...
    local agent = datacenter.get("agent", roleId)
    if agent and agent.serv then
        if funcName == "getProperties" then
            return true, skynet.call(agent.serv, "role", funcName, fields)
        else
            return true, skynet.call(agent.serv, "role", funcName, ...)
        end
    else
        local roleCross = require("models.RoleCross")
        if funcName == "getProperties" then
            return false, roleCross.handle(funcName, roleId, fields)
        else
            return false, roleCross.handle(funcName, roleId, ...)
        end
    end
end

function getNameByRoleId(roleId)
    local status, name = rpcRole(roleId, "getProperty", "name")
    return name

end

function broadCastCapsule(roleId, capsuleId, broadInfo)
    local capsule = capsules[capsuleId]
    if not capsule then print("not capsule :" .. capsuleId) return end

    local register = capsule:getProperty("register") or {}
    if next(capsule) then
        for id, _ in pairs(register) do
            if id ~= roleId then
                rpcRole(id, "SendPacket", actionCodes.Capsule_notifyChange, MsgPack.pack(broadInfo)) 	-- 通知对方
            end
        end
    end
end

function broadCastSpecial(roleId, capsuleId, broadInfo)
    if not broadInfo or not next(broadInfo) then return end
    local capsule = capsules[capsuleId]
    if not capsule then skynet.error("not capsule: " .. capsuleId) return end

    local register = capsule:getProperty("register") or {}
    for id, _ in pairs(register) do
        if id ~= roleId then
            if broadInfo[id] then
               rpcRole(id, "paySpecialReward", id, broadInfo[id])
            end
        end
    end
end

local function add(roleId, capsuleId)
    local capsule = capsules[capsuleId]
    if not capsule then skynet.error("add not capsule: " .. capsuleId) return end
    if next(capsule) then
        capsule:join(roleId)
        broadCastCapsule(roleId, capsuleId, {notifyType= NotifyChangeType.JOIN, roleId = roleId})
        return capsule:data(roleId)
    end
    print("id 不存在: ".. capsuleId)
    return nil
end

local function capsuleRefreshing(now)
    for _, v in pairs(capsules) do
        if v:refreshing(now) then
            print("刷新机器looooook....")
            print(v:getProperty("id"))
            print(v:getProperty("room"))
            v:init()
            v:create()
        end
    end
end

--扭蛋机刷新
local function check_capsules()
    local now = skynet.timex()
    pcall(capsuleRefreshing, now)
    skynet.timeout(100, check_capsules)
end

function CMD.reset()
    local now = skynet.timex()
    local res = redisproxy:smembers(CAPSULE_INFO) or {}
    for _, key in pairs(res) do
        redisproxy:del(CAPSULE_PUBLIC:format(key))
        redisproxy:srem(CAPSULE_INFO, key)
    end

    for _, data in pairs(csvdb["ichibankuji_mainCsv"]) do
        for _, val in ipairs(data) do
            if val.type == 1 then
                local key = val.id..val.room
                local capsule = require("models.Capsule").new({ key = CAPSULE_PUBLIC:format(key), id= val.id, room = val.room, typ = 1, name=val.name})
                capsule:init()
                capsule:create()
                capsules[key] = capsule
                redisproxy:sadd(CAPSULE_INFO, key)
            end
        end
    end
end

function CMD.start()
    local now = skynet.timex()
    local res = redisproxy:smembers(CAPSULE_INFO) or {}
    for _, key in pairs(res) do
        local capsule = require("models.Capsule").new({ key = CAPSULE_PUBLIC:format(key)})
        capsule:load()
        if capsule:isShow() then
            if capsule:refreshing(now) then
                capsule:init()
                capsule:create()
            end
            capsules[key] = capsule
        else
            redisproxy:del(CAPSULE_PUBLIC:format(key))
            redisproxy:srem(CAPSULE_INFO, key)
        end
    end

    for _, data in pairs(csvdb["ichibankuji_mainCsv"]) do
        for _, val in ipairs(data) do
            if val.type == 1 then
                local key = val.id..val.room
                if not capsules[key] then
                    if now < val.hide_time then
                        local capsule = require("models.Capsule").new({ key = CAPSULE_PUBLIC:format(key), id= val.id, room = val.room, typ = 1, name=val.name})
                        capsule:init()
                        capsule:create()

                        capsules[key] = capsule
                        redisproxy:sadd(CAPSULE_INFO, key)
                    end
                end
            end
        end
    end

    check_capsules()
end

function CMD.list(id)
    local tmpCapsules = {}
    for k, v in pairs(capsules) do
        if v:getProperty("id") == id then
            local onlineCount= v:getOnlineCount()
            tmpCapsules[k] = {id=v:getProperty("id"), room=v:getProperty("room"), typ=v:getProperty("typ"), people=onlineCount[2], coin= v:getProperty("coin")}
        end
    end
    return tmpCapsules
end

function CMD.join(roleId, capsuleId)
    if capsuleId then
        return add(roleId, capsuleId)
    end
    return nil
end


function CMD.exit(roleId, capsuleId)
    if capsuleId then
        local capsule = capsules[capsuleId]
        if not capsule then skynet.error("not capsule: " .. capsuleId) return end

        capsule:exit(roleId)
        broadCastCapsule(roleId, capsuleId, {notifyType = NotifyChangeType.EXIT, roleId = roleId})
    else
        for id, capsule in pairs(capsules) do
            if next(capsule) then
                capsule:exit(roleId)
                broadCastCapsule(roleId, id, {notifyType = NotifyChangeType.EXIT, roleId = roleId})
            end
        end
    end
end

function CMD.draw_capsule(roleId, capsuleId, full, drawsNum, cares)
    local capsule = capsules[capsuleId]
    if not capsule then skynet.error("not capsule: " .. capsuleId) return 2 end

    local ret, drawReward = capsule:draw(roleId, full, drawsNum, cares)
    if ret > 5 then
        --broadCastCapsule(roleId, capsuleId, {notifyType = NotifyChangeType.DRAW, notify = notify})
        broadCastSpecial(roleId, capsuleId, drawReward["specials"])
    end
    drawReward["specials"] = nil
    return ret, drawReward, capsule:data(roleId)
end

function CMD.register(roleId, capsuleId)
    local capsule = capsules[capsuleId]
    if not capsule then skynet.error("not capsule: " .. capsuleId) return nil end

    return capsule:register(roleId)
end

function CMD.goods_stock(capsuleId)
    local capsule = capsules[capsuleId]
    if not capsule then skynet.error("not capsule: " .. capsuleId) return 0 end

    return capsule:getGoodsAmount(), capsule:getProperty("token")
end

function CMD.capsule_data(roleId, capsuleId)
    local capsule = capsules[capsuleId]
    if not capsule then skynet.error("not capsule: " .. capsuleId) return nil end

    return capsule:data(roleId)
end

function CMD.page_record(capsuleId, up, idx)
    local capsule = capsules[capsuleId]
    if not capsule then skynet.error("not capsule: " .. capsuleId) return nil end

    return capsule:pageRecord(up, idx)
end

function CMD.get_special_nty(roleId, capsuleId)
    local capsule = capsules[capsuleId]
    if not capsule then skynet.error("not capsule: " .. capsuleId) return nil end

    return capsule:getSpecialNotify(roleId)
end

function CMD.clear_special_nty(roleId, capsuleId, good_ids)
    local capsule = capsules[capsuleId]
    if not capsule then skynet.error("not capsule: " .. capsuleId) return nil end

    return capsule:clearSpecialNty(roleId, good_ids)
end

skynet.start(function()
    skynet.dispatch("lua", function(session, address, cmd, ...)
        local f = CMD[string.lower(cmd)]
        skynet.ret(skynet.pack(f(...)))
    end)

    skynet.register("capsuled")
    globalCsv = csvdb["GlobalDefineCsv"]
end)