local AzurMediator = {}
local this = AzurMediator
local sConcat = string.concat
local _worldMapTpl = L_GameTpl:getWorldMapTpl()
local _spawnerTpl = L_GameTpl:getWorldSpawnerTpl()
local _worldBorthposTpl = L_GameTpl:getWorldBorthposTpl()
local _adapter = CS.Lens.Gameplay.Modules.Azur.WorldAdapter

function this.onExitGame()
  L_BattleDataManager:dispose()
  L_BattleFieldManager:dispose()
  L_CameraManager:dispose()
  L_MountManager:dispose()
end

function this.getWordsTplData(key)
  return L_WordsTpl:getValue(key)
end

function this.getResPathBySpawnerId(spawnerId)
  return _adapter.GetResPathBySpawnerId(spawnerId)
end

function this.openPageBigMap(id, openMode)
  local worldId = AzurWorldInstance.CurWorldId
  local tpl = _worldMapTpl:getTplById(worldId, id)
  if tpl then
    local _filterMarkTpl = L_GameTpl:getWorldFilterMarkTpl()
    local filterMarkId = _worldMapTpl:getFilterMark(tpl)
    if not math.isEmpty(filterMarkId) then
      local markTpl = _filterMarkTpl:getTplById(filterMarkId)
      local param = _filterMarkTpl:getParam(markTpl)
      L_UI:open("pageBigMap", {openMode = openMode, unLockParam = param})
    end
  end
end

function this.fightStart(fightTable)
  local allObjs = fightTable.enemyPoints
  local allGroups = fightTable.groups
  local triggerBattleObjId = fightTable.objId
  local attactEnemyIndex = fightTable.enemyIndex
  local pos = fightTable.pos
  local ret = L_BattleStore:req_newBattleCreate(allObjs, allGroups, triggerBattleObjId, attactEnemyIndex, pos)
  return nil
end

function this.taskFightStart(fightTable)
  local allObjs = fightTable.enemyPoints
  local allGroups = fightTable.groups
  local triggerBattleObjId = fightTable.objId
  local attactEnemyIndex = fightTable.enemyIndex
  local pos = fightTable.pos
  local taskId = fightTable.taskId
  local ret = L_BattleStore:req_startTaskBattleToData(allObjs, allGroups, taskId, triggerBattleObjId, attactEnemyIndex, pos)
end

function this.setInteractUI(data)
  L_PlayerManager:setInteractUI(data)
end

function this.checkInteractCondition(interactId)
  local interactSystem = L_PlayerManager:getInteractSystem()
  local interData = {}
  interData.interactId = interactId
  local canShow = interactSystem:refreshExternalParam(interData)
  return canShow
end

function this.executeInteractAction(data)
  L_PlayerManager:executeInteractAction(data)
end

function this.changeInteractUIState(data)
  L_InteractiveManager:changeInteractState(data)
end

function this.setTransferPosId(posId, callback)
  local tpl = _worldBorthposTpl:getTplById(posId)
  local sceneId = _worldBorthposTpl:getCityId(tpl)
  local delayCallback = function()
    FrameScheduler.add(function()
      callback()
    end, 5)
  end
  L_SceneStore:transferToPoint(sceneId, posId, nil, delayCallback)
end

function this.showRewards(rewardList, isFly, title, srcId)
  local dataList = {}
  local pageRewardDataList = {}
  for k, v in pairs(rewardList) do
    local itemData = {}
    itemData.itemid = v.itemId
    itemData.itemnum = v.itemNum
    itemData.deadtime = v.deadTime
    itemData.exts = v.exts
    itemData.itemtype = v.itemType
    itemData.varitems = v.varitems
    itemData.guid = v.guid
    itemData.collect = v.collect
    if isFly and itemData.itemtype ~= L_Const.resType.pet and itemData.itemtype ~= L_Const.resType.hero then
      table.insert(dataList, itemData)
    else
      table.insert(pageRewardDataList, itemData)
    end
  end
  if 0 < #pageRewardDataList then
    pageRewardDataList.title = title
    L_RewardManager:showPage(pageRewardDataList, srcId)
  end
  if 0 < #dataList then
    L_FlyMsgManager:showItemServerRewards(dataList)
  end
end

function this.showCommonRewards(rewardList, srcId, title)
  local rewards = require("ui.manager.reward.rewardData").new()
  rewards.title = title
  rewards.src = srcId
  rewards:constructList(rewardList)
  L_RewardManager:ShowReward(rewards, true)
end

function this.playPetCaptureFailedSound(petId)
  Timer.once(0.5, function()
    L_PetStore:playPetVoiceSound(petId, L_PetConst.PetSystemVoiceType.CaptureFail)
  end)
end

function this.registerCallBack(regId, callback)
  L_TaskManager:registerCallBack(regId, callback)
end

function this.unregisterCallBack(regId, callback)
  L_TaskManager:unregisterCallBack(regId, callback)
end

function this.tickTask()
  L_TaskManager:onEventTaskAllExecuteOver()
end

function this.taskOpenPage(pageName, regId, taskId, isOver, pageCall, callback)
  if pageName == "pageTaskBase" then
    if pageCall ~= nil then
      pageCall("pageTaskBase")
    end
    L_FlyMsgManager:showTaskTip(taskId, isOver)
    return
  else
    L_UI:open(pageName)
  end
  if callback ~= nil then
    callback(string.empty)
  end
  L_TaskManager:registerParamCallBack(regId, callback)
end

function this.registerParamCallBack(regId, callback)
  L_TaskManager:registerParamCallBack(regId, callback)
end

function this.unregisterParamCallBack(regId)
  L_TaskManager:unregisterParamCallBack(regId)
end

function this.registerEventCallBack(callBack)
  L_TaskManager:registerEventCallBack(callBack)
end

function this.openTaskPhotoPage(insetData, oriPos, targetPos, callBack)
  L_TaskManager:openTaskPhotoPage(insetData, oriPos, targetPos, callBack)
end

function this.addTaskSubData(taskId, nodeId, subData)
  L_TaskManager:addTaskSubData(taskId, nodeId, subData)
end

function this.completeTaskSubmit(entityId, taskId, nodeId)
  L_TaskManager:completeTaskSubmit(entityId, taskId, nodeId)
end

function this.createInterimBattleData(heroTeam, battleId, configBattle)
  local action
  
  function action(args)
    if args.finishType == C_EBattlerServerFinishType.Win then
      configBattle(true)
      L_BattleDataManager:removeListener(L_BattleDataManager.event.battleFinished, action)
    else
      L_UI:open("pageBattleFailed", {
        callBack = function()
          L_BattleManager:startInterimBattle(heroTeam, battleId)
        end
      })
    end
  end
  
  L_BattleDataManager:addListener(L_BattleDataManager.event.battleFinished, action)
  local status = L_UI:getPageStatus("loading")
  if status and status == "shown" then
    L_LoadingManager:closeLoading()
    Timer.once(0.2, function()
      L_BattleManager:startInterimBattle(heroTeam, battleId)
    end)
    return
  end
  L_BattleManager:startInterimBattle(heroTeam, battleId)
end

function this.checkNpcIsCanCreate(npcId)
  local sceneId = AzurWorldInstance.CurWorldId
  local tpl = L_GameTpl:getWorldMapTpl():getTplById(sceneId, npcId)
  if tpl then
    return true
  else
    return false
  end
end

function this.getCProtoDesc(protoId)
  return MsgGenCode.desc[protoId]
end

function this.pauseInput(isPause)
  L_UIManager:tmpPauseInput(isPause)
end

function this.showTaskBlackDialog(fadeInTime, fadeOutTime, writerInterval, skip, click, messageList, callBack)
  local textData = CS.Azur.Gameplay.UI.PageStoryCommonTextData()
  textData.fadeInTime = fadeInTime
  textData.fadeOutTime = fadeOutTime
  textData.showType = 1
  textData.showSkip = skip
  textData.clickNext = click
  textData.writerInterval = writerInterval
  for i, v in pairs(messageList) do
    local data = CS.Azur.Gameplay.UI.PageStoryCommonTextDataMessage()
    data.speaker = v.speaker
    data.content = v.content
    data.duration = v.duration
    textData.messages:Add(data)
  end
  AzurWorld.StoryMgr.pageCommon:ShowDialog(textData)
end

function this.showTaskNarrationDialog(fadeInTime, fadeOutTime, writerInterval, skip, click, messageList, callBack)
  local textData = CS.Azur.Gameplay.UI.PageStoryCommonTextData()
  textData.fadeInTime = fadeInTime
  textData.fadeOutTime = fadeOutTime
  textData.showType = 4
  textData.showSkip = skip
  textData.clickNext = click
  textData.writerInterval = writerInterval
  for i, v in pairs(messageList) do
    local data = CS.Azur.Gameplay.UI.PageStoryCommonTextDataMessage()
    data.speaker = v.speaker
    data.content = v.content
    data.duration = v.duration
    textData.messages:Add(data)
  end
  AzurWorld.StoryMgr.pageCommon:ShowDialog(textData)
end

function this.getPlayerLevel()
  local level, isMax = L_PlayerStore:getLv()
  return level
end

function this.getWorldNowLevel()
  return L_WorldLevelStore:getNowLevel()
end

function this.createMapMark(areaId, worldPos)
  if areaId == 0 then
    areaId = L_AreaStore:getMapAreaId()
  end
  local mapData = L_MapManager:createMapData(areaId)
  local localPos = mapData:worldToLocal(worldPos)
  local strPos = localPos and string.format("%s,%s,%s", localPos.x, localPos.y, 0)
  local data = {
    map_id = areaId,
    mark_id = 1,
    pos = strPos,
    notes = "111",
    guid = 0,
    pos_x = worldPos.x,
    pos_y = worldPos.y,
    pos_z = worldPos.z
  }
  L_MapStore:req_worldMapMarkAdd(data, function(rspData)
    L_MapStore:req_worldMapMarkTracePointSet(rspData.guid)
  end)
end

function this.getPetLevel(guid)
  local petItem = L_PetStore:getPetItem(guid)
  if petItem then
    return petItem.lv
  end
  return 1
end

function this.createKiBoPVEFieldEntityEnd(entity)
  L_KiBoDuelManager:onCreateKiBoPVEFieldEntityEnd(entity)
end

function this.refreshKiBoDuelPet()
  L_KiBoDuelManager:updatePetHealingIcon()
end

function this.kiboDuelEnd(result)
  L_KiBoDuelManager:dealKiBoDuelEnd(result)
end

function this.refreshKiBoSummonFieldStatus(isIn)
  L_KiBoDuelManager:refreshKiBoSummonFieldStatus(isIn)
end

function this.showUIBlackMask(coveredTime, fadeIn, fadeOut, completeClose)
  L_GameUtil.openMask({
    coverdTime = coveredTime,
    fadeIn = fadeIn,
    fadeOut = fadeOut,
    isCompleteClose = completeClose
  })
end

function this.showUIBlackMaskPro(fadeInTime, stayTime, fadeOutTime, forbidInput)
  L_GameUtil.openMask({
    coverdTime = fadeInTime,
    fadeIn = true,
    isCompleteClose = false
  })
  Timer.once(fadeInTime + stayTime, function()
    L_GameUtil.openMask({
      coverdTime = fadeOutTime,
      fadeOut = true,
      isCompleteClose = true
    })
    if forbidInput == false then
      local uiListener = L_UI._auxiliaries.uiListener.cls
      uiListener:controlInputMapLock("pageMask", false)
    end
  end)
  if forbidInput == false then
    local uiListener = L_UI._auxiliaries.uiListener.cls
    uiListener:controlInputMapLock("pageMask", false)
  end
end

function this.switchMount(rideOn, idx)
  return true
end

function this.enableSyncPlayPosition(enable)
  if enable then
    L_PlayerManager:resumeSendOperator()
  else
    L_PlayerManager:shotdownSendOperator()
  end
end

function this.setCSHomeBuildInteract(guid, isPet)
  L_InteractiveManager:setCSHomeBuildInteract(guid, isPet)
  L_HomeManager:setCurrInteractId(isPet and 0 or guid)
end

function this.setProductInfoFromLua(buildGuid, productGuid)
  local ProductStateLua2CS = {
    [L_HomeConst.ProductQueueState.NONE] = CS.Lens.Gameplay.UI.Home.HomeBuildProductState.NONE,
    [L_HomeConst.ProductQueueState.WAITING] = CS.Lens.Gameplay.UI.Home.HomeBuildProductState.WAITNIG,
    [L_HomeConst.ProductQueueState.PAUSE] = CS.Lens.Gameplay.UI.Home.HomeBuildProductState.PAUSE,
    [L_HomeConst.ProductQueueState.RUNNING] = CS.Lens.Gameplay.UI.Home.HomeBuildProductState.RUNNING,
    [L_HomeConst.ProductQueueState.FINISH] = CS.Lens.Gameplay.UI.Home.HomeBuildProductState.FINISH
  }
  local state = L_ProductManager:getProductState(buildGuid, productGuid)
  local product = L_ProductManager:getProductByGuid(buildGuid, productGuid)
  local onceTime, iconPath, img_iconFilter
  if L_HomeUtil.getBuildingType(buildGuid) == L_Const.WorldMapBuildType.WMBT_HATCH then
    local special = L_ProductManager:getProductSpecialParams(buildGuid, productGuid)
    local petEggData = L_PetStore:getPetEggItem(special.extra_guid)
    local petEggConf = L_ItemTplManager:getPetEggItem(petEggData.configId, special.extra_guid)
    iconPath = petEggConf.icon
    onceTime = L_PetStore:getEggIncubationTime(L_PetStore:getPetEggItem(special.extra_guid).configId, buildGuid)
  else
    onceTime = L_ProductManager:getProduceOnceTime(buildGuid, product.product_id)
    local itemData = L_ProductManager:getProductRewardItemData(product.product_id)
    local item = L_ItemTplManager:getItemConfig(itemData.itemType, itemData.itemId)
    local commonItemTpl = L_GameTpl:getCommonItemTpl():getTplById(itemData.itemId)
    img_iconFilter = commonItemTpl and L_GameTpl:getCommonItemTpl():getFilterIcon(commonItemTpl) or ""
    iconPath = item.icon
  end
  local finishNum, total, amount = L_ProductManager:getProductProduceInfo(buildGuid, product)
  local CSTemp = CS.Lens.Gameplay.UI.Home.TempHomeBuildDataFromLua
  CSTemp.state = ProductStateLua2CS[state]
  CSTemp.onceTime = onceTime
  CSTemp.finishCount = finishNum
  CSTemp.restCount = total - finishNum
  CSTemp.amount = amount
  CSTemp.iconPath = iconPath
  CSTemp.filterIconPath = img_iconFilter
end

function this.getPetSatiety(petGuid)
  return L_SatietyStore:getPetSatiety(petGuid)
end

function this.canBuildUpgrade(buildGuid)
  return L_HomeUtil.canBuildUpgrade(buildGuid)
end

function this.getProductByPet(petGuid, buildGuid, queueGuid, callback)
  L_ProductManager:reqCollectProductByPet(petGuid, buildGuid, queueGuid, callback)
end

function this.showRewardMsg(itemType, itemId, itemNum)
  L_FlyMsgManager:showCommonRewardMsg(itemType, itemId, itemNum)
end

function this.showGetEgg(itemId)
  L_UI:open("pageGetPetEgg", {configId = itemId})
end

function this.showUIStoryDialog(showType, content, duration)
  local message = CS.Azur.Gameplay.UI.PageStoryCommonTextDataMessage()
  message.speaker = ""
  message.content = content
  message.duration = duration
  local textData = CS.Azur.Gameplay.UI.PageStoryCommonTextData()
  textData.fadeInTime = 0.1
  textData.fadeOutTime = 0.1
  textData.showType = showType
  textData.showSkip = true
  textData.clickNext = false
  textData.writerInterval = 0.02
  textData.messages:Add(message)
  AzurWorld.StoryMgr.pageCommon:ShowDialog(textData)
end

function this.convertPos2MapAreaId(pos)
  return L_AreaStore:queryAreaId(pos)
end

function this.showFlyMsg(msgStr, isWordsKey, param1)
  if isWordsKey then
    msgStr = L_WordsTpl:getValue(msgStr)
    if param1 then
      msgStr = string.format(msgStr, param1)
    end
  end
  L_FlyMsgManager:showNormalMsg(msgStr)
end

function this.doOneRewardDropEnd(guid, itemid, itemnum, itemtype)
  local entity
  if itemtype == L_Const.resType.petEgg then
    entity = L_PetStore:getPetEggItem(guid)
    if entity then
      L_UI:open("pageGetPetEgg", {
        configId = entity.configId
      })
    end
  elseif itemtype == L_Const.resType.pet then
    entity = L_PetStore:getPetItem(guid)
    if entity then
      local options = {pet = entity}
      L_PetManager:commonGetPet(options)
    end
  else
    local rewards = require("ui.manager.reward.rewardData").new()
    rewards:constructOne(guid, itemid, itemnum, itemtype)
    L_RewardManager:ShowReward(rewards, true)
    local parse = L_ItemManager:parseItem(itemtype, itemid)
  end
end

function this.checkObjDiscovered(mapId, guid)
  return L_MapStore:checkObjDiscovered(mapId, guid)
end

function this.checkCollectionToolTrigger(isIn, toolType)
  L_CollectionToolStore:call(L_CollectionToolStore.event.triggerCollect, isIn, toolType)
end

function this.checkCollectionToolBtnShow(isShow, toolType)
  L_CollectionToolStore:call(L_CollectionToolStore.event.collectTriggerBtnChange, isShow, toolType)
end

function this.notifyPlayerCollectAction(isBegin)
  printf("notifyPlayerCollectAction %s", isBegin)
  L_CollectionToolStore:call(L_CollectionToolStore.event.collectStatusChange, isBegin)
end

function this.isBlockBattleByUI()
  for _, pageType in pairs(L_UI.groupKeys) do
    local pages = L_UI:getAllPages(pageType)
    for _, page in pairs(pages) do
      if L_UI:checkPageOpen(page.pageName) then
        local pageConfig = L_UI:getPageConfig(page.pageName)
        if pageConfig.blockBattle then
          return true
        end
      end
    end
  end
  return false
end

function this.sendSyncHeroServerDataList()
  L_HeroStore:call(L_HeroStore.event.heroSync)
end

function this.sendSyncHeroCharData()
  L_HeroStore:call(L_HeroStore.event.heroDataSync)
end

function this.heroMarkNew(heroGuid)
  L_ReddotManager:markNew(L_ReddotManager.DotDef.HeroNew, heroGuid)
end

function this.heroLevelUp(heroGuid)
  L_BattleDataManager:setLevelSettleData(L_Const.roleType.hero, heroGuid, "levelUp")
end

function this.heroFavorLevelUp(heroGuid)
  L_BattleDataManager:setLevelSettleData(L_Const.roleType.hero, heroGuid, "favorLevelUp")
end

function this.getIcon(itemType, itemId)
  return L_ItemTplManager:getItemConfig(itemType, itemId).icon
end

function this.getUIIsClosed(pageName)
  local status = L_UI:getPageStatus(pageName)
  if not status or status == L_UI.pageEvent.closed or status == L_UI.pageEvent.hided then
    return true
  end
  return false
end

function this.checkCanCatchPet()
  return L_PetManager:judgeCanCatchPet()
end

function this.checkCanScanPet()
  return L_PetManager:judgeCanScanPet()
end

function this.checkShowScanPet()
  return L_PetManager:judgeShowScanPet()
end

function this.OpenKiboDuelUI()
  L_KiBoDuelSceneMgr:OpenKiboDuelUI()
end

function this.StartKiboDuel()
  L_KiBoDuelSceneMgr:StartKiboDuel()
end

function this.ExitKiboDuel()
  L_KiBoDuelSceneMgr:ExitKiboDuel()
end

function this.StartKiboDuelCountDown()
  local page = L_UI:getPage("pagePetDuel")
  if page then
    page:startOpenCountDown()
  end
end

function this.HideKiboDuelPage()
  local page = L_UI:getPage("pagePetDuel")
  if page then
    page:hideBoard()
  end
end

function this.getIsGuideComplete(id, flag)
  return L_GuideStore:isGuideComplete(id, flag)
end

function this.getIsLocalGuideComplete(id)
  return L_GuideManager:isLocalGuideCompleted(id)
end

function this.bindCameraPoint(pos, rot)
  L_CameraManager:bindPoint(pos, rot)
end

function this.bindCameraEntity()
  local main = L_PlayerManager:getMainControlEntity()
  L_CameraManager:bindEntity(main, true)
  C_CameraManager.GetMainCameraBrain():ManualUpdate()
end

function this.openPhotoPlayable(playableObjectList, cameraAngleList, cameraOffsetList, targetPos, distanceLimit, go)
  local objList = {}
  for i, v in pairs(playableObjectList) do
    table.insert(objList, v)
  end
  local angleList = {}
  for i, v in pairs(cameraAngleList) do
    table.insert(angleList, v)
  end
  local offsetList = {}
  for i, v in pairs(cameraOffsetList) do
    table.insert(offsetList, v)
  end
  L_UI:open("pagePhotographPlayable", {
    playableObjectList = objList,
    cameraAngleList = angleList,
    cameraOffsetList = offsetList,
    targetPos = targetPos,
    distanceLimit = distanceLimit,
    targetGo = go,
    isSearchTarget = true
  })
end

function this.checkConditionIsComplete(conditionString, isGroup)
  local getSingleConditionData = function(singleConditionStr)
    local singleConditon = string.split(singleConditionStr, "#")
    local conditionType = tonumber(singleConditon[1])
    local conditionLimit = tonumber(singleConditon[2])
    local codData = {}
    table.insert(codData, conditionType)
    table.insert(codData, conditionLimit)
    return codData
  end
  if isGroup then
    local conditionDataGroup = {}
    local singleConditionStrList = string.split(conditionString, "|")
    for _, singleConditionStr in pairs(singleConditionStrList) do
      local singleConditionData = getSingleConditionData(singleConditionStr)
      table.insert(conditionDataGroup, singleConditionData)
    end
    return L_ConditionManager:isComplete(conditionDataGroup)
  else
    local conditionData = getSingleConditionData(conditionString)
    return L_ConditionManager:singleIsComplete(conditionData)
  end
end

function this.setStoryProxy()
  CS.Lens.Gameplay.Modules.BigWorld.Macro.IsBattleSimulator = true
  L_PlayerManager:getPlayerUnit():removeSystem(L_EcsConst.systemType.operatorSend)
  local sexType = CS.Azur.Gameplay.EditorTool.StorySimulator.StorySimulator.GetPlayerSexType()
  local baseInfo = L_PlayerStore:getPlayerInfo().baseInfo
  baseInfo.sex = sexType
end

function this.generateWorldTarget(data)
  L_WorldChallengeManager:generateChallengePoint(data)
end

function this.disposeWorldTarget(data)
  L_WorldChallengeManager:disposeChallengePoint(data)
end

function this.ShowItemRepairUI(repairId, title, content, confirmCallback, cancelCallback)
  local repairTpl = L_GameTpl:getCommonWorldRepairTpl()
  local tpl = repairTpl:getTplById(repairId)
  local rewards = repairTpl:getReward(tpl)
  local item = {}
  for _, v in pairs(rewards) do
    local itemType, itemId, ItemNum = v[1], v[2], v[3]
    local hasNum = L_ItemTplManager:getItemNum(itemType, itemId)
    table.insert(item, {
      itemType = v[1],
      itemId = v[2],
      itemNumTxt = string.format("%s/%s", L_GameUtil.fillColor(hasNum, ItemNum > hasNum and L_Const.colorHtml.red001 or L_Const.colorHtml.white001), v[3])
    })
  end
  local tempConfirmCallback = function()
    if L_DataUtil.checkItemEnough(rewards) then
      confirmCallback()
    else
      L_FlyMsgManager:showNormalMsg("\230\157\144\230\150\153\228\184\141\232\182\179")
    end
  end
  title = title or "ui_world_repair_title"
  content = content or "ui_world_repair_desc"
  local data = {
    txtTitle = L_WordsTpl:getValue(title),
    txtContent = L_WordsTpl:getValue(content),
    itemList = item,
    confirmCallback = tempConfirmCallback,
    cancelCallback = cancelCallback
  }
  L_GameUtil.showCommonTip(data)
end

function this.ShowDungeonRewardsUI(rewards, title, content, confirmCallback)
  if rewards == nil then
    printf("\229\137\175\230\156\172", "\229\137\175\230\156\172\229\165\150\229\138\177\228\184\186\231\169\186")
    return
  end
  local item = {}
  for _, v in pairs(rewards) do
    table.insert(item, {
      itemType = v.itemtype,
      itemId = v.itemid,
      itemNumTxt = tostring(v.itemnum)
    })
  end
  local data = {
    txtTitle = title,
    txtContent = content,
    itemList = item,
    confirmCallback = confirmCallback,
    hideCancel = true
  }
  L_GameUtil.showCommonTip(data)
end

table.merge(this, require("modules.world.azurWorld.azurMediator_story"))
_adapter.SetLuaMediator(this)
return AzurMediator
