local _M = {}
  local tarr2tab = table.array2Table
  
  local function loadEmails(roleId)
  	local emails = {}
  	local rds = string.format(R_EMAIL, roleId)
  	local ids = redisproxy:lrange(rds, 0, EMAIL_LIMIT - 1)
  	local redret = redisproxy:pipelining(function (red)
  		for _, id in ipairs(ids) do
  			red:hgetall(string.format("email:%d:%s", roleId, id))
  		end
  	end)
  	for index, id in ipairs(ids) do
  		local email = require("models.Email").new({key = string.format("email:%d:%s", roleId, id)})
  		if email:load(tarr2tab(redret[index])) then
  			table.insert(emails, email)
  		end
  	end
  	return emails
  end
  
  function _M.listRpc(agent, data)
  	local role = agent.role
  	local roleId = role:getProperty("id")
  	local now = skynet.timex()
  	local result = {}
  	local mid = role:getProperty("sid")
  
  	local globalEmail = redisproxy:hget("autoincrement_set", "email")
  	globalEmail = tonum(globalEmail)
  	local emailSync = role:getProperty("emailSync")
  	if globalEmail > emailSync then
  		role:setProperty("emailSync", globalEmail)
  		emailSync = math.max(emailSync + 1, globalEmail - EMAIL_LIMIT + 1)
  		local result = redisproxy:pipelining(function (red)
  			for id = emailSync, globalEmail do
  				red:hgetall(string.format("globalEmail:%s", id))		
  			end
  		end)
  		local count = 1
  		for _, data in ipairs(result) do
  			local email = tarr2tab(data)
  			if tonum(email.createtime) > role:getProperty("ctime") 
  				and ( not email.mid or tonum(email.mid) == mid ) 
  				and ( not email.endtime or tonum(email.endtime) > now )then
  				local time = email.timestamp and tonum(email.timestamp) or email.createtime
  				redisproxy:insertEmail({
  					roleId = roleId, 
  					emailId = 0,
  					createtime = time,
  					title = email.title, 

  					stitle = email.stitle, 

  					content = email.content, 
  					attachments = email.attachments
  				})

  				role:log("mail_actions", {desc = "get_global", key1 = email.title, key2 = email.attachments})

  			end
  		end
  	end
  
  	local emails = loadEmails(roleId)
  	for _, email in ipairs(emails) do
  		table.insert(result, email:data())
  	end
  

  	SendPacket(actionCodes.Email_listRpc, MsgPack.pack({list = result}))

  	return true
  end
  
  local function getEmailAttachments( email )
  	if email:getProperty("status") == 2 then
  		return ""
  	end
  	local attachments = email:getProperty("attachments")
  	if attachments:len() == 0 then
  		local rewardPms = email:getProperty("rewardPms")
  		local emailData = csvdb["emailCsv"][email:getProperty("emailId")]
  		if emailData then
  			attachments = emailData.attachment:format(table.unpack(rewardPms))
  		end
  	end
  	return attachments
  end
  
  function _M.drawAllAttachRpc(agent, data)
  	local role = agent.role
  	local roleId = role:getProperty("id")
  
  	local reward = {}
  	local ids = {}
  
  	local emails = loadEmails(roleId)
  	redisproxy:pipelining(function (red)
  		for _, email in ipairs(emails) do
  			local attachments = getEmailAttachments(email)
  			if attachments ~= "" then
  				local emailId = email:getProperty("id")
  				local items = role:award(attachments)
  				ids[emailId] = 1
  				red:hset(string.format(R_EMAIL_ITEM, roleId, emailId), "status", 2) 

  				role:log("mail_actions", {desc = "draw_attach", int1 = emailId, key1 = email:getProperty("title"), key2 = attachments})

  
  				for key, v in pairs(items) do
  					reward[key] = (reward[key] or 0) + v
  				end
  			end
  		end
  	end)
  
  	SendPacket(actionCodes.Email_drawAllAttachRpc, MsgPack.pack({ids = ids, reward = reward}))
  	return true
  end
  
  function _M.drawAttachRpc(agent, data)
  	local role = agent.role
  	local roleId = role:getProperty("id")
  	local msg = MsgPack.unpack(data)
  	local id = msg.id
  
  	local rds = string.format(R_EMAIL_ITEM, roleId, id)
  
  	local email = require("models.Email").new({key = rds})
  	if not email:load() then return end
  
  	local attachments = getEmailAttachments(email)
  	if attachments == "" then return end
  
  	local reward = role:award(attachments)
  	redisproxy:hset(rds, "status", 2) 	-- 领取标记
  	SendPacket(actionCodes.Email_drawAttachRpc, MsgPack.pack({reward = reward}))
  

  	role:log("mail_actions", {desc = "draw_attach", int1 = id, key1 = email:getProperty("title"), key2 = attachments})

  	return true
  end
  
  function _M.checkRpc(agent, data)
  	local role = agent.role
  	local roleId = role:getProperty("id")
  
  	local msg = MsgPack.unpack(data)
  	local id = msg.id
  
  	local rds = string.format(R_EMAIL_ITEM, roleId, id)
  	if not redisproxy:exists(rds) then return end
  
  	redisproxy:hset(rds, "status", 1)

  	role:log("mail_actions", {desc = "check_mail", int1 = id})

  
  	SendPacket(actionCodes.Email_checkRpc, '')
  	return true
  end
  
  function _M.delRpc(agent, data)
  	local role = agent.role
  	local roleId = role:getProperty("id")
  
  	local rds = string.format(R_EMAIL, roleId)
  	local ids = redisproxy:lrange(rds, 0, EMAIL_LIMIT - 1)
  	local now = skynet.timex()
  	local result = {}
  	local emailSet = csvdb["emailCsv"]
  
  	redisproxy:pipelining(function (red)
  		for _, id in ipairs(ids) do
  			local emailRds = string.format("email:%d:%s", roleId, id)
  			local email = require("models.Email").new({key = emailRds})
  			if email:load() then
  				local status = email:getProperty("status")
  				local attachments = email:getProperty("attachments")
  				local emailData = emailSet[email:getProperty("emailId")]
  				if emailData and attachments:len() == 0 then
  					attachments = emailData.attachment
  				end
  				if status == 2 or (status == 1 and attachments:len() == 0) then
  					red:lrem(rds, 0, id)
  					red:del(emailRds)
  					result[tonum(id)] = 1
  				end
  			end
  		end
  	end)

  	for delId, _ in ipairs(result) do
  		role:log("mail_actions", {desc = "del_mail", int1 = delId})
  	end

  	SendPacket(actionCodes.Email_delRpc, MsgPack.pack({result = result}))
  	return true
  end
  
  return _M