if Engine.GetCurrentMap() ~= "core_frontend" then
	return
end

function IsServerBrowserEnabled()
	return true
end

DataSources.LobbyServer = {
	prepare = function(controller, list, filter)
		list.numElementsInList = list.vCount
		list.controller = controller
		list.serverBrowserRootModel = Engine.CreateModel(Engine.GetGlobalModel(), "serverBrowser")
		local serverListCountModel = Engine.GetModel(list.serverBrowserRootModel, "serverListCount")
		if serverListCountModel then
			list.serverCount = Engine.GetModelValue(serverListCountModel)
		else
			list.serverCount = 0
		end
		list.servers = {}
		local serversModel = Engine.CreateModel(list.serverBrowserRootModel, "servers")
		for i = 1, list.numElementsInList, 1 do
			list.servers[i] = {}
			list.servers[i].root = Engine.CreateModel(serversModel, "server_" .. i)
			list.servers[i].model = Engine.CreateModel(list.servers[i].root, "model")
		end
		list.updateModels = function(controller, list, offset)
			local serverInfo = Engine.SteamServerBrowser_GetServerInfo(offset)
			if serverInfo then
				local SetModelValue = function(model, key, value)
					local model = Engine.CreateModel(model, key)
					if model then
						Engine.SetModelValue(model, value)
					end
				end

				local elementIndex = offset % list.numElementsInList + 1
				local serverModel = list.servers[elementIndex].model
				SetModelValue(serverModel, "serverIndex", serverInfo.serverIndex)
				SetModelValue(serverModel, "connectAddr", serverInfo.connectAddr)
				SetModelValue(serverModel, "ping", serverInfo.ping)
				SetModelValue(serverModel, "modName", serverInfo.modName)
				SetModelValue(serverModel, "mapName", serverInfo.map)
				SetModelValue(serverModel, "desc", serverInfo.desc)
				-- Changed the client count to be the actual player count
				local clientCount = serverInfo.playerCount - serverInfo.botCount
				SetModelValue(serverModel, "clientCount", clientCount)
				SetModelValue(serverModel, "maxClients", serverInfo.maxPlayers)
				SetModelValue(serverModel, "passwordProtected", serverInfo.password)
				SetModelValue(serverModel, "secure", serverInfo.secure)
				SetModelValue(serverModel, "name", serverInfo.name)
				SetModelValue(serverModel, "gameType", serverInfo.gametype)
				SetModelValue(serverModel, "dedicated", serverInfo.dedicated)
				SetModelValue(serverModel, "ranked", serverInfo.ranked)
				SetModelValue(serverModel, "hardcore", serverInfo.hardcore)
				-- Added the bot count
				SetModelValue(serverModel, "botCount", serverInfo.botCount)
				return serverModel
			else
				return nil
			end
		end

		if list.serverListUpdateSubscription then
			list:removeSubscription(list.serverListUpdateSubscription)
		end
		local serverListUpdateModel = Engine.CreateModel(list.serverBrowserRootModel, "serverListCount")
		list.serverListUpdateSubscription = list:subscribeToModel(serverListUpdateModel, function(model)
			list:updateDataSource(false, false)
		end, false)
		if list.serverListSortTypeSubscription then
			list:removeSubscription(list.serverListSortTypeSubscription)
		end
		local serverListSortTypeModel = Engine.CreateModel(list.serverBrowserRootModel, "serverListSortType")
		list.serverListSortTypeSubscription = list:subscribeToModel(serverListSortTypeModel, function(model)
			list:updateDataSource(false, false)
		end, false)
	end,
	getCount = function(list)
		return list.serverCount
	end,
	getItem = function(controller, list, index)
		local offset = index - 1
		return list.updateModels(controller, list, offset)
	end,
	cleanup = function(list)
		if list.serverBrowserRootModel then
			Engine.UnsubscribeAndFreeModel(list.serverBrowserRootModel)
			list.serverBrowserRootModel = nil
		end
	end
}

CoD.ServerBrowserRowInternal.new = function(menu, controller)
	local self = LUI.UIHorizontalList.new({
		left = 0,
		top = 0,
		right = 0,
		bottom = 0,
		leftAnchor = true,
		topAnchor = true,
		rightAnchor = true,
		bottomAnchor = true,
		spacing = 2
	})
	self:setAlignment(LUI.Alignment.Left)
	if PreLoadFunc then
		PreLoadFunc(self, controller)
	end
	self:setUseStencil(false)
	self:setClass(CoD.ServerBrowserRowInternal)
	self.id = "ServerBrowserRowInternal"
	self.soundSet = "default"
	self:setLeftRight(true, false, 0, 700)
	self:setTopBottom(true, false, 0, 22)
	self:makeFocusable()
	self.onlyChildrenFocusable = true
	self.anyChildUsesUpdateState = true

	local passwordFlag = CoD.ServerBrowserFlag.new(menu, controller)
	passwordFlag:setLeftRight(true, false, 0, 28)
	passwordFlag:setTopBottom(true, true, 0, 0)
	passwordFlag.icon:setImage(RegisterImage("uie_t7_icon_serverbrowser_protected"))
	passwordFlag:linkToElementModel(self, nil, false, function(model)
		passwordFlag:setModel(model, controller)
	end)
	passwordFlag:mergeStateConditions({
		{
			stateName = "FlagOn",
			condition = function(menu, element, event)
				return IsSelfModelValueTrue(element, controller, "passwordProtected")
			end
		}
	})
	passwordFlag:linkToElementModel(passwordFlag, "passwordProtected", true, function(model)
		menu:updateElementState(passwordFlag, {
			name = "model_validation",
			menu = menu,
			modelValue = Engine.GetModelValue(model),
			modelName = "passwordProtected"
		})
	end)
	self:addElement(passwordFlag)
	self.passwordFlag = passwordFlag

	local dedicatedFlag = CoD.ServerBrowserFlag.new(menu, controller)
	dedicatedFlag:setLeftRight(true, false, 30, 58)
	dedicatedFlag:setTopBottom(true, true, 0, 0)
	dedicatedFlag.icon:setImage(RegisterImage("uie_t7_icon_serverbrowser_dedicated"))
	dedicatedFlag:linkToElementModel(self, nil, false, function(model)
		dedicatedFlag:setModel(model, controller)
	end)
	dedicatedFlag:mergeStateConditions({
		{
			stateName = "FlagOn",
			condition = function(menu, element, event)
				return IsSelfModelValueTrue(element, controller, "dedicated")
			end
		}
	})
	dedicatedFlag:linkToElementModel(dedicatedFlag, "dedicated", true, function(model)
		menu:updateElementState(dedicatedFlag, {
			name = "model_validation",
			menu = menu,
			modelValue = Engine.GetModelValue(model),
			modelName = "dedicated"
		})
	end)
	self:addElement(dedicatedFlag)
	self.dedicatedFlag = dedicatedFlag

	local rankedFlag = CoD.ServerBrowserFlag.new(menu, controller)
	rankedFlag:setLeftRight(true, false, 60, 88)
	rankedFlag:setTopBottom(true, true, 0, 0)
	rankedFlag.icon:setImage(RegisterImage("uie_t7_icon_serverbrowser_ranked"))
	rankedFlag:linkToElementModel(self, nil, false, function(model)
		rankedFlag:setModel(model, controller)
	end)
	rankedFlag:mergeStateConditions({
		{
			stateName = "FlagOn",
			condition = function(menu, element, event)
				return IsSelfModelValueTrue(element, controller, "ranked")
			end
		}
	})
	rankedFlag:linkToElementModel(rankedFlag, "ranked", true, function(model)
		menu:updateElementState(rankedFlag, {
			name = "model_validation",
			menu = menu,
			modelValue = Engine.GetModelValue(model),
			modelName = "ranked"
		})
	end)
	self:addElement(rankedFlag)
	self.rankedFlag = rankedFlag

	local name = CoD.horizontalScrollingTextBox_18pt.new(menu, controller)
	name:setLeftRight(true, false, 90, 330)
	name:setTopBottom(true, false, 2, 20)
	name.textBox:setTTF("fonts/default.ttf")
	name.textBox:setAlignment(Enum.LUIAlignment.LUI_ALIGNMENT_LEFT)
	name:linkToElementModel(self, "name", true, function(model)
		local _name = Engine.GetModelValue(model)
		if _name then
			name.textBox:setText(Engine.Localize(_name))
		end
	end)
	self:addElement(name)
	self.name = name

	local spacer = LUI.UIFrame.new(menu, controller, 0, 0, false)
	spacer:setLeftRight(true, false, 332, 339)
	spacer:setTopBottom(true, false, 0, 22)
	spacer:setAlpha(0)
	self:addElement(spacer)
	self.spacer = spacer

	local map = CoD.horizontalScrollingTextBox_18pt.new(menu, controller)
	map:setLeftRight(true, false, 341, 446)
	map:setTopBottom(true, false, 2, 20)
	map.textBox:setTTF("fonts/default.ttf")
	map.textBox:setAlignment(Enum.LUIAlignment.LUI_ALIGNMENT_LEFT)
	map:linkToElementModel(self, "mapName", true, function(model)
		local mapName = Engine.GetModelValue(model)
		if mapName then
			map.textBox:setText(MapNameToLocalizedMapName(mapName))
		end
	end)
	self:addElement(map)
	self.map = map

	local hardcoreFlag = CoD.ServerBrowserFlag.new(menu, controller)
	hardcoreFlag:setLeftRight(true, false, 448, 470)
	hardcoreFlag:setTopBottom(true, true, 0, 0)
	hardcoreFlag.icon:setImage(RegisterImage("uie_t7_icon_serverbrowser_skull"))
	hardcoreFlag:linkToElementModel(self, nil, false, function(model)
		hardcoreFlag:setModel(model, controller)
	end)
	hardcoreFlag:mergeStateConditions({
		{
			stateName = "FlagOn",
			condition = function(menu, element, event)
				return IsSelfModelValueTrue(element, controller, "hardcore")
			end
		}
	})
	hardcoreFlag:linkToElementModel(hardcoreFlag, "hardcore", true, function(model)
		menu:updateElementState(hardcoreFlag, {
			name = "model_validation",
			menu = menu,
			modelValue = Engine.GetModelValue(model),
			modelName = "hardcore"
		})
	end)
	self:addElement(hardcoreFlag)
	self.hardcoreFlag = hardcoreFlag

	local gametype = LUI.UIText.new()
	gametype:setLeftRight(true, false, 472, 576)
	gametype:setTopBottom(true, false, 2, 20)
	gametype:setTTF("fonts/RefrigeratorDeluxe-Regular.ttf")
	gametype:setAlignment(Enum.LUIAlignment.LUI_ALIGNMENT_LEFT)
	gametype:setAlignment(Enum.LUIAlignment.LUI_ALIGNMENT_TOP)
	gametype:linkToElementModel(self, "gameType", true, function(model)
		local gameType = Engine.GetModelValue(model)
		if gameType then
			gametype:setText(Engine.Localize(GetGameTypeDisplayString(gameType)))
		end
	end)
	self:addElement(gametype)
	self.gametype = gametype

	local playerCount = LUI.UIText.new()
	playerCount:setLeftRight(true, false, 593, 613)
	playerCount:setTopBottom(true, false, 2, 20)
	playerCount:setTTF("fonts/RefrigeratorDeluxe-Regular.ttf")
	playerCount:setAlignment(Enum.LUIAlignment.LUI_ALIGNMENT_RIGHT)
	playerCount:setAlignment(Enum.LUIAlignment.LUI_ALIGNMENT_TOP)
	playerCount:linkToElementModel(self, "clientCount", true, function(model)
		local clientCount = Engine.GetModelValue(model)
		if clientCount then
			playerCount:setText(Engine.Localize(clientCount))
		end
	end)
	self:addElement(playerCount)
	self.playerCount = playerCount

	local slash = LUI.UIText.new()
	slash:setLeftRight(true, false, 615, 624)
	slash:setTopBottom(true, false, 2, 20)
	slash:setText(Engine.Localize("/"))
	slash:setTTF("fonts/RefrigeratorDeluxe-Regular.ttf")
	slash:setAlignment(Enum.LUIAlignment.LUI_ALIGNMENT_LEFT)
	slash:setAlignment(Enum.LUIAlignment.LUI_ALIGNMENT_TOP)
	self:addElement(slash)
	self.slash = slash

	local maxPlayers = LUI.UIText.new()
	maxPlayers:setLeftRight(true, false, 626, 645)
	maxPlayers:setTopBottom(true, false, 2, 20)
	maxPlayers:setTTF("fonts/RefrigeratorDeluxe-Regular.ttf")
	maxPlayers:setAlignment(Enum.LUIAlignment.LUI_ALIGNMENT_LEFT)
	maxPlayers:setAlignment(Enum.LUIAlignment.LUI_ALIGNMENT_TOP)
	maxPlayers:linkToElementModel(self, "maxClients", true, function(model)
		local maxClients = Engine.GetModelValue(model)
		if maxClients then
			maxPlayers:setText(Engine.Localize(maxClients))
		end
	end)
	self:addElement(maxPlayers)
	self.maxPlayers = maxPlayers

	local botCount = LUI.UIText.new()
	botCount:setLeftRight(true, false, 637, 659)
	botCount:setTopBottom(true, false, 2, 20)
	botCount:setTTF("fonts/RefrigeratorDeluxe-Regular.ttf")
	botCount:setAlignment(Enum.LUIAlignment.LUI_ALIGNMENT_LEFT)
	botCount:setAlignment(Enum.LUIAlignment.LUI_ALIGNMENT_TOP)
	botCount:linkToElementModel(self, "botCount", true, function(model)
		local _botCount = Engine.GetModelValue(model)
		if _botCount then
			botCount:setText("[" .. Engine.Localize(_botCount) .. "]")
		end
	end)
	self:addElement(botCount)
	self.botCount = botCount

	local ping = LUI.UIText.new()
	ping:setLeftRight(true, false, 661, 699.37)
	ping:setTopBottom(true, false, 2, 20)
	ping:setTTF("fonts/RefrigeratorDeluxe-Regular.ttf")
	ping:setAlignment(Enum.LUIAlignment.LUI_ALIGNMENT_CENTER)
	ping:setAlignment(Enum.LUIAlignment.LUI_ALIGNMENT_TOP)
	ping:linkToElementModel(self, "ping", true, function(model)
		local _ping = Engine.GetModelValue(model)
		if _ping then
			ping:setText(Engine.Localize(_ping))
		end
	end)
	self:addElement(ping)
	self.ping = ping

	spacer.id = "spacer"
	self:registerEventHandler("gain_focus", function(self, event)
		if self.m_focusable and self.spacer:processEvent(event) then
			return true
		else
			return LUI.UIElement.gainFocus(self, event)
		end
	end)
	LUI.OverrideFunction_CallOriginalSecond(self, "close", function(element)
		element.passwordFlag:close()
		element.dedicatedFlag:close()
		element.rankedFlag:close()
		element.name:close()
		element.map:close()
		element.hardcoreFlag:close()
		element.gametype:close()
		element.playerCount:close()
		element.maxPlayers:close()
		element.ping:close()
	end)

	if PostLoadFunc then
		PostLoadFunc(self, controller, menu)
	end

	return self
end