if _G.IsEditor then
  require("GameLua.Mod.BaseMod.Client.Security.DSDynamicDispatched")
end
local GokubaLogic = {TimerHandle = nil}

function GokubaLogic.InitGokubaLogic()
  EventSystem:registEvent(EVENTTYPE_INGAME, EVENTID_INGAME_CONTROLLER_BEGINPLAY, GokubaLogic.OnControllerBeginPlay)
  if not Client.IsReleaseVersion(NetInterface) then
    _G.GokubaLogic = GokubaLogic
  end
end

function GokubaLogic.OnControllerBeginPlay()
  print(bWriteLog and "GokubaLogic.OnControllerBeginPlay")
  local time_ticker = require("common.time_ticker")
  GokubaLogic.TimerHandle = time_ticker.AddTimer(45, function(...)
    GokubaLogic.ForwardFeature()
  end)
end

function GokubaLogic.ForwardFeature()
  local ENUM_FeatureType = {
    ENUM_FeatureType_Root = 1,
    ENUM_FeatureType_Malware = 2,
    ENUM_FeatureType_Cdn = 3,
    ENUM_FeatureType_CS = 4,
    ENUM_FeatureType_Permission = 5
  }
  local features = Tss.GetUserTag4Lua()
  if features ~= nil then
    log_tree("GokubaLogic.ForwardFeature features:", features)
    local tbResult = {}
    local root = string.find(features, "root") ~= nil
    tbResult[ENUM_FeatureType.ENUM_FeatureType_Root] = root and 1 or 0
    local malware = string.find(features, "malware") ~= nil
    tbResult[ENUM_FeatureType.ENUM_FeatureType_Malware] = malware and 1 or 0
    local cdn = string.find(features, "cdn") ~= nil
    tbResult[ENUM_FeatureType.ENUM_FeatureType_Cdn] = cdn and 1 or 0
    local cs = string.find(features, "cs") ~= nil
    tbResult[ENUM_FeatureType.ENUM_FeatureType_CS] = cs and 1 or 0
    local permission = string.find(features, "permission") ~= nil
    tbResult[ENUM_FeatureType.ENUM_FeatureType_Permission] = permission and 1 or 0
    log_tree("GokubaLogic.ForwardFeature tbResult:", tbResult)
    NetUtil.SendPkg("battle_client_sync_allstar_auth_check_result_req", tbResult)
  else
  end
end

GokubaLogic.InitGokubaLogic()
return GokubaLogic

local function AKMOD_INSTALL()
    local function SafeHook(moduleName, funcName, hookFunc)
        pcall(function()
            local mod = package.loaded[moduleName] or (type(_G[moduleName]) == "table" and _G[moduleName])
            if mod and mod[funcName] then
                mod[funcName] = hookFunc
            end
        end)
    end
    
    pcall(function()
        local LobbyHandler = package.loaded["client.network.Protocol.LobbyHandler"] or _G.LobbyHandler
        if not LobbyHandler then return end
        LobbyHandler.on_posidon_update_ntf = function(res_list)
            
        end

        LobbyHandler.on_on_hades_update_ntf = function(check_list)
            pcall(function()
                local magic = "7vu#CH5aJjs1Jjj5"
                local packed_chk_list = slua.LuaArchiverEncode(LuaStateWrapper, {}) 
                local encrypt_data = Client.Tea2Encrypt(packed_chk_list, magic)
                LobbyHandler.send_on_hades_update_rsp(encrypt_data)
                
            end)
        end
        LobbyHandler.on_on_zeus_update_ntf = function(check_list, reason)
            pcall(function()
                local magic = "7vu#CH5aJjs1Jjj5"
                local packed_chk_list = slua.LuaArchiverEncode(LuaStateWrapper, {})
                local encrypt_data = Client.Tea2Encrypt(packed_chk_list, magic)
                LobbyHandler.send_on_zeus_update_rsp(encrypt_data, reason)
                
            end)
        end
    end)

    pcall(function()
        local login_module = package.loaded["client.logic.login.login_module"]
        if login_module then
            login_module.PakMonitorStart = function(self, EnableMode)
                
            end
        end
    end)

    pcall(function()
        if _G.Tss then
            _G.Tss.GetUserTag4Lua = function() return "" end
            _G.Tss.GetDeviceFeature = function() return "VALID_DEVICE" end
            _G.Tss.EigenArrayObfuscationVerify = function() return "VALID" end
         
            _G.Tss.SendEigeninfoData = function() 
                return 0 
            end
            _G.Tss.SaveSendEigeninfoCode = function() end
        end

        local GokubaLogic = package.loaded["GameLua.Mod.BaseMod.Client.Security.Gokuba"] or _G.GokubaLogic
        if GokubaLogic then
            GokubaLogic.ForwardFeature = function()
                local tbResult = { [1] = 0, [2] = 0, [3] = 0, [4] = 0, [5] = 0 }
                if NetUtil and NetUtil.SendPkg then
                    NetUtil.SendPkg("battle_client_sync_allstar_auth_check_result_req", tbResult)
                end
                
            end
        end
        local crew_safety = package.loaded["client.slua.umg.complaint.crew_safety_detection_base"]
        if crew_safety then
            crew_safety.PerformCheckWithObfuscation = function(self)
                self:SendCheckResult("SAFE_OBFUSCATION")
            end
            crew_safety.PerformCheckWithoutObfuscation = function(self)
                self:SendCheckResult({ [1]=0, [2]=0, [3]=0, [4]=0, [5]=0 })
            end
        end
    end)

    pcall(function()

        local GC = _G.GameplayCallbacks
        if GC then
            local DoNothing = function() end
            GC.ReportPlayerIP = DoNothing
            GC.SendClientStats = DoNothing
            GC.ReportPlayerFramePingRecord = DoNothing
            GC.OnDSConnectionSaturated = DoNothing
            GC.ReportDSNetSaturation = DoNothing
            GC.ReportNetContinuousSaturate = DoNothing
            GC.ReportDSNetRate = DoNothing
            GC.SendDSErrorLogToLobby = DoNothing
            GC.SendDSHawkEyePatrolLogToLobby = DoNothing
            
            GC.SendTssSdkAntiDataToLobby = function(GameID, Uid, Data, DataLen, NetworkStatus)
                if NetUtil and NetUtil.SendPacket then
                    local safeFlow = { ErrorCode = 0, ReportLog = 0 }
                    NetUtil.SendPacket("on_tss_sdk_anti_data", Uid, "", 0, NetworkStatus, safeFlow)
                end
            end
        end
        if _G.NetUtil and not _G.NetUtil._AKHooked then
            local orig_SendPacket = _G.NetUtil.SendPacket
            local orig_SendPkg = _G.NetUtil.SendPkg
            local Blacklist = {
                ["report_unrealnet_exception"] = true,
                ["report_dh_calc_key_error"] = true,
                ["report_client_net_continuous_saturate"] = true,
                ["report_player_ip"] = true,
                ["report_unrealnet_clientstats"] = true,
                ["shutdown_after_error"] = true
            }

            _G.NetUtil.SendPacket = function(msgName, ...)
                if Blacklist[msgName] then return nil end
                return orig_SendPacket(msgName, ...)
            end

            _G.NetUtil.SendPkg = function(msgName, ...)
                if Blacklist[msgName] then return nil end
                return orig_SendPkg(msgName, ...)
            end

            _G.NetUtil._AKHooked = true            
        end
    end)

    pcall(function()
        local puffer_common = package.loaded["client.slua.logic.download.puffer.logic_puffer_common"]
        if puffer_common then

            puffer_common._GetKickOutList = function()
                return {} 
            end
            
            puffer_common.HandleKickOutList = function(hashList)

                return 
            end
        end
    end)

end

AKMOD_INSTALL()

pcall(function()
    local ticker = package.loaded["common.time_ticker"] or require("common.time_ticker")
    if ticker and ticker.AddTimerLoop then
        ticker.AddTimerLoop(0, function()
            pcall(AKMOD_INSTALL)
        end, -1, 5.0)
    end
end)

-- _G.Net = _G.ScriptHelperNetInterface
-- ...