local ipairs = ipairs
  local table = table
  local math = math
  local string = string
  local redisproxy = redisproxy
  local MsgPack = MsgPack
  local string_format = string.format
  local tonumber = tonumber
  local table_insert = table.insert
  local table_unpack = table.unpack
  local table_find = table.find
  local table_nums = table.nums
  local math_random = math.randomInt

  require "utils.MysqlUtil"

  
  local _M = {}
  
  local function formatArray(tb)
  	tb = tb or {}
  	local t = {}
  	for _, objectId in ipairs(tb) do
  		t[tonumber(objectId)] = 1
  	end
  	return t
  end
  

  
  local function addAndCheckApplyLimit(roleId, objId)
  	roleId = tonumber(roleId)
  	local dbKey = FRIEND_APPLY_KEY:format(roleId)
  	local redret = redisproxy:pipelining(function (red)
  		red:zadd(dbKey, skynet.timex(), objId)
  		red:zremrangebyrank(dbKey, 0, -(globalCsv.friendApplyLimit + 1))
  	end)
  end
  
  local function checkBlackLimit(roleId)
  	roleId = tonumber(roleId)
  	local count = redisproxy:scard(FRIEND_BLACK_KEY:format(roleId))
  	return count < globalCsv.friendListLimit
  end
  
  local function getRoleInfo(roleId)
  	local online, info = rpcRole(roleId, "friendSInfo")
  	return online, info
  end
  
  local function getRoleAllInfo(roleId)
  	local online, info = rpcRole(roleId, "friendInfo")
  	return online, info
  end
  
  local function table_merge(tab1, tab2, filter)
  	tab1 = tab1 or {}
  	tab2 = tab2 or {}
  	filter = filter or {}
  	for k_, v_ in pairs(tab2) do
  		if not filter[k_] then
  			tab1[k_] = v_
  		end
  	end
  	return tab1
  end
  
  function _M.searchRpc(agent, data)
  	local role = agent.role
  	local roleId = role:getProperty("id")
  	local msg = MsgPack.unpack(data)
  	local key = msg.key
  
  	if not key then return end
  
  	local objIds = {}
  	local tempId = tonumber(key)
  	if tempId then

  		if roleExists(tempId) then

  			objIds[tempId] = 1
  		end
  	end
  	local tempId = redisproxy:get(string_format("user:%s", string.upper(key)))
  	if tempId then
  		objIds[tonumber(tempId)] = 1
  	end
  	objIds[roleId] = nil --不能有自己
  
  	local searchList = {}
  	for objId, _ in pairs(objIds) do
  		local online, info = getRoleInfo(objId)
  		local redret = redisproxy:pipelining(function (red)

  			red:zscore(FRIEND_APPLY_KEY:format(objId), roleId)
  			red:sismember(FRIEND_BLACK_KEY:format(roleId), objId)
  		end)

  		
  		local isFriend = role.friends[objId] and 1 or nil
  		local hadApply = redret[1] and 1 or nil
  		local inBlack = redret[2] == 1 and 1 or nil

  
  		table.insert(searchList, table_merge({
  			roleId = objId, 
  			online = online, 
  			isFriend = isFriend, 
  			hadApply = hadApply,
  			inBlack = inBlack,
  		}, info, {
  
  		}))
  	end

  	role:mylog("role_action", {desc = "searchFriend"})

  	SendPacket(actionCodes.Friend_searchRpc, MsgPack.pack({searchList = searchList}))
  	return true
  end
  
  
  function _M.applyRpc(agent, data)
  	local role = agent.role
  	local roleId = role:getProperty("id")
  
  	local msg = MsgPack.unpack(data)
  	local objectId = msg.roleId

  	dump(msg)

  
  	if objectId == roleId then
  		return
  	end
  
  	local result = nil
  	local redret = redisproxy:pipelining(function (red)

  		red:zscore(FRIEND_APPLY_KEY:format(objectId), roleId)
  		red:sismember(FRIEND_BLACK_KEY:format(objectId), roleId)
  		red:sismember(FRIEND_BLACK_KEY:format(roleId), objectId)

  	end)

  	dump(redret)

  	-- 玩家id不存在

  	if not result and not roleExists(objectId) then

  		result = 1	
  	end
  
  	-- 已经有这个好友

  	if not result and role.friends[objectId] then

  		result = 2
  	end
  	-- 已经申请

  	if not result and redret[1] then

  		result = 3
  	end
  	-- 对方把你拉黑

  	if not result and redret[2] == 1 then

  		result = 4
  	end
  
  	-- 你把对方拉黑了

  	if not result and redret[3] == 1 then

  		result = 5
  	end
  
  	-- 自己好友已经满

  	if not result and table.numbers(role.friends) >= globalCsv.friendListLimit then

  		result = 6
  	end
  	-- 对方的好友已满

  	if not result and getFriendCount(objectId) >= globalCsv.friendListLimit then

  		result = 7
  	end
  
  	if not result then
  		addAndCheckApplyLimit(objectId, roleId)
  		local myInfo = role:friendSInfo()
  		myInfo.roleId = roleId
  		myInfo.online = true
  		myInfo.hadApply = true

  		role:mylog("role_action", {desc = "addFriend", int1 = 1})
  

  		rpcRole(objectId, "SendPacket", actionCodes.Friend_updateProperty, MsgPack.pack({newApply = 1, info = {myInfo}})) 	-- 通知对方
  	end

  	SendPacket(actionCodes.Friend_applyRpc, MsgPack.pack({result = result}))
  	return true
  end
  
  function _M.applyListRpc(agent, data)
  	local role = agent.role
  	local roleId = role:getProperty("id")
  
  	local applyList = {}
  
  	local friends = redisproxy:zrange(FRIEND_APPLY_KEY:format(roleId), 0, -1)
  	for _ , id in pairs(friends) do
  		id = tonumber(id)
  		local online, info = getRoleInfo(id)
  		table.insert(applyList, table_merge({
  			roleId = id, online = online
  		}, info, {
  
  		}))
  	end
  	SendPacket(actionCodes.Friend_applyListRpc, MsgPack.pack({list = applyList}))
  	return true
  end
  

  local function checkHandleApply(role, objectId, needAddNew) 

  	needAddNew = needAddNew or 0

  	local roleId = role:getProperty("id")

  	local redret = redisproxy:pipelining(function (red)

  		red:sismember(FRIEND_BLACK_KEY:format(objectId), roleId)
  		red:sismember(FRIEND_BLACK_KEY:format(roleId), objectId)
  	end)

  	--自己好友满了

  	if (table.numbers(role.friends) + needAddNew) >= globalCsv.friendListLimit then

  		return 1

  	end
  	-- 对方好友满了

  	if getFriendCount(objectId) >= globalCsv.friendListLimit then

  		return 2

  	end
  	-- 对方把你拉黑

  	if redret[1] == 1 then

  		return 3

  	end
  	-- 你把对方拉黑了

  	if redret[2] == 1 then

  		return 4

  	end

  
  	return nil, redret[1]

  end
  
  function _M.handleApplyRpc(agent, data)
  	local role = agent.role
  	local roleId = role:getProperty("id")
  
  	local msg = MsgPack.unpack(data)
  	local cmd = msg.cmd
  
  	local newTag = MsgPack.pack({ skynet.timex(), 1})
  	local result = nil
  	if cmd == 1 then	--同意
  
  		local objectId = msg.roleId
  
  		if not redisproxy:zscore(FRIEND_APPLY_KEY:format(roleId), objectId) then
  			return
  		end

  		local curCount

  		result, curCount = checkHandleApply(role, objectId)

  
  		if not result then
  			redisproxy:pipelining(function (red)
  				red:ZREM(FRIEND_APPLY_KEY:format(roleId), objectId)
  				red:ZREM(FRIEND_APPLY_KEY:format(objectId), roleId)

  				addFriend(roleId, objectId)

  			end)
  			local myInfo = role:friendSInfo()
  			myInfo.online = true
  			myInfo.roleId = roleId
  			myInfo.isFriend = 1
  			local redret = redisproxy:pipelining(function (red)
  				red:sismember(FRIEND_POINT:format(objectId), roleId)
  				red:sismember(FRIEND_POINT:format(roleId), objectId)
  			end)
  			myInfo.pGet = redret[1] == 1 and 1 or nil
  			rpcRole(objectId, "SendPacket", actionCodes.Friend_updateProperty, MsgPack.pack({newFriend = 1, info = {myInfo}}))	-- 通知对方
  			local online , otherInfo = getRoleInfo(objectId)
  			otherInfo.roleId = objectId
  			otherInfo.online = online
  			otherInfo.isFriend = true
  			otherInfo.pGet = redret[2] == 1 and 1 or nil
  			SendPacket(actionCodes.Friend_updateProperty, MsgPack.pack({newFriend = 1, info = {otherInfo}}))

  			role:log("friend_opt", {
  				friend_opt_type = 100, -- 好友操作类型，见枚举表中 好友操作类型枚举表
  				friend_roleid = objectId, -- 好友账户下的角色id
  				friend_cnt = curCount + 1, -- 操作后好友数量
  			})

  			role:mylog("role_action", {desc = "addFriend", int1 = 1})
  

  		end
  
  	elseif cmd == 0 then	-- 不同意
  		local objectId = msg.roleId
  		if not redisproxy:zscore(FRIEND_APPLY_KEY:format(roleId), objectId) then
  			return
  		end
  		redisproxy:ZREM(FRIEND_APPLY_KEY:format(roleId), objectId)
  	elseif cmd == 2 then    -- 一键拒绝
  		redisproxy:del(FRIEND_APPLY_KEY:format(roleId))
  	elseif cmd == 3 then    -- 一键同意
  		local redret = redisproxy:pipelining(function(red)

  			red:zrange(FRIEND_APPLY_KEY:format(roleId), 0, -1)

  			red:SMEMBERS(FRIEND_POINT:format(roleId))
  		end)
  		local allIds = redret[1]
  		local fpoint = formatArray(redret[2])
  		local needAdd = {}
  		local needAddMy = {}
  		local needAddInfo = {}
  		for _, objId in ipairs(allIds) do
  			objId = tonumber(objId)

  			local cr, curCount = checkHandleApply(role, objId, #needAdd)

  			if not cr then 
  				table.insert(needAdd, objId)
  				table.insert(needAddMy, objId)
  				table.insert(needAddMy, newTag)
  				local online, otherInfo = getRoleInfo(objId)
  				otherInfo.online = true
  				otherInfo.roleId = objId
  				otherInfo.isFriend = true
  				otherInfo.pGet = fpoint[objId] and 1 or nil
  				table.insert(needAddInfo, otherInfo)

  
  				role:log("friend_opt", {
  					friend_opt_type = 100, -- 好友操作类型，见枚举表中 好友操作类型枚举表
  					friend_roleid = objId, -- 好友账户下的角色id
  					friend_cnt = curCount + 1, -- 操作后好友数量
  				})

  			end
  		end
  
  		redisproxy:pipelining(function (red)

  			if next(needAdd) then
  				red:ZREM(FRIEND_APPLY_KEY:format(roleId), table_unpack(needAdd))
  				for _, objectId in pairs(needAdd) do
  					red:ZREM(FRIEND_APPLY_KEY:format(objectId), roleId)

  					addFriend(roleId, objectId)

  				end
  			end

  		end)
  		local myInfo = role:friendSInfo()
  		myInfo.roleId = roleId
  		myInfo.online = true
  		myInfo.isFriend = 1
  		local giveFP = role.dailyData:getProperty("giveFP")
  		for _, objectId in pairs(needAdd) do
  			myInfo.pGet = giveFP[objectId]
  			rpcRole(objectId, "SendPacket", actionCodes.Friend_updateProperty, MsgPack.pack({newFriend = 1, info = {myInfo}}))	-- 通知对方
  		end
  		if next(needAdd) then

  			role:mylog("role_action", {desc = "addFriend", int1 = #needAdd})
  

  			SendPacket(actionCodes.Friend_updateProperty, MsgPack.pack({newFriend = 1, info = needAddInfo}))
  		else
  			result = 1
  		end
  		
  	else 	--不存在
  		return
  	end
  
  	SendPacket(actionCodes.Friend_handleApplyRpc, MsgPack.pack({result = result}))
  	return true
  end
  
  function _M.listRpc(agent, data)
  	local role = agent.role
  	local roleId = role:getProperty("id")
  
  	local friendList = {}
  	local redret = redisproxy:pipelining(function (red)

  		red:SMEMBERS(FRIEND_POINT:format(roleId))
  	end)
  

  	local fpoint = formatArray(redret[1])

  	local hadGet = role.dailyData:getProperty("getFP")
  	local hadGive = role.dailyData:getProperty("giveFP")
  

  	local addNew = false 
  	for id, friend in pairs(role.friends) do

  		local online, info = getRoleInfo(id)
  		local roleInfo = {
  			roleId = id, 
  			online = online, 

  			addTime = friend:getProperty("addTime"), 
  			isNew = friend:getProperty("isNew"),

  			pGive = hadGive[id],
  			pGet = hadGet[id] and -1 or (fpoint[id] and 1 or nil)
  		}
  		roleInfo = table_merge(roleInfo, info, {})
  
  		friendList[#friendList + 1] = roleInfo
  

  		if roleInfo.isNew then
  			friend:setProperty("isNew", 0)	
  			addNew = true

  		end
  	end

  	if addNew then

  		role:checkTaskEnter("AddFriend", {count = #friendList})

  	end
  
  	SendPacket(actionCodes.Friend_listRpc, MsgPack.pack({list = friendList}))
  	return true
  end
  
  function _M.deleteRpc(agent, data)
  	local role = agent.role
  	local roleId = role:getProperty("id")
  	local msg = MsgPack.unpack(data)
  	local objectId = msg.roleId

  	if not roleExists(objectId) then

  		return
  	end
  	-- 是否在好友列表中

  	if role.friends[objectId] then
  		role.friends[objectId] = nil

  		redisproxy:pipelining(function (red)

  			delFriend(roleId, objectId)

  			red:ZREM(FRIEND_APPLY_KEY:format(roleId), objectId)
  			red:ZREM(FRIEND_APPLY_KEY:format(objectId), roleId)
  		end)
  	end
  	rpcRole(objectId, "SendPacket", actionCodes.Friend_updateProperty, MsgPack.pack({deleteFriend = 1, roleId = roleId}))
  

  	role:log("friend_opt", {
  		friend_opt_type = 200, -- 好友操作类型，见枚举表中 好友操作类型枚举表
  		friend_roleid = objectId, -- 好友账户下的角色id
  		friend_cnt = 0, -- 操作后好友数量
  	})

  	SendPacket(actionCodes.Friend_deleteRpc, MsgPack.pack(""))
  	return true
  end
  
  function _M.blockRpc(agent, data)
  	local role = agent.role
  	local roleId = role:getProperty("id")
  	local msg = MsgPack.unpack(data)
  	local cmd = msg.cmd
  	local objectId = msg.roleId

  	if not roleExists(objectId) then

  		return
  	end
  
  	local result = nil
  	if cmd == 1 then
  		-- 黑名单满了
  		if not result and not checkBlackLimit(roleId) then 
  			result = 1
  		end
  		-- 删除好友
  		if not result then
  			redisproxy:pipelining(function (red)

  				delFriend(roleId, objectId)

  				red:ZREM(FRIEND_APPLY_KEY:format(roleId), objectId)
  				red:ZREM(FRIEND_APPLY_KEY:format(objectId), roleId)

  				red:sadd(FRIEND_BLACK_KEY:format(roleId), objectId)
  			end)

  			rpcRole(objectId, "SendPacket", actionCodes.Friend_updateProperty, MsgPack.pack({deleteFriend = 1, roleId = roleId}))
  			role:log("friend_opt", {
  				friend_opt_type = 300, -- 好友操作类型，见枚举表中 好友操作类型枚举表
  				friend_roleid = objectId, -- 好友账户下的角色id
  				friend_cnt = 0, -- 操作后好友数量
  			})

  		end
  	elseif cmd == 2 then
  		redisproxy:SREM(FRIEND_BLACK_KEY:format(roleId), objectId)
  	else
  		return
  	end

  	SendPacket(actionCodes.Friend_blockRpc, MsgPack.pack({result = result}))
  	return true
  end
  
  function _M.blockListRpc(agent, data)
  	local role = agent.role
  	local roleId = role:getProperty("id")
  
  	local blockList = {}
  
  	local friends = redisproxy:SMEMBERS(FRIEND_BLACK_KEY:format(roleId))
  	for _ , id in pairs(friends) do
  		id = tonumber(id)
  		local online, info = getRoleInfo(id)
  		table.insert(blockList, table_merge({
  			roleId = id, online = online
  		}, info, {
  
  		}))
  	end

  	SendPacket(actionCodes.Friend_blockListRpc, MsgPack.pack({list = blockList}))
  	return true
  end
  
  function _M.infoRpc(agent, data)
  	local role = agent.role
  	local roleId = role:getProperty("id")
  	local msg = MsgPack.unpack(data)
  	local objectId = msg.roleId

  
  	if not roleExists(objectId) then

  		return
  	end
  
  	local online, info = getRoleAllInfo(objectId)
  	local redret = redisproxy:pipelining(function (red)

  		red:zscore(FRIEND_APPLY_KEY:format(objectId), roleId)
  		red:sismember(FRIEND_BLACK_KEY:format(roleId), objectId)
  	end)

  	local isFriend = role.friends[objectId] and 1 or nil
  	local hadApply = redret[1] == 1 and 1 or nil
  	local inBlack = redret[2] == 1 and 1 or nil

  
  	local objInfo = table_merge({
  		roleId = objectId, 
  		online = online, 
  		isFriend = isFriend, 
  		hadApply = hadApply,
  		inBlack = inBlack,
  	}, info, {
  
  	})
  	SendPacket(actionCodes.Friend_infoRpc, MsgPack.pack({info = objInfo}))
  	return true
  end
  
  function _M.pointRpc(agent, data)
  	local role = agent.role
  	local roleId = role:getProperty("id")
  	local msg = MsgPack.unpack(data)
  	local cmd = msg.cmd
  	local result = nil
  	local reward = {}
  	if cmd == 1 then  -- 赠送
  		local objId = msg.roleId
  		local giveP = role.dailyData:getProperty("giveFP")
  		if not result and giveP[objId] then 
  			result = 1
  		end

  		if not result and not role.friends[objId] then

  			result = 2
  		end
  		if not result then
  			redisproxy:sadd(FRIEND_POINT:format(objId), roleId)
  			giveP[objId] = 1
  			role.dailyData:updateProperty({field = "giveFP", value = giveP})

  			role:checkTaskEnter("GiveFriendP", {count = 1})

  			rpcRole(objId, "SendPacket", actionCodes.Friend_updateProperty, MsgPack.pack({newPoint = 1, roleId = roleId}))

  
  			role:mylog("role_action", {desc = "giveFPoint", int1 = 1})

  		end
  	elseif cmd == 2 then -- 领取
  		local objId = msg.roleId
  		local getP = role.dailyData:getProperty("getFP")
  		if not result and table.numbers(getP) >= globalCsv.friendPointLimit then
  			result = 1
  		end
  		if not result and getP[objId] then
  			result = 2
  		end
  		if not redisproxy:sismember(FRIEND_POINT:format(roleId), objId) then
  			result = 3
  		end
  		if not result then
  			getP[objId] = 1

  			reward = role:award({[ItemId.FriendPoint] = 1}, {log = {desc = "friendPoint"}})

  			role.dailyData:updateProperty({field = "getFP", value = getP})

  			role:checkTaskEnter("GetFriendP", {count = 1})

  			role:mylog("role_action", {desc = "getFPoint", int1 = 1})

  		end
  	elseif cmd == 3 then -- 一键赠送领取
  		-- 赠送
  		local giveP = role.dailyData:getProperty("giveFP")

  		local change = 0

  		redisproxy:pipelining(function(red)

  			for objId, friend in pairs(role.friends) do

  				if not giveP[objId] then
  					giveP[objId] = 1

  					change = change + 1

  					red:sadd(FRIEND_POINT:format(objId), roleId)
  					rpcRole(objId, "SendPacket", actionCodes.Friend_updateProperty, MsgPack.pack({newPoint = 1, roleId = roleId}))
  				end
  			end
  		end)

  		if change > 0 then

  			role.dailyData:updateProperty({field = "giveFP", value = giveP})

  			role:checkTaskEnter("GiveFriendP", {count = change})

  			role:mylog("role_action", {desc = "giveFPoint", int1 = change})
  

  		else
  			result = 1
  		end
  		
  		--领取
  		local getP = role.dailyData:getProperty("getFP")
  		local curCount = table.numbers(getP)
  		local getCount = 0
  		if curCount < globalCsv.friendPointLimit then
  			for _, objId in pairs(redisproxy:SMEMBERS(FRIEND_POINT:format(roleId))) do
  				local objId = tonumber(objId)
  				if not getP[objId] then
  					getCount = getCount + 1
  					curCount = curCount + 1
  					getP[objId] = 1
  					if curCount >= globalCsv.friendPointLimit then
  						break
  					end
  				end
  			end
  			if getCount > 0 then

  				reward = role:award({[ItemId.FriendPoint] = getCount}, {log = {desc = "friendPoint"}})

  				role.dailyData:updateProperty({field = "getFP", value = getP})

  				role:checkTaskEnter("GetFriendP", {count = getCount})

  				role:mylog("role_action", {desc = "getFPoint", int1 = getCount})

  			else

  				result = (result or 0) + 2

  			end
  		end
  	else
  		return
  	end
  	SendPacket(actionCodes.Friend_pointRpc, MsgPack.pack({result = result, reward = reward}))
  	return true
  end
  function _M.randomRpc(agent, data)
  	local role = agent.role
  	local roleId = role:getProperty("id")
  
  	local redret = redisproxy:pipelining(function (red)

  		red:zrevrange(FRIEND_RECOMMEND, 0, globalCsv.friendRecommendLimit + globalCsv.friendListLimit + 10) --扩充10个
  		red:SMEMBERS(FRIEND_BLACK_KEY:format(roleId))

  	end)

  	local newList = redret[1]
  	local hadBlack = formatArray(redret[2])

  	local needRoleIds = {}
  	for _, newId in pairs(newList) do
  		local numNewId = tonumber(newId)

  		if numNewId ~= roleId and not role.friends[numNewId] and not hadBlack[numNewId] then

  			table.insert(needRoleIds, numNewId)
  		end
  	end
  
  	local randomRoles = {}

  	local redret = redisproxy:pipelining(function (red)
  		for _, objId in ipairs(needRoleIds) do

  			red:zscore(FRIEND_APPLY_KEY:format(objId), roleId)

  		end
  	end)
  	for idx, objId in ipairs(needRoleIds) do
  		if not redret[idx] then
  			local online, info = getRoleInfo(objId)
  			table.insert(randomRoles, table_merge({
  				roleId = objId, 
  				online = online,  
  				hadApply = hadApply,
  				inBlack = inBlack,
  			}, info, {
  
  			}))
  			if #randomRoles >= globalCsv.friendRecommendLimit then break end
  		end

  	end
  
  	SendPacket(actionCodes.Friend_randomRpc, MsgPack.pack({list = randomRoles}))
  	return true
  end
  

  function _M.battleInfoRpc(agent, data)
  	local role = agent.role
  	local roleId = role:getProperty("id")
  	local msg = MsgPack.unpack(data)
  	local objId = msg.roleId
  	local online, matchInfo = rpcRole(objId, "friendBattleInfo")
  	SendPacket(actionCodes.Friend_battleInfoRpc, MsgPack.pack({matchInfo = matchInfo}))
  	return true
  end
  

  
  return _M