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 table_insert = table.insert
local tconcat = table.concat
local httpc = require("http.httpc")

local WAVE_HERO_NUMS = 150
local WAVE_RUNE_NUMS = 150

local function validName(name)
	name = string.upper(name)
	local exist = redisproxy:exists(string_format("user:%s", name))
	if exist then return "existed" end

	local SERV = string_format("NAMED%d", math.random(1, 5))
	local legal = skynet.call(SERV, "lua", "check", name)
	return legal and "ok" or "illegal"
end

-- 随机玩家名
local function randomRoleName()
	-- 过滤已经存在的名字
	local name
	repeat
		name = getRandomName()
	until validName(name) == "ok"
	return name
end

local function setRoleName(uid, roleId)
	local result
	local name
	local dbName
	repeat
		name = randomRoleName()
		dbName = string.upper(name)
		result = redisproxy:setnx(string_format("user:%s", dbName), roleId)
	until result == 1
	redisproxy:set(string_format("uid:%s", uid), dbName)
	return name
end

local _M = {}
function _M.loginRpc( agent, data )
	local msg = MsgPack.unpack(data)
	local response = {}
	-- if msg.version ~= globalCsv.version then
	-- 	response.result = "UPDATE_TIP"
	-- 	SendPacket(actionCodes.Role_loginRpc, MsgPack.pack(response))
	-- 	return true
	-- end

	-- 1.
	local roleId = redisproxy:get(string_format("user:%s", string.upper(msg.name)))
	if not roleId then
		response.result = "NOT_EXIST"
		SendPacket(actionCodes.Role_loginRpc, MsgPack.pack(response))
		return true
	end

	roleId = tonumber(roleId)

	--维护不能登录
	local maintain = tonumber(redisproxy:hget("autoincrement_set", "maintain"))
	if maintain and maintain > 0 then
		if tonumber(redisproxy:hget(string_format("role:%d", roleId), "ignoreMt")) ~= 1 then
			response.result = "MAINTAIN_TIP"
			SendPacket(actionCodes.Role_loginRpc, MsgPack.pack(response))
			return true
		end
	end

	local now = skynet.timex()
	local role = agent.role
	-- 2
	if not role then
		local roleKey = string_format("role:%d", roleId)
		if not redisproxy:exists(roleKey) then
			response.result = "DB_ERROR"
			SendPacket(actionCodes.Role_loginRpc, MsgPack.pack(response))
			return true
		end
		-- 2a
		role = require("models.Role").new({key = roleKey})
		role:load()
		role:loadAll()
	else
		role:reloadWhenLogin()
	end

	if not msg.isGMlogin then
		local banTime = role:getProperty("banTime")
		if banTime > now then
			response.result = "BAN_TIP"
			response.banTime = banTime
			response.banType = role:getProperty("banType")
			response.roleId = roleId
			SendPacket(actionCodes.Role_loginRpc, MsgPack.pack(response))
			return true
		end
		if banTime ~= 0 then
			-- 清除封号状态
			role:setBan(0)
		end
	end
	SERV_OPEN = redisproxy:hget("autoincrement_set", "server_start")

	role:changeStructVersion() -- 数据结构 版本更新
	role:advEndlessSeasonCheck() -- 冒险赛季更新检查

	-- 跨天登陆事件
	role:onCrossDay(now)
	role:onResetRank(now)
	role:setProperty("ltime", now)
	redisproxy:zadd(FRIEND_RECOMMEND, now, roleId)

	for _, name in ipairs({"dailyData", "dinerData"}) do
		response[name] = role[name]:data()
	end

	response.role = role:data()
	response.result = "SUCCESS"
	response.serverTime = now

	local modules = {}

	local heroIds = {}
	for heroId, _ in pairs(role.heros) do
		table.insert(heroIds, heroId)
	end
	local heroWave = math.ceil(#heroIds / WAVE_HERO_NUMS)
	if #heroIds <= 50 then
		heroWave = 0
		table_insert(modules, "heros")
	end

	local runeIds = {}
	for id ,_ in pairs(role.runeBag) do
		table.insert(runeIds, id)
	end 
	local runeWave = math.ceil(#runeIds / WAVE_RUNE_NUMS)
	if #runeIds <= 50 then
		runeWave = 0
		table_insert(modules, "runeBag")
	end

	for _, name in ipairs(modules) do
		response[name] = {}
		for id, unit in pairs(role[name]) do
			response[name][id] = unit:data()
		end
	end

	response.wave = 1 + heroWave + runeWave + 1

	SendPacket(actionCodes.Role_loginRpc, MsgPack.pack(response))

	local curWave = 1 

	local runeIndex = 1
	for index = curWave + 1, curWave + runeWave do
		local runeResponse = {runeBag = {}}
		for i = runeIndex, runeIndex + WAVE_RUNE_NUMS do
			local runeId = runeIds[i]
			if not runeId then
				break
			end
			local rune = role.runeBag[runeId]
			table.insert(runeResponse.runeBag, rune:data())
			runeIndex = runeIndex + 1
		end
		runeResponse.runeWave = index
		SendPacket(actionCodes.Role_loginRpc, MsgPack.pack(runeResponse))
	end
	curWave = curWave + runeWave

	local heroIndex = 1
	for index = curWave + 1, curWave + heroWave do
		local heroResponse = {heros = {}}
		for i = heroIndex, heroIndex + WAVE_HERO_NUMS do
			local heroId = heroIds[i]
			if not heroId then
				break
			end
			local hero = role.heros[heroId]
			table_insert(heroResponse.heros, hero:data())
			heroIndex = heroIndex + 1
		end
		heroResponse.heroWave = index
		SendPacket(actionCodes.Role_loginRpc, MsgPack.pack(heroResponse))
	end
	curWave = curWave + heroWave

	

	-- 注册全服广播
	if not role._channelIdx then
		local channel = math.randomInt(1, 1)
		role._channelIdx = channel
	end
	if not mcast_util.channel_world() then
		local w_channel = datacenter.get( ("MC_W_CHANNEL" .. role._channelIdx) )
		if w_channel then
			mcast_util.sub_world(w_channel)
		end
	end

	-- 发下缓存的世界消息
	local worldChatResponse = {worldChats = {}}
	local ok, msgs = pcall(skynet.call, 'GLOBALD', "lua", "getWorldMsg", role._channelIdx)
	if not ok then 
		msgs = {} 
	end
	worldChatResponse.worldChats = msgs
	local redret = redisproxy:pipelining(function(red)
		red:lrange(CHAT_OFFLINE:format(roleId), 0, -1)
		red:del(CHAT_OFFLINE:format(roleId))
	end)
	worldChatResponse.p2pChats = redret[1]
	worldChatResponse.chatWave = curWave + 1
	curWave = curWave + 1

	SendPacket(actionCodes.Role_loginRpc, MsgPack.pack(worldChatResponse))

	datacenter.set("agent", roleId, {
		serv = skynet.self(),
		fd = agent.client_fd,
		gate_serv = agent.gate_serv,
	})
	agent.role = role

	start_agent_timer()


	-- 玩家登陆做的一些操作
	role:saveHangTeam()
	role:savePvpCTeam()


	-- role:log("login", { ip = agent.ip, diamond = role:getProperty("diamond"), reDiamond = role:getProperty("reDiamond")})

	return true
end

function _M.createRpc(agent, data)
	local msg = MsgPack.unpack(data)
	local response = {}

	-- 再次检查uid
	local uid = tostring(msg.uid)
	local user = redisproxy:get(string_format("uid:%s", uid))
	if user then
		response.result = "SUCCESS"
		response.roleName = user
		SendPacket(actionCodes.Role_createRpc, MsgPack.pack(response))
		return true
	end

	local roleId = getNextRoleId()
	if not roleId then
		response.result = "DB_FULL"
		SendPacket(actionCodes.Role_createRpc, MsgPack.pack(response))
		return true
	end
	local roleName = setRoleName(msg.uid, roleId)
	local newRole = require("models.Role").new({
		key = string_format("role:%d", roleId),
		id = roleId,
		uid = tostring(msg.uid),
		subId = msg.subId or 0,
		name = roleName,
		uname = msg.uname or "",
		device = tostring(msg.device)
	})

	if newRole:create() then
		--更新USER表
		response.result = "SUCCESS"
		response.roleId = roleId
		response.roleName = string.upper(roleName)
	else
		response.result = "DB_ERROR"
		SendPacket(actionCodes.Role_createRpc, MsgPack.pack(response))
		return true
	end

	-- 欢迎邮件
	-- redisproxy:insertEmail({roleId = roleId, emailId = 1})
	-- redisproxy:insertEmail({roleId = roleId, emailId = 2})

	newRole:log("create", { ip = agent.ip, ucode = ucode})

	SendPacket(actionCodes.Role_createRpc, MsgPack.pack(response))
	return true
end

function _M.syncTimeRpc(agent, data)
	SendPacket(actionCodes.Role_syncTimeRpc, MsgPack.pack({nowTime = skynet.timex()}))
	return true
end

function _M.saleItemRpc(agent, data)
	local role = agent.role
	local msg = MsgPack.unpack(data)
	local backs = msg.backs
	if not backs then return end

	local reward = {}
	local fragCount = 0
	for itemId, count in pairs(backs) do
		if math.illegalNum(count, 1, role:getItemCount(itemId)) then return end
		local itemData = csvdb["itemCsv"][itemId]
		if itemData.sell_effect == "" then return end
		if itemData.type == ItemType.HeroFragment or itemData.type == ItemType.HeroFCommon then
			fragCount = fragCount + count
		end
		local sellEffect = itemData.sell_effect:toArray(true, "=")
		reward[sellEffect[1]] = (reward[sellEffect[1]] or 0) + sellEffect[2] * count
	end	
	
	role:costItems(backs)
	local reward = role:award(reward)
	role:checkTaskEnter("DecoFrag", {count = fragCount})
	SendPacket(actionCodes.Role_saleItemRpc, MsgPack.pack({reward = reward}))
	return true
end

function _M.openItemRpc(agent, data)
	local role = agent.role
	local msg = MsgPack.unpack(data)
	local itemId = msg.itemId
	local count = msg.count
	if math.illegalNum(count, 1, role:getItemCount(itemId)) then return end
	local itemData = csvdb["itemCsv"][itemId]
	if itemData.use_type ~= 2 then return end
	local randomData = csvdb["item_randomCsv"][tonumber(itemData.use_effect)]
	if not randomData or randomData.openTime > 0 then return end

	local reward = randomData.gift:toNumMap()
	for _id, _count in pairs(reward) do
		reward[_id] = _count * count
	end
	if randomData.random_num > 0 and randomData.random_gift ~= "" then
		for i = 1, count do
			local pool = {}
			for _, temp in ipairs(randomData.random_gift:toArray()) do
				table.insert(pool, temp:toArray(true, "="))
			end
			local needCount = math.min(#pool, randomData.random_num)
			for j = 1, needCount do
				local idx = math.randWeight(pool, 3)
				reward[pool[idx][1]] = (reward[pool[idx][1]] or 0) + pool[idx][2]
				table.remove(pool, idx)
			end
		end
	end
	role:costItems({[itemId] = count})
	reward = role:award(reward)

	SendPacket(actionCodes.Role_openItemRpc, MsgPack.pack({reward = reward}))
	return true
end

function _M.openTimeBoxRpc(agent, data)
	local role = agent.role
	local msg = MsgPack.unpack(data)
	local oper = msg.oper  -- 操作 1 - 2
	local slot = msg.slot  -- 位置 1 - 6
	if math.illegalNum(slot, 1, globalCsv.box_timeOpen_maxNum) then return end

	local boxL = role:getProperty("boxL")
	local reward
	if oper == 1 then	-- 打开
		local itemId = msg.itemId
		if role:getItemCount(itemId) < 1 then return end
		local itemData = csvdb["itemCsv"][itemId]
		local randomData = csvdb["item_randomCsv"][itemId]
		if not itemData or not randomData or randomData.openTime <= 0 then return end

		if boxL[slot] then return end
		role:costItems({[itemId] = 1})
		boxL[slot] = {id = itemId, time = skynet.timex() + randomData.openTime}
		
		 -- 上宝石
		local gemId = msg.gem or 0
		local num = randomData[gemId .. "_gem_num"] 
		if num then
			if not role:checkItemEnough({[gemId] = 1}) then return end
			role:costItems({[gemId] = 1})
		end

		boxL[slot].gem = gemId
	elseif oper == 2 then -- 领取
		local quick = msg.quick
		if not boxL[slot] then return end
		if boxL[slot].time > skynet.timex() then -- 没开完
			if not quick then return end
			local cost_pre = globalCsv.box_timeOpen_diamond:toArray(true, "=")
			local costD = math.ceil((boxL[slot].time - skynet.timex()) / (cost_pre[1] * 60)) * cost_pre[2]
			if not role:checkItemEnough({[ItemId.Diamond] = costD}) then return end
			role:costItems({[ItemId.Diamond] = costD})
		end

		local itemData = csvdb["itemCsv"][boxL[slot].id]
		local randomData = csvdb["item_randomCsv"][itemData.id]
		reward = randomData.gift:toNumMap() -- 固定奖励
		-- 随机奖励
		local randomGift = randomData.random_gift
		local randomNum = randomData.random_num
		if boxL[slot].gem ~= 0 then
			randomNum = randomData[boxL[slot].gem .. "_gem_num"]
			randomGift = randomData[boxL[slot].gem .. "_gem_gift"]
		end

		if randomNum > 0 and randomGift and randomGift ~= "" then
			local pool = {}
			for _, temp in ipairs(randomGift:toArray()) do
				table.insert(pool, temp:toArray(true, "="))
			end
			local needCount = math.min(#pool, randomNum)
			for j = 1, needCount do
				local idx = math.randWeight(pool, 3)
				reward[pool[idx][1]] = (reward[pool[idx][1]] or 0) + pool[idx][2]
				table.remove(pool, idx)
			end
		end


		boxL[slot] = nil
		reward = role:award(reward)
		role:checkTaskEnter("OpenBox")
	else
		return
	end

	role:setProperty("boxL") --刷新
	role:changeUpdates({{type = "boxL", field = slot, value = boxL[slot], isOnlyToC = true}}) -- 通知客户端
	SendPacket(actionCodes.Role_openTimeBoxRpc, MsgPack.pack({reward = reward}))
	return true
end

function _M.storyBookRewardRpc(agent, data)
	local role = agent.role
	local msg = MsgPack.unpack(data)
	local storyId = msg.id
	local storyBookData = csvdb["story_bookCsv"][storyId]
	if not storyBookData then return end
	local storyStatus = role:getProperty("storyB")
	if not storyStatus[storyId] or not storyStatus[storyId].s or storyStatus[storyId].s ~= 1 then 
		return 
	end
	-- 获取奖励
	storyStatus[storyId].s = -1
	role:changeUpdates({{ type = "storyB", field = storyId, value = storyStatus[storyId] }})
	local reward = role:award(storyBookData.gift)
	SendPacket(actionCodes.Role_storyBookRewardRpc, MsgPack.pack({reward = reward}))
	return true
end

function _M.unLockStoryBookRpc(agent, data)
	local role = agent.role
	local msg = MsgPack.unpack(data)

	local storyId = msg.id
	local storyBookData = csvdb["story_bookCsv"][storyId]
	if not storyBookData or storyBookData.lockItem == "" then return end -- 不能解锁

	local storyStatus = role:getProperty("storyB")
	if storyStatus[storyId] and storyStatus[storyId].s then return end  --不需要解锁

	local cost = storyBookData.lockItem:toNumMap()
	if not cost or not next(cost) then return end
	if not role:checkItemEnough(cost) then return end  -- 消耗品不足

	role:costItems(cost)

	-- 解锁
	storyStatus[storyId] = storyStatus[storyId] or {}
	table.clear(storyStatus[storyId])
	storyStatus[storyId].s = 1
	role:changeUpdates({{ type = "storyB", field = storyId, value = storyStatus[storyId] }})
	SendPacket(actionCodes.Role_unLockStoryBookRpc, '')
	return true
end

function _M.taskRpc(agent, data)
	local role = agent.role
	local msg = MsgPack.unpack(data)
	local taskType = msg.type -- 1 日常 2 周长
	local taskId = msg.id --任务id
	local roleField = {"dTask", "wTask"}
	if not roleField[taskType] then return 1 end

	local taskData = csvdb["task_loopCsv"][taskType][taskId]
	if not taskData then return 2 end

	local taskStatus = role:getProperty(roleField[taskType])
	local tStatus = taskStatus["t"] or {}

	if (tStatus[taskId] or 0) < taskData.condition1 then
		return 3
	end

	local reward = role:award(taskData.reward)
	local active = (taskStatus["a"] or 0) + taskData.active

	role:changeUpdates({
		{ type = roleField[taskType], field = {"t", taskId}, value = -1 },
		{ type = roleField[taskType], field = "a", value = active}
	})

	SendPacket(actionCodes.Role_taskRpc, MsgPack.pack({reward = reward}))
	return true
end

function _M.taskActiveRpc(agent, data)
	local role = agent.role
	local msg = MsgPack.unpack(data)
	local taskType = msg.type -- 1 日常 2 周长
	local taskId = msg.id --任务id
	local roleField = {"dTask", "wTask"}
	if not roleField[taskType] then return end

	local taskData = csvdb["task_activeCsv"][taskType][taskId]
	if not taskData then return end

	local taskStatus = role:getProperty(roleField[taskType])
	local tStatus = taskStatus["at"] or {}

	if tStatus[taskId] == -1 or (taskStatus["a"] or 0) < taskData.active then
		return
	end

	local reward = role:award(taskData.reward)
	role:changeUpdates({
		{ type = roleField[taskType], field = {"at", taskId}, value = -1 }
	})
	
	SendPacket(actionCodes.Role_taskActiveRpc, MsgPack.pack({reward = reward}))
	return true
end

function _M.achiveRpc(agent, data)
	local role = agent.role
	local msg = MsgPack.unpack(data)
	local taskId = msg.id --任务id

	local achiveTask = csvdb["achievementCsv"][taskId]
	if not achiveTask then return end

	local achiveT = role:getProperty("achiveT")
	local achiveV = role:getProperty("achiveV")

	if achiveV[taskId] then return end

	local curStatus = achiveT[achiveTask.type] or 0
	local maxc = achiveTask.condition1

	if maxc > curStatus then
		return 
	end

	local reward = role:award(achiveTask.reward)

	role:changeUpdates({
		{ type = "achiveV", field = taskId, value = skynet.timex() }
	})
	
	SendPacket(actionCodes.Role_achiveRpc, MsgPack.pack({reward = reward}))
	return true
end

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

	local cmd = msg.cmd
	local content = msg.content

	if not content then return end

	local now = skynet.timex()
	-- 判断禁言
	local result = nil

	local SERV = string_format("CHATED%d", math.random(1, 5))
	local legal, mod = skynet.call(SERV, "lua", "check", content)
	if not legal then
		content = mod or ""
	end

	if content == "" then
		result = -1
	end

	local response = {
		chatType = cmd,
		player = {
			roleId = role:getProperty("id"),
			name = role:getProperty("name"),
			level = role:getProperty("level"),
			headId = role:getProperty("headId"),
		},
		content = content,
		time = now,
	}


	local waitTime = nil
 	local check = {
		-- 世界聊天
		[1] = function ()
			if role:getProperty("silent") > now then  --禁言
				result = 1
				return
			end

			role._worldChatLimit = role._worldChatLimit or {start = 0, count = 0, canSayt = 0}  --第一次开始说话时间  从第一次说话次数  能说话的时间

			if now < role._worldChatLimit.canSayt then
				result = 2
				waitTime = role._worldChatLimit.canSayt - now
				return
			end

			if now - role._worldChatLimit.start >= globalCsv.chat_world_limit.time then
				role._worldChatLimit.start = now
				role._worldChatLimit.count = 1
			else
				role._worldChatLimit.count = role._worldChatLimit.count + 1
				if role._worldChatLimit.count > globalCsv.chat_world_limit.count then
					role._worldChatLimit.count = 0
					role._worldChatLimit.start = 0
					role._worldChatLimit.canSayt = now + globalCsv.chat_world_limit.wait
					result = 2
					waitTime = globalCsv.chat_world_limit.wait
					return
				end
			end
			mcast_util.pub_world(actionCodes.Role_chat, MsgPack.pack(response))
			pcall(skynet.send, 'GLOBALD', "lua", "sendWorldMsg", role._channelIdx, response)
		end,
		-- 私聊
		[2] = function ()
			local objectId = msg.roleId
			response.objId = objectId
			local redret = redisproxy:pipelining(function(red)
				red:exists(string.format("role:%d", objectId))
				red:sismember(FRIEND_BLACK_KEY:format(roleId), objectId)
				red:sismember(FRIEND_BLACK_KEY:format(objectId), roleId)
			end)
			if redret[1] ~= 1 then
				result = 1	
				return
			end
			-- 你把对方拉黑拉黑
			if redret[2] == 1 then
				result = 2
				return
			end
			-- 对方把你拉黑
			local isBlock = redret[3] == 1

			local bin = MsgPack.pack(response)
			if not isBlock then
				redisproxy:pipelining(function(red)
					red:rpush(CHAT_OFFLINE:format(objectId), bin)
					red:ltrim(CHAT_OFFLINE:format(objectId), -200, -1)
				end)
				-- 若在线，实时发送聊天信息
				local agent = datacenter.get("agent", objectId)
				if agent then
					SendPacket(actionCodes.Role_chat, bin, agent.fd)
				end
			end
			SendPacket(actionCodes.Role_chat, bin)
		end,
	}
	if not check[cmd] then return end
	
	if not result then
		check[cmd]()
	end
	SendPacket(actionCodes.Role_chatRpc, MsgPack.pack({result = result, waitTime = waitTime}))
	return true
end

function _M.chatGet(agent, data)
	local role = agent.role
	local roleId = role:getProperty("id")
	redisproxy:del(CHAT_OFFLINE:format(roleId))
	return true
end

return _M