local bannedStrings = {"lumbertycoon", "lumber_tycoon", "lumbertyc00n", "lumber_tyc00n", "lumbertyco0n", "lumber_tyco0n", "lumbertyc0on", "lumber_tyc0on",
						"iumbertycoon", "iumber_tycoon", "iumbertyc00n", "iumber_tyc00n", "iumbertyco0n", "iumber_tyco0n", "iumbertyc0on", "iumber_tyc0on",
						"defaultio", "defauitio", "defaultlo", "defaultlo",
						"defualtio", "defuaitio", "defualtlo", "defualtlo",
						"defaulti0", "defauiti0", "defaultl0", "defaultl0",
						"defualti0", "defuaiti0", "defualtl0", "defualtl0"
}

local password = "nohacks"

local playerStats = {}
local joinTime = {}
local loadedSlot = {}

------------------------[[ Player stats setup ]]------------------------
game.Players.PlayerAdded:connect(function(newPlayer)

	if not (newPlayer.UserId == 78743445) then
		for _, s in pairs(bannedStrings) do
			if string.find(string.lower(newPlayer.Name), s) then
				print("K9"..debug.traceback())
				newPlayer:Kick()
				return
			end
		end
	end


	local stats = Instance.new("IntValue")
	stats.Name = "leaderstats"

	local a = Instance.new("IntValue")
	a.Name = "Money"
	a.Value = 20
	a.Parent = stats

	stats.Parent = newPlayer

	local chattingValue = Instance.new("IntValue", newPlayer)
	chattingValue.Name = "IsChatting"

	local toolDebounce = Instance.new("NumberValue", newPlayer)
	toolDebounce.Name = "ToolEnableTick"

	local buyingLand = Instance.new("BoolValue", newPlayer)
	buyingLand.Name = "IsBuyingLand"

	local propertyOwner = Instance.new("BoolValue", newPlayer)
	propertyOwner.Name = "OwnsProperty"


	local realMoney = a:clone()
	playerStats[newPlayer] = {Money = realMoney}--stats
	realMoney.Changed:connect(function()
		a.Value = realMoney.Value
	end)

	a.Changed:connect(function()
		if not (a.Value == realMoney.Value) then
			addExploitLog("MoneyExploit", newPlayer.Name, newPlayer.Name.." changed leaderstat value from "..realMoney.Value.." to "..a.Value)
		end
	end)

	joinTime[newPlayer] = tick()
	newPlayer.Chatted:connect(function(...)
		Chatted(newPlayer, ...)
	end)

	script.WhitelistFolder:Clone().Parent = newPlayer
	script.BlacklistFolder:Clone().Parent = newPlayer

	if not (newPlayer.userId == 78743445) and checkBan(newPlayer) then
		return
	end

	rememberTools(newPlayer)
end)


game.Players.PlayerRemoving:connect(function(leavingPlayer)
	wait(10)
	playerStats[leavingPlayer] = nil
	joinTime[leavingPlayer] = nil
	loadedSlot[leavingPlayer] = nil
end)



local function getStats(player)
	if playerStats[player] then
		return playerStats[player]
	end
	return nil
end



local Transactions = game.ReplicatedStorage.Transactions

------------------------[[Tool Memory ]]------------------------

function rememberTools(player)
	local toolFolder = script.ToolFolder:Clone()
	local toolV = toolFolder.Tool
	toolV.Parent = nil
	toolFolder.Parent = player


	local function updateFolder(tool)
		if not player.Parent or not player:FindFirstChild("Backpack") then
			return
		end

		local currentTools = toolFolder:GetChildren()

		local charTool = player.Character and player.Character:FindFirstChild("Tool") and player.Character.Tool:FindFirstChild("ToolName")
		if charTool then
			local newV = toolV:Clone()
			newV.Value = charTool.Value
			newV.Parent = toolFolder
		end

		for _, tool in pairs(player.Backpack:GetChildren()) do
			if tool:FindFirstChild("ToolName") then
				local newV = toolV:Clone()
				newV.Value = tool.ToolName.Value
				newV.Parent = toolFolder
			end
		end

		for _, v in pairs(currentTools) do
			v:Destroy()
		end
	end

	local keepTools = false
	local hardReloading = player:WaitForChild("CurrentlySavingOrLoading") and player.CurrentlySavingOrLoading.HardReload
	hardReloading.Changed:connect(function()
		keepTools = false
	end)

	local function connectCharacter(char)

		--local --[[_,]] hardReloading = not player:FindFirstChild("CurrentlySavingOrLoading") or player.CurrentlySavingOrLoading.HardReload.Value

		if keepTools and not hardReloading.Value then
			for _, v in pairs(toolFolder:GetChildren()) do
				local item = game.ReplicatedStorage.Purchasables.Tools.AllTools:FindFirstChild(v.Value)

				if item then
					local newTool = item.Tool:clone()

					local owner = Instance.new("ObjectValue", newTool)
					owner.Name = "Owner"
					owner.Value = player

					local lastInteraction = Instance.new("IntValue", owner)
					lastInteraction.Name = "LastInteraction"

					newTool.Parent = player.Backpack
				end
			end
		end
		updateFolder()

		local c1 = char.ChildAdded:connect(updateFolder)
		local c2 = char.ChildRemoved:connect(updateFolder)
		local c3 = player.Backpack.ChildAdded:connect(updateFolder)
		local c4 = player.Backpack.ChildRemoved:connect(updateFolder)

		char.Humanoid.Died:wait()

		c1:disconnect()
		c2:disconnect()
		c3:disconnect()
		c4:disconnect()


		--currentlySavingOrLoadingBool[player].Value, currentlySavingOrLoadingBool[player].HardReload.Value
		--local --[[_,]] hardReloading = not player:FindFirstChild("CurrentlySavingOrLoading") or player.CurrentlySavingOrLoading.HardReload.Value

		local pos = char:FindFirstChild("Head") and char.Head.Position
		if pos --[[and pos.Y > -9]] and pos.Y < 5000 then
			keepTools = false

			for _, v in pairs(toolFolder:GetChildren()) do
				v:Destroy()
			end

			if not hardReloading.Value then
				for _, tool in pairs(player.Backpack:GetChildren()) do
					if tool:FindFirstChild("ToolName") then
						wait(0.15)
						tool.Handle.CFrame = CFrame.new(pos + Vector3.new(math.random() * 4 - 2, math.random() * 2, math.random() * 4 - 2)) * CFrame.Angles(math.random() * math.pi * 2, math.random() * math.pi * 2, math.random() * math.pi * 2)
						tool.Handle.Velocity = ((tool.Handle.Position - pos).unit + Vector3.new(0, 3, 0)) * 5
						local b = Instance.new("BoolValue", tool)
						b.Name = "DeathDrop"
						tool.Parent = workspace
					end
				end
			else
				for _, tool in pairs(player.Backpack:GetChildren()) do
					if tool:FindFirstChild("ToolName") then
						tool:Destroy()
					end
				end
			end

			for _, v in pairs(toolFolder:GetChildren()) do
				v:Destroy()
			end

			local charTool = player.Character and player.Character:FindFirstChild("Tool")
			if charTool and charTool:FindFirstChild("ToolName") and not hardReloading.Value then
				local b = Instance.new("BoolValue", charTool)
				b.Name = "DeathDrop"
				charTool.Parent = workspace
			elseif charTool and hardReloading.Value then
				charTool:Destroy()
			end
		else
			keepTools = not hardReloading.Value
		end
	end

	if player.Character then
		connectCharacter(player.Character)
	end
	player.CharacterAdded:connect(connectCharacter)


end

------------------------[[ Exploit Logging ]]------------------------

local exploterList = game:GetService("DataStoreService"):GetDataStore("Logs")

local slackHooks = {["MoneyExploit"] = 				"https://hooks.slack.com/services/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",
					["Exploit"] =					"https://hooks.slack.com/services/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",
					["ExploitMinor"] = 				"https://hooks.slack.com/services/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",
					["WhitelistBlacklistExploit"] = "https://hooks.slack.com/services/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",
					["KickList"] = 					"https://hooks.slack.com/services/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",
					["Notes"] = 					"https://hooks.slack.com/services/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"

					}



function getDate(t)
	local thisDate = require(game.ReplicatedStorage.DateTableModule)(t)
	return thisDate.DayName.." - "..thisDate.Day.."/"..thisDate.Month.."/"..thisDate.Year.." - "..thisDate.Hour..":"..string.format("%02i", thisDate.Minute)..":"..string.format("%02i", math.floor(thisDate.Seconds)).." "..thisDate.AMOrPM
end
function getTime(t)
	local thisDate = require(game.ReplicatedStorage.DateTableModule)(t)
	return thisDate.Hour..":"..string.format("%02i", thisDate.Minute)..":"..string.format("%02i", math.floor(thisDate.Seconds)).." "..thisDate.AMOrPM
end

local chatHistory = {}
local historyLength = 40

function Chatted(player, message, recipient)
	for i = historyLength, 2, -1 do
		chatHistory[i] = chatHistory[i - 1]
	end
	chatHistory[1] = getTime(tick()).." ["..player.Name..(recipient and " to "..recipient.Name or "").."] "..message
end


function sendPush(message, logName)
	--[[local smsString = string.gsub(message, " ", "+")
	game:GetService("HttpService"):PostAsync("https://api.clockworksms.com/http/send.aspx",
											"key=b46258414b9ecfc4e2aa5c5538510dc9039db8fb&to=14436240402&content="..smsString,
											Enum.HttpContentType.ApplicationUrlEncoded)]]
	if slackHooks[logName] then
		local slackString = 'payload={"text": "'..message..'"}'
		game:GetService("HttpService"):PostAsync(slackHooks[logName], slackString, Enum.HttpContentType.ApplicationUrlEncoded)
	end
end


function addExploitLog(logName, playerName, errorMessage, preformedLogList)

	local thisDate = getDate(tick())

	local otherPlayers = {}
	local otherPlayersString = ""

	if not preformedLogList then
		for _, v in pairs(game.Players:GetChildren()) do
			otherPlayers[v.Name] = {}
			local stats = getStats(v)
			if stats then
				otherPlayers[v.Name].Money = stats.Money.Value
				if joinTime[v] then
					otherPlayers[v.Name].JoinTime = getDate(joinTime[v])
				end
				otherPlayersString = otherPlayersString..v.Name..": "..v.UserId.."- $"..stats.Money.Value.."\n"
			end
		end

		sendPush("LT2 new log: "..logName.."\nUser: "..playerName.."\n"..errorMessage.."\nPlayerlist:\n"..otherPlayersString..thisDate, logName)

		script.Parent.ErrorReport.Report:Fire(errorMessage)
	end


	local success = true
	--[[local success, error = pcall(function()
		exploterList:UpdateAsync(logName, function(logList)
			if not logList then
				logList = {}
			end
			if not logList[playerName] then
				logList[playerName] = {}
			end

			local thisLog = preformedLogList or {Message = errorMessage, Date = thisDate, PlayerList = otherPlayers, ChatLog = chatHistory}
			table.insert(logList[playerName], thisLog)

			return logList
		end)
	end)]]

	if not success then
		--script.Parent.ErrorReport.Report:Fire("Could not update log list: "..error)
		--sendPush("Log could not be added: "..error, logName)
	end

	return success
end

function script.Parent.AddLog.OnInvoke(...)
	return addExploitLog(...)
end
function game.ReplicatedStorage.Transactions.AddLog.OnServerInvoke(player, logName, errorMessage)
	addExploitLog(logName, player.Name, errorMessage)
end


function kickPlayer(player, errorMessage)
	addExploitLog("MoneyExploit", player.Name, errorMessage)

	--player:Kick("Better luck next time!")
end


------------------------[[ Banning ]]------------------------

local KickPlayer = game:GetService("DataStoreService"):GetDataStore("KickPlayer")
local banList = {}

function checkBan(player)



	local ret = false
	local playerKicked

	for id, message in pairs(banList) do
		for _, v in pairs(game.Players:GetPlayers()) do
			--print("Checking on id: "..tonumber(string.sub(id, 6)))
			if v.userId == tonumber(string.sub(id, 6)) then

				if v == player then
					ret = true
				end

				playerKicked = v

				if message and not (message == "") then
					print("Kicking with message "..message)
					v:Kick(message)
				else
					print("Kicking default, studio: "..tostring(game:GetService("RunService"):IsStudio()))
					if not game:GetService("RunService"):IsStudio() then
						wait(0.5)
						print("K10"..debug.traceback())
						v:Kick()--"Your account has been suspended for illegitimate activity. If you wish to appeal your suspension, send Defaultio a private message.")
					end
				end
			end
		end
	end

	return ret, playerKicked
end

banList = {}
coroutine.resume(coroutine.create(function()
	while true do
		if pcall(function()
			banList = KickPlayer:GetAsync("PlayerList")
		end) then break end
		print("ban list failed, retrying soon")
		wait(60 * 1.5)
	end
end))

KickPlayer:OnUpdate("PlayerList", function(list)
	banList = list
	local _, playerKicked = checkBan()
	if playerKicked then
		script.Parent.Parent.Stats.AddLog:Invoke("KickList", playerKicked.Name, playerKicked.Name.." ban-kicked")
	end
end)

------------------------[[ Banning 2.0 ]]------------------------

--local KickPlayer = game:GetService("DataStoreService"):GetDataStore("PlayerBanning")

------------------------[[ Client to server ]]------------------------

function Transactions.ClientToServer.GetFunds.OnServerInvoke(player)
	local stats = getStats(player)
	if not stats then warn("No stats found for "..player.Name.." :"..debug.traceback()) return end

	return stats.Money.Value
end

function Transactions.ClientToServer.PlayerCanPurchase.OnServerInvoke(player, value)
	local stats = getStats(player)
	if not stats then warn("No stats found for "..player.Name.." :"..debug.traceback()) return end

	return stats.Money.Value >= value
end

function Transactions.ClientToServer.AttemptPurchase.OnServerInvoke(player, value)

	if value < 0 then
		kickPlayer(player, player.Name.." attempted invalid purchase of "..value.." (clientside)")
		script.Parent.ModeratePlayer:Invoke(player, player.userId, player.Name, "Ban", "")
		--return
	end

	local stats = getStats(player)
	if not stats then warn("No stats found for "..player.Name.." :"..debug.traceback()) return end

	if stats.Money.Value >= value then
		stats.Money.Value = stats.Money.Value - value
		fundsChanged(player)
		return true
	else
		promptUserToBuyMoreMoney(player)
		return false
	end
end


script.Parent.DataSaving.PlayerLoaded.Event:connect(function(player, slot)
	loadedSlot[player] = slot
end)

lastDonation = {}
local throttleTime = 120

function Transactions.ClientToServer.Donate.OnServerInvoke(player, receivingPlayer, value, saveSlot)
	local stats = getStats(player)
	local receivingStats = getStats(receivingPlayer)

	if not stats then warn("No stats found for "..player.Name.." :"..debug.traceback()) return false, "No stats found for "..player.Name end
	if not receivingStats then warn("No stats found for "..receivingPlayer.Name.." :"..debug.traceback()) return false, "No stats found for "..receivingPlayer.Name end

	if lastDonation[player] then
		if tick() - lastDonation[player] < throttleTime then
			return false, "Please wait to make more money transfers"
		end
	end

	if not player:FindFirstChild("CurrentlySavingOrLoading") or not receivingPlayer:FindFirstChild("CurrentlySavingOrLoading")
									or player.CurrentlySavingOrLoading.Value or receivingPlayer.CurrentlySavingOrLoading.Value then
		return false, "Save in progress"
	end
	if saveSlot <= 0 then
		return false, "No active save slot"
	end

	if value < 0 then
		kickPlayer(player, player.Name.." attempted invalid donation of "..value.." to "..(receivingPlayer and receivingPlayer.Name or "nil player").." (clientside)")
		return false, "Invalid value"
	end

	if receivingStats and receivingStats.Money.Value > 6000000 then
		return false, "Invalid value" --idk
	end

	local function AttemptReiumburse()
		stats.Money.Value = stats.Money.Value + value
		fundsChanged(player)
	end

	lastDonation[player] = tick()

	if stats.Money.Value >= value then
		stats.Money.Value = stats.Money.Value - value
		fundsChanged(player)

		if stats.Money.Value > 5000000 or value > 10000000 then
			if receivingPlayer and receivingPlayer.Parent == game.Players then
				addExploitLog("MoneyExploit", player.Name, player.Name.." attempting donating "..value.." to "..(receivingPlayer and receivingPlayer.Name or "nil player").." yielding")
			end
			wait(math.random(60 * 10, 60 * 200))
			return false
		end

		local playerHasSaved = false
		local c = script.Parent.DataSaving.PlayerSaved.Event:connect(function(p, s)
			if p == player and s == saveSlot then
				playerHasSaved = true
			end
		end)

		for i = 0, 100 do
			wait(1)
			if playerHasSaved then
				break
			end
		end

		c:disconnect()

		if not playerHasSaved then
			--AttemptReiumburse()
			return false, "Timeout"
		end


		if receivingPlayer and receivingPlayer.Parent == game.Players then
			receivingStats = getStats(receivingPlayer)
			if not receivingStats then warn("No stats found for "..receivingPlayer.Name.." :"..debug.traceback())
				--AttemptReiumburse()
				return false, "No stats found for "..receivingPlayer.Name
			end

			receivingStats.Money.Value = receivingStats.Money.Value + value
			fundsChanged(receivingPlayer)
			if value >= 500000 then
				addExploitLog("MoneyExploit", player.Name, player.Name.." donating "..value.." to "..(receivingPlayer and receivingPlayer.Name or "nil player"))
			end
		else
			--AttemptReiumburse()
			return false, "Receiving player left"
		end



		return true
	else
		return false, "Insufficient funds"
	end
end



function Transactions.ClientToServer.ASet.OnServerInvoke(player, value, pass)

	if not (player.UserId == 78743445) or not (pass == password)  then
		kickPlayer(player, player.Name.." attempted illegal funds set of "..value.." (clientside)")
		script.Parent.ModeratePlayer:Invoke(player, player.userId, player.Name, "Ban", "")
		return
	end


	local stats = getStats(player)
	if not stats then warn("No stats found for "..player.Name.." :"..debug.traceback())
		script.Parent.ErrorReport.Report:Fire("No stats found for "..player.Name.." :"..debug.traceback())
		return
	end

	stats.Money.Value = value

	fundsChanged(player)
end
------------------------[[ Server to client ]]------------------------

function fundsChanged(player)
	local stats = getStats(player)
	if not stats then warn("No stats found for "..player.Name.." :"..debug.traceback()) return end

	Transactions.ServerToClient.FundsChanged:FireClient(player, stats.Money.Value)
end


------------------------[[ Server to server ]]------------------------

Transactions.ServerToServer.AddFunds.Event:connect(function(player, value, pass)

	if not (pass == password) then
		kickPlayer(player, player.Name.." attempted illegal funds add of "..value)
		--return
	end

	local stats = getStats(player)
	if not stats then warn("No stats found for "..player.Name.." :"..debug.traceback()) return end

	stats.Money.Value = stats.Money.Value + value

	fundsChanged(player)
end)

function Transactions.ServerToServer.GetFunds.OnInvoke(player)
	local stats = getStats(player)
	if not stats then warn("No stats found for "..player.Name.." :"..debug.traceback()) return end

	return stats.Money.Value
end

function Transactions.ServerToServer.SetFunds.OnInvoke(player, value, pass)

	if not (pass == password) then
		kickPlayer(player, player.Name.." attempted illegal funds set of "..value)
		--return
	end

	local stats = getStats(player)
	if not stats then warn("No stats found for "..player.Name.." :"..debug.traceback())
		script.Parent.ErrorReport.Report:Fire("No stats found for "..player.Name.." :"..debug.traceback())
		return
	end

	stats.Money.Value = value

	fundsChanged(player)

	--[[if value > 1000000 and not game.Players.LocalPlayer then
		addExploitLog("MoneyExploit", player.Name, player.Name.." loaded high money value of "..value)
	end]]
end

function Transactions.ServerToServer.PlayerCanPurchase.OnInvoke(player, value)
	local stats = getStats(player)
	if not stats then warn("No stats found for "..player.Name.." :"..debug.traceback()) return end

	return stats.Money.Value >= value
end

function Transactions.ServerToServer.AttemptPurchase.OnInvoke(player, value)

	if value < 0 then
		kickPlayer(player, player.Name.." attempted invalid purchase of "..value)
		--return
	end

	local stats = getStats(player)
	if not stats then warn("No stats found for "..player.Name.." :"..debug.traceback()) return end

	if stats.Money.Value >= value then
		stats.Money.Value = stats.Money.Value - value
		fundsChanged(player)
		return true
	else
		promptUserToBuyMoreMoney(player)
		return false
	end
end




function promptUserToBuyMoreMoney(player)
	coroutine.resume(coroutine.create(function()
		wait(3)
		game.ReplicatedStorage.Notices.SendUserNoticeRemote:FireClient(player, "Not enough money? You can buy extra in the menu.", nil, "Open Money Menu")
	end))
end