local skynet = require "skynet"

  require "utils.init"
  
  local redisd_count = tonumber(skynet.getenv("thread"))
  local redisd
  skynet.init(function()
  	local idx = math.randomInt(1, redisd_count)
  	redisd = skynet.localname(".redis" .. idx)
  end)

  
  local table_insert = table.insert
  
  local redisproxy = {}
  

  local isUsePika = false
  
  

  setmetatable(redisproxy, { __index = function(t, k)
  	local cmd = string.upper(k)
  	local f = function (self, ...)
  		local ok, result = pcall(skynet.call, redisd, "lua", cmd, ...)
  		if not ok then
  			skynet.error(cmd, ..., "\n", debug.traceback(coroutine.running(), nil))
  			return
  		end
  		return result
  	end
  	t[k] = f
  	return f
  end})
  
  function redisproxy:runScripts(name, ...)
  	local RedisScripts = require("rdsscripts/RedisScripts")
  
  	if not RedisScripts[name].sha1 then
  		local content = io.readfile(RedisScripts[name].file)
  		RedisScripts[name].sha1 = self:script("LOAD", content)
  	end
  
  	-- 不存在脚本(系统问题或者需要刷新脚本)
  	local existScript = self:script("EXISTS", RedisScripts[name].sha1)
  	if existScript[1] == 0 then
  		local content = io.readfile(RedisScripts[name].file)
  		RedisScripts[name].sha1 = self:script("LOAD", content)
  	end
  
  	return self:evalsha(RedisScripts[name].sha1, ...)
  end
  
  local meta = {__index = function (tab, name) return function (_, ...) tab[#tab+1]={name, ...} end end}

  function redisproxy:pipelining(block, transaction)
  	if transaction == nil then transaction = true end  -- 默认具有事务性
  	if isUsePika then transaction = false end
  
  	local ops = setmetatable({}, meta)
  	if transaction then
  		ops[#ops+1]={"multi"}
  	end

  	block(ops)

  	if transaction then
  		if #ops == 1 then return end
  		ops[#ops+1]={"exec"}
  	else
  		if #ops == 0 then return end
  	end
  	return self:pipeline(ops, transaction)
  end
  
  if isUsePika then
  
  function redisproxy:insertEmail(params)
  	local roleId = params.roleId
  	local emailId = params.emailId
  	local createtime = params.createtime or skynet.timex()
  	local contentPms = params.contentPms or {}
  	local rewardPms = params.rewardPms or {}
  	local title = params.title or ""
  	local stitle = params.stitle or ""
  	local content = params.content or ""
  	local attachments = params.attachments or ""
  
  	local id = self:HINCRBY(string.format("role:%d:autoincr", roleId), "email", 1)
  	self:LPUSH(string.format("role:%d:emailIds", roleId), id)
  	local deleteIds = self:LRANGE(string.format("role:%d:emailIds", roleId), EMAIL_LIMIT, -1)
  	self:pipelining(function(red)
  		for _, deleteId in ipairs(deleteIds) do
  			red:DEL(string.format("email:%d:%d", roleId, deleteId))
  		end
  		red:LTRIM(string.format("role:%d:emailIds", roleId), 0, EMAIL_LIMIT - 1)
  		red:HMSET(string.format("email:%d:%d", roleId, id), 
  			"id", tostring(id), 
  			"emailId", emailId,
  			"status", "0", 
  			"createtime", createtime,
  			"contentPms", MsgPack.pack(contentPms), 
  			"rewardPms", MsgPack.pack(rewardPms), 
  			"title", title, 
  			"stitle", stitle, 
  			"content", content, 
  			"attachments", attachments)
  	end)

  end
  

  else
  

  function redisproxy:insertEmail(params)
  	local pms = {
  		roleId = params.roleId,
  		emailId = params.emailId,
  		createtime = params.createtime or skynet.timex(),

  		contentPms = params.contentPms or {},
  		rewardPms = params.rewardPms or {},

  		title = params.title or "",

  		stitle = params.stitle or "",

  		content = params.content or "",
  		attachments = params.attachments or "",
  	}

  	self:runScripts("insertEmail", 10, EMAIL_LIMIT,

  		pms.roleId, pms.emailId, pms.createtime,

  		MsgPack.pack(pms.contentPms), MsgPack.pack(pms.rewardPms), pms.title, pms.stitle, pms.content, pms.attachments)

  	return true
  end
  

  
  end
  

  return redisproxy