local ipairs = ipairs
  local table = table
  local math = math
  local redisproxy = redisproxy
  local MsgPack = MsgPack
  
  local _M = {}
  
  function _M.getServerProcessRpc(agent, data)
  	local role = agent.role
  	local result = role:getSeaportServerProgress()
  
  	SendPacket(actionCodes.Seaport_getServerProcessRpc, MsgPack.pack(result))
  	return true
  end
  
  function _M.donateRpc(agent, data)
  	local role = agent.role
  	local msg = MsgPack.unpack(data)
  	
  	local phase = msg.phase or 0
  	local id = msg.id or 0
  	local itemId = msg.itemId or 0
  	local itemCount = msg.count or 0
  
  	if itemId == 0 or itemCount == 0 then return 0 end
  	if role:getItemCount(itemId) < itemCount then return 1 end
  	local DonateCsv = csvdb["seaport_purchaseCsv"]

  	if not DonateCsv[phase] or not DonateCsv[phase][id] then return 2 end

  	local ddata = DonateCsv[phase][id]
  	local needs = ddata.need_item:toArray(true,"=")

  	if itemId ~= needs[1] then return 3 end
  	if itemCount % needs[2] ~= 0 then return 4 end
  
  	local group = itemCount / needs[2]

  	local rewards = ddata.award:toNumMap()

  
  	for id, value in pairs(rewards) do
  		rewards[id] = value * group
  	end
  

  	if phase == 1 then
  		local old = tonumber(redisproxy:hget(SEAPORT_TRADE_TASK_1,id)) or 0
  		local need = ddata.need_num - old
  		if need >= itemCount then
  			redisproxy:hincrby(SEAPORT_TRADE_TASK_1,id,itemCount)
  		else
  			redisproxy:hincrby(SEAPORT_TRADE_TASK_1,id,need)
  			for _, temp in pairs(DonateCsv[2]) do
  				local items = temp.need_item:toArray(true,"=")
  				if items[1] == itemId then
  					redisproxy:hincrby(SEAPORT_TRADE_TASK_2,temp.id,itemCount - need)
  					break
  				end
  			end
  		end
  	else
  		redisproxy:hincrby(SEAPORT_TRADE_TASK_2,id,itemCount)
  	end

  	local seaport = role:getProperty("seaport") or {}
  	if not seaport.join then
  		seaport.join = 1
  		role:updateProperty({field = "seaport", value = seaport})
  	end
  

  	role:costItems({[itemId] = itemCount}, {log = {desc = "seaportDonate", int1 = phase, int2 = id}})

  	local reward, change = role:award(rewards, {log = {desc = "seaportDonate", int1 = ddata.phase, int2 = ddata.id}})

  
  	role:mylog("role_action", {desc = "seaportDonate", int1 = itemId, int2 = itemCount})
  
  	SendPacket(actionCodes.Seaport_donateRpc, MsgPack.pack(role:packReward(reward, change)))
  	return true
  end
  
  function _M.donateRewardRpc(agent, data)
  	local role = agent.role
  	local msg = MsgPack.unpack(data)
  
  	local id = msg.id
  	local dataCsv = csvdb["seaport_purchaseCsv"]
  	if not dataCsv[id] then return 0 end
  
  	local seaport = role:getProperty("seaport") or {}
  	local donate = seaport.donate or {}
  	if donate[id] then return 3 end
  
  	local data = dataCsv[id][1]
  
  	local result = role:getSeaportServerProgress()
  	if not result[id] then return 1 end
  
  	for _, tempData in ipairs(dataCsv[id]) do
  		if tempData.need_num > (result[id][tempData.id] or 0) then
  			return 2
  		end
  	end
  
  	donate[id] = 1
  	seaport.donate = donate
  
  	local reward, change = role:award(data.phase_award, {log = {desc = "seaportReward", int1 = data.phase, int2 = data.id}})
  
  	role:updateProperty({field = "seaport", value = seaport})
  	SendPacket(actionCodes.Seaport_donateRewardRpc, MsgPack.pack(role:packReward(reward, change)))
  	return true
  end
  
  -- 获取英雄大成功率
  local function getHeroCoef(hero, condition)
      -- 基础概率
      local rareMap = {[HeroQuality.N] = 10, [HeroQuality.R] = 10, [HeroQuality.SR] = 15, [HeroQuality.SSR] = 20}
      local rare = hero:getRare()
      local result = 0
      for _, it in ipairs(condition:toTableArray(true)) do
          local type = it[1]
          local value = it[2]
          local add = it[3]
          if type == 1 then   -- 种族加成
              if hero:getCamp() == value then
                  result = result + add
              end
          elseif type == 2 then   -- 定位加成
              if hero:getPosition() == value then
                  result = result + add
              end
          end
      end
  
      return result + (rareMap[rare] or 0)
  end
  
  function _M.taskRpc(agent, data)
  	local role = agent.role
  	local msg = MsgPack.unpack(data)
  
  	local oper = msg.oper or 0
  	local team = msg.team or ""
  	local taskId = msg.id or 0
  	local level = msg.level or 0
  
  	if oper == 0 then return 0 end
  	local TaskCsv = csvdb["seaport_taskCsv"]
  	if not TaskCsv[taskId] or not TaskCsv[taskId][level] then return 1 end
  
  	local reward, change = {}, {}

  	local heroFaithMap = {}

  	local seaport = role:getProperty("seaport")
  
  	local data = TaskCsv[taskId][level]

  	if data.phase == 2 then
  		local openTime = tonumber(redisproxy:hget("autoincrement_set", "seaportTime0")) or 0
  		local nowTime = skynet.timex()
  		if nowTime < (openTime + 86400) or nowTime > (openTime + 172800) then return 9 end
  	end
  

  	if oper == 1 then -- 开始委托
  		if team == "" then return 3 end

  		local conditions = data.condition:toTableArray(true)

  		local heros = team:toArray(true,"=")
  		if not next(heros) then return 8 end

  		local UnitCsv = csvdb["unitCsv"]
  		for _, conds in pairs(conditions) do
  			local count = 0
  			for _, heroId in pairs(heros) do
  				local hero = role.heros[heroId]

  				if not hero then return 8 end

  
  				if conds[1] == 1 then
  					if hero:getProperty("level") >= conds[2] then
  						count = count + 1
  					end
  				elseif conds[1] == 2 then
  					if UnitCsv[hero:getProperty("type")].rare >= conds[2] then
  						count = count + 1
  					end
  				elseif conds[1] == 3 then
  					count = count + 1
  				end
  			end
  			if count < conds[#conds] then
  				return 4
  			end
  		end
  
  		local collect = seaport.collect or {}
  		collect[taskId] = {}
  		collect[taskId].time = skynet.timex()
  		collect[taskId].level = level
  		collect[taskId].team = team
  
  		seaport.collect = collect
  	elseif oper == 2 then -- 领取委托奖励
  		local collects = seaport.collect or {}
  		local collect = collects[taskId] or {}
  		if not next(collects) or not next(collect) then
  			return 5
  		end

  		local quick = msg.quick

  		local endTime = data.time + collect.time

  		local remainT = endTime - skynet.timex()

  		if not quick and remainT > 0 then return 6 end
  
  		if quick and remainT > 0 then
  			local cost = math.ceil(remainT / 3600) * globalCsv.seaport_task_quick

  			if not role:checkItemEnough({[ItemId.Jade] = cost}) then return 8 end
  			role:costItems({[ItemId.Jade] = cost}, {log = {desc = "seaportTask", int1 = taskId, int2 = level}})

  		end

  
  		local carbonCsv = csvdb["idle_battleCsv"]

  		local expData = role:getProperty("hangInfo").expData or {}
  		--if not carbonCsv[expCarbonId] then return 7 end

  
  		local totalCoef = 0

  	    for _, heroId in ipairs(collect.team:toArray(true,"=")) do

  	        local hero = role.heros[heroId]
  	        if hero then
  	            totalCoef = totalCoef + getHeroCoef(hero, data.success)
  	            hero:addHeroFaith(data.trust)

  	            heroFaithMap[heroId] = hero:getProperty("faith")

  	        end
      	end
  
  		local bigSuccess = false
  	    local result = math.randomInt(0, 100)
  	    if result < totalCoef then
  	        bigSuccess = true
  	    end
  

  		local money = math.ceil((expData.money or 0) / 5 * data.time * data.money_clear)
  		local exp = math.ceil((expData.exp or 0) / 5 * data.time * data.exp_clear)

  		local itemReward = data.item_clear_special:toNumMap()
  		itemReward[ItemId.Gold] = (itemReward[ItemId.Gold] or 0) + money
      	itemReward[ItemId.Exp] = (itemReward[ItemId.Exp] or 0) + exp
      
  		if bigSuccess then
  	        for key, value in pairs(itemReward) do
  	            itemReward[key] = math.ceil(1.5 * value)
  	        end
  	    end
  
  	    reward, change = role:award(itemReward, {log = {desc = "seaportTask", int1 = taskId, int2 = level}})
  
  		seaport.collect[taskId] = nil

  
  		role:mylog("role_action", {desc="seaportTask", int1=taskId, int2=level, short1=bigSuccess and 1 or 0})

  	else
  		return 0
  	end
  
  	role:updateProperty({field = "seaport", value = seaport})
  

  	local result = role:packReward(reward, change)
  	result["heroFaith"] = heroFaithMap
  
  	SendPacket(actionCodes.Seaport_taskRpc, MsgPack.pack(result))

  	return true
  end
  
  function _M.shopRpc(agent, data)
  	local role = agent.role
  	local msg = MsgPack.unpack(data)
  	local id = msg.id or 0
  	local count = msg.count or 1
  

  	local shopCsv = {}
  	local dataSet = csvdb["shop_normalCsv"]

  	for _, datat in pairs(dataSet) do

  		if datat.shop == 4 then

  			shopCsv[datat.id] = datat

  		end
  	end

  	local sdata = shopCsv[id]
  	
  	if not sdata then return 2 end

  	local seaport = role:getProperty("seaport")
  	local shop = seaport.shop or {}
  
  	if (shop[id] or 0) >= sdata.limit then return 1 end
  
  	
  
  	

  	if role:getItemCount(sdata.icon) < sdata.cost * count then return 3 end

  	role:costItems({[sdata.icon] = sdata.cost * count}, {log = {desc = "seaportShop", int1 = id, int2 = count}})

  	local itemReward = sdata.gift:toNumMap()

  	for itemId, value in pairs(itemReward) do
  		itemReward[itemId] = value * count
  	end
  
  	local reward, change = role:award(itemReward, {log = {desc = "seaportShop", int1 = id, int2 = count}})
  

  	shop[id] = (shop[id] or 0) + count
  	seaport.shop = shop
  

  	role:updateProperty({field = "seaport", value = seaport})
  
  	SendPacket(actionCodes.Seaport_shopRpc, MsgPack.pack(role:packReward(reward, change)))
  	return true
  end
  
  function _M.resetRpc(agent, data)
  	local role = agent.role
  	role:checkSeaportTrade()
  	SendPacket(actionCodes.Seaport_resetRpc, MsgPack.pack(""))
  	return true
  end
  
  return _M