require 'funcs'

local GameMode = require 'tetris.modes.gamemode'
local Piece = require 'tetris.components.piece'

local Bag7NoSZOStartRandomizer = require 'tetris.randomizers.bag7noSZOstart'

local HighStackerGame = GameMode:extend()

HighStackerGame.name = "High Stacker"
HighStackerGame.hash = "HighStacker"
HighStackerGame.tagline = "Play risky on the higher fields and don't be a chicken!"

--Official Release v1.0
--Concept & Coding by Xx_Henry_xX (Xx_Henry_xX#0296)
--Code mostly & shamelessly stolen from...
	--Marathon A2 / A3
	--Survival 2020
--[[
	changelog
	Official Release v1.0
	-2'-ALL ending appearing on other ALLs fixed
	-transition bug is fixed AT LAST!!!!!!!!!!!!!

	Official Release v0.2
	-null piece bug fixed
	-some pointless bool == bool stuffs edited

	Official Release v0.1
	-total delay is now ura loop 2 exclusive
	-edited total delay values
	-end of game bonus details added
	-2'-ALL ending added
	-roll bgm added

	Discord Beta v2.0
	-scoring rehaul (mostly on REN)
	-slot is gone
	-current section score & section cool requirement display added

	Discord Beta v1.2
	-adjusted section cool cutoffs and ura 2nd loop cutoff
	-fixed end of game bonus being given endlessly (kudos 2 infinifen#1129)

	Discord Beta v1.1
	-bugfixes on section score text color
	-end of game bonus added

	Discord Beta v1.0
	-initial semi-public release
]]

function HighStackerGame:new()
	HighStackerGame.super:new()

	self.roll_frames = 0
	self.combo = 0
	self.randomizer = Bag7NoSZOStartRandomizer()
	self.grade = 0
	self.grade_points = 0
	self.grade_point_decay_counter = 0
	self.section_start_score = 0
	self.section_scores = { [0] = 0 }
	self.loop = 0 --0 == loop 1 / 1 == omote / 2 == ura
	self.total_lines = 0
	self.section_cools = 0
	self.cool_timer = 0
	self.ground_touched = false
	self.total_delay = 300
	self.show_loop = false
	self.actually_cue_the_rolls = false
	self.ren_on = false

	self.line_details = { }
	self.line_details_second = { }
	self.detail_timer = 0
	self.ending = 0
	self.clear_bonus_given = false

	--debug
	--[[
	self.level = 499
	self.section_cools = 4
	self.score = 50000000
	self.section_scores = {
		[0] = 10000000,
		[1] = 10000000,
		[2] = 10000000,
		[3] = 10000000
	}
	]]
	
	self.additive_gravity = false
	self.lock_drop = false
	self.lock_hard_drop = false
	self.enable_hold = true
	self.next_queue_length = 3
end

function HighStackerGame:getARE()
		if self.level < 700 then return 27
	elseif self.level < 800 then return 18
	else return 14 end
end

function HighStackerGame:getLineARE()
		if self.level < 600 then return 27
	elseif self.level < 700 then return 18
	elseif self.level < 800 then return 14
	else return 8 end
end

function HighStackerGame:getDasLimit()
		if self.level < 500 then return 15
	elseif self.level < 900 then return 9
	else return 7 end
end

function HighStackerGame:getLineClearDelay()
		if self.level < 500 then return 40
	elseif self.level < 600 then return 25
	elseif self.level < 700 then return 16
	elseif self.level < 800 then return 12
	else return 6 end
end

function HighStackerGame:getLockDelay()
		if self.level < 900 then return 30
	else return 17 end
end

function HighStackerGame:getGravity()
		if (self.level < 30)  then return 4/256
	elseif (self.level < 35)  then return 6/256
	elseif (self.level < 40)  then return 8/256
	elseif (self.level < 50)  then return 10/256
	elseif (self.level < 60)  then return 12/256
	elseif (self.level < 70)  then return 16/256
	elseif (self.level < 80)  then return 32/256
	elseif (self.level < 90)  then return 48/256
	elseif (self.level < 100) then return 64/256
	elseif (self.level < 120) then return 80/256
	elseif (self.level < 140) then return 96/256
	elseif (self.level < 160) then return 112/256
	elseif (self.level < 170) then return 128/256
	elseif (self.level < 200) then return 144/256
	elseif (self.level < 220) then return 4/256
	elseif (self.level < 230) then return 32/256
	elseif (self.level < 233) then return 64/256
	elseif (self.level < 236) then return 96/256
	elseif (self.level < 239) then return 128/256
	elseif (self.level < 243) then return 160/256
	elseif (self.level < 247) then return 192/256
	elseif (self.level < 251) then return 224/256
	elseif (self.level < 300) then return 1
	elseif (self.level < 330) then return 2
	elseif (self.level < 360) then return 3
	elseif (self.level < 400) then return 4
	elseif (self.level < 420) then return 5
	elseif (self.level < 450) then return 4
	elseif (self.level < 500) then return 3
	else return 20
	end
end

function HighStackerGame:getTotalDelay()
		if self.loop ~= 2 then return 300
	elseif self.level < 530 then return 270
	elseif self.level < 600 then return 240
	elseif self.level < 700 then return 210
	elseif self.level < 800 then return 180
	elseif self.level < 900 then return 150
	else return 120 end
end

function HighStackerGame:advanceOneFrame()
	if self.clear then
		self.roll_frames = self.roll_frames + 1
		if not self.actually_cue_the_rolls then
			if self.roll_frames < -120 then
				return false
			elseif self.roll_frames >= 0 then
				if self.loop ~= 0 then
					self.clear = false
					self.ready_frames = 100
					self.show_loop = true
				end
				return true
			end
			return false
		elseif self.roll_frames < 0 then
			if self.roll_frames + 1 == 0 then
				switchBGM("credit_roll", "gm3")
			end
			return false
		elseif self.roll_frames > 3701 then
			self.completed = true
			switchBGM(nil)
		end
	elseif self.ready_frames == 0 then
		self.frames = self.frames + 1
		if self.piece ~= nil then
			if self.ground_touched and self.loop == 2 then
				self.total_delay = self.total_delay + 1
				if self.total_delay >= self:getTotalDelay() and self.piece:isDropBlocked(self.grid) then
					self.piece.locked = true
				end
			elseif self.piece:isDropBlocked(self.grid) then self.ground_touched = true end
		end
	end
	if self.detail_timer > 0 then
		self.detail_timer = self.detail_timer - 1
	end
	return true
end

function HighStackerGame:onPieceEnter()
	self.total_delay = 0
	self.ground_touched = false
	if (self.level % 100 ~= 99) and not self.clear and self.frames ~= 0 and not self.ren_on then
		self.level = self.level + 1
	end
end

local line_count_multiplier = {1, 2, 4, 6}
local line_position_score = {
	15000,
	15000,
	15000,
	15000, --lowest off-field row
	15000,
	10000,
	9000,
	8000,
	7000,
	6000,
	5000,
	4000,
	3000,
	2000,
	1000,
	900,
	800,
	700,
	600,
	500,
	40,
	30,
	20,
	10
}

function HighStackerGame:updateScore(level, drop_bonus, cleared_lines)
	local ae, cleared_lines_table = self.grid:getClearedRowCount()
	self.total_lines = self.total_lines + cleared_lines
	if cleared_lines > 0 then
		self.detail_timer = 120
		self.line_details = { }
		self.line_details_second = { }
		local basescore = self.combo
		local levelscore = self.level * 10
		table.insert(self.line_details_second, levelscore)
		if basescore > 0 then 
			table.insert(self.line_details_second, basescore)
			self.ren_on = true
		end
		if self.loop == 1 then levelscore = levelscore - 5000 end
		basescore = basescore + levelscore
		for key, pos in ipairs(cleared_lines_table) do
			basescore = basescore + line_position_score[pos]
			table.insert(self.line_details, line_position_score[pos])
		end
		self.score = self.score + basescore * line_count_multiplier[cleared_lines]
		self.combo = basescore
		
	else
		self.combo = 0
		self.ren_on = false
	end
	self.drop_bonus = 0
	if self.clear then self.lines = self.lines + cleared_lines end --reminder that this is for roll lines
end

function HighStackerGame:onLineClear(cleared_row_count)
	if self.ren_on == false then
		self:updateSectionScores(self.level, self.level + cleared_row_count)
		self.level = math.min(self.level + cleared_row_count, 1000)
	end
	if self.level >= 500 and not self.clear and self.loop == 0 then
		self.level = 500
		self.clear = true
		self.grid:clear()
		self.roll_frames = -150
		if self:nextloopcheck() then
			self.roll_frames = self.roll_frames - 120
			self.lcd = 0
			self.are = 0
		else
			self.actually_cue_the_rolls = true
		end
	elseif self.level == 1000 and not self.clear then
		self.clear = true
		self.grid:clear()
		self.actually_cue_the_rolls = true
		self.roll_frames = -150
	end
	self.lock_drop = self.level >= 900
	self.lock_hard_drop = self.level >= 900
end

local lowest_section_cool_cutoff = 800000

function HighStackerGame:updateSectionScores(old_level, new_level)
	if self.clear or self.loop ~= 0 then return end
	if math.floor(old_level / 100) < math.floor(new_level / 100) or
	new_level >= 500 then
		-- record new section
		section_score = self.score - self.section_start_score
		self.section_scores[math.floor(old_level / 100)] = section_score
		self.section_start_score = self.score
		if self.loop == 0 then
			if section_score >= lowest_section_cool_cutoff + 50000 * (math.floor(old_level / 100) + self.section_cools) then
				self.section_cools = self.section_cools + 1
				self.cool_timer = 300
			end
		end
	end
end

function HighStackerGame:nextloopcheck()
	if not self.clear then return false end
	if self.section_cools >= 5 and self.score >= 6000000 then
		self.loop = 2
		return true
	elseif self.section_cools >= 3 and self.score >= 4000000 then
		self.loop = 1
		return true
	end
	return false
end

function HighStackerGame:getSkin()
	return (self.level >= 701 and self.loop == 2) and "bone" or "2tie"
end

function HighStackerGame:onGameComplete()
	if not self.clear_bonus_given then
		self.clear_bonus_given = true
		if self.loop == 2 then
			self.score = self.score + self.total_lines * 100 + self.lines * 1000
		elseif self.loop == 1 then
			self.score = self.score + self.total_lines * 100 + self.lines * 500
		else
			self.score = self.score + self.total_lines * 10 + self.lines * 100
		end
	end
	self:onGameOver()
end

function HighStackerGame:onGameOver()
	switchBGM(nil)
	if not self.clear_bonus_given then
		love.graphics.setColor(1, 1, 1, 1)
		love.graphics.setFont(font_3x5_3)
		love.graphics.printf("GAME\nOVER", 64, 200, 160, "center")
	else
		if self.game_over_frames >= 300 then
			local alpha = 0
			local animation_length = 120
			if self.game_over_frames - 300 < animation_length then
				-- Show field for a bit, then fade out.
				alpha = math.pow(2048, (self.game_over_frames - 300)/animation_length - 1)
			else
				alpha = 1
			end
			love.graphics.setColor(0, 0, 0, alpha)
			love.graphics.rectangle(
				"fill", 64, 80,
				16 * self.grid.width, 16 * (self.grid.height - 4)
			)
		end
		if self.game_over_frames >= 420 and loop == 2 then
			love.graphics.setColor(1, 1, 1, 1)
			love.graphics.setFont(font_3x5_2)
			love.graphics.printf(
				[[And so, the journey
for the true end of
this absurd scoring
mode is over...

From now on,
aim for an even
	  higher score.

May fortune
	   be with you.

	   -Xx_Henry_xX]], 67, math.max(125, 1000 - self.game_over_frames), 160, "left")
		end
	end
end

HighStackerGame.rollOpacityFunction = function(age)
	if age < 240 then return 1
	elseif age > 300 then return 0
	else return 1 - (age - 240) / 60 end
end

HighStackerGame.mRollOpacityFunction = function(age)
	if age > 4 then return 0
	else return 1 - age / 4 end
end

function HighStackerGame:drawGrid()
	if self.clear and not (self.completed or self.game_over) then
		if self.loop == 2 then
			self.grid:drawInvisible(self.mRollOpacityFunction, nil, false)
		elseif self.loop == 1 then
			self.grid:drawInvisible(self.rollOpacityFunction, nil, false)
		else
			self.grid:draw()
		end
	else
		self.grid:draw()
		if self.piece ~= nil then
			self:drawGhostPiece(ruleset)
		end
	end
end

function HighStackerGame:drawScoringInfo()
	love.graphics.setColor(1, 1, 1, 1)
	love.graphics.setFont(font_3x5_2)

	--y is dis debug text everywhere
	--[[
	love.graphics.setFont(font_3x5_2)
	love.graphics.print(
		self.das.direction .. " " ..
		self.das.frames .. " " ..
		strTrueValues(self.prev_inputs)
	)
	]]

	love.graphics.printf("NEXT", 126, 6, 40, "left")
	love.graphics.printf("HOLD", 46, 6, 40, "left")
	--love.graphics.printf("SCORE", 240, 200, 40, "left")
	local vertpos = 320
	if self.show_loop then vertpos = 290 end
	love.graphics.printf("LEVEL", 240, vertpos, 40, "left")

	love.graphics.setFont(font_3x5_3)
	if self.clear and not self.actually_cue_the_rolls and self.roll_frames >= -120 then
		if self.loop == 2 then
			love.graphics.printf("WELCOME TO THE SPECIAL ROUND", 64, 200, 160, "center")
		else
			love.graphics.printf("Let's try everything again", 64, 200, 160, "center")
		end
	end	

	if self.clear_bonus_given then
		if self.loop == 0 then
			love.graphics.setFont(font_3x5_3)
			love.graphics.printf("ALL CLEAR!", 44, 100, 200, "center")
			love.graphics.setFont(font_3x5)
			love.graphics.printf("(probably)", 44, 125, 200, "center")

			love.graphics.setFont(font_3x5_2)
			love.graphics.printf("TOTAL LINES", 80, 240, 120, "left")
			love.graphics.printf(self.total_lines .. " x 10\n" .. (self.total_lines * 10), 80, 260, 120, "right")
			love.graphics.printf("ROLL LINES", 80, 320, 120, "left")
			love.graphics.printf(self.lines .. " x 100\n" .. (self.lines * 100), 80, 340, 120, "right")
		elseif self.loop == 1 then
			love.graphics.setFont(font_3x5_3)
			love.graphics.printf("ALL CLEAR!", 44, 100, 200, "center")
			love.graphics.setFont(font_3x5)
			love.graphics.printf("(probably)", 44, 125, 200, "center")

			love.graphics.setFont(font_3x5_2)
			love.graphics.printf("TOTAL LINES", 80, 240, 120, "left")
			love.graphics.printf(self.total_lines .. " x 100\n" .. (self.total_lines * 100), 80, 260, 120, "right")
			love.graphics.printf("ROLL LINES", 80, 320, 120, "left")
			love.graphics.printf(self.lines .. " x 500\n" .. (self.lines * 500), 80, 340, 120, "right")
		elseif self.game_over_frames < 300 then
			love.graphics.printf("CONGRATULATIONS!\nTRUE 2-ALL\nCLEAR!!!", 44, 100, 200, "center")

			love.graphics.setFont(font_3x5_2)
			love.graphics.printf("TOTAL LINES", 80, 240, 120, "left")
			love.graphics.printf(self.total_lines .. " x 100\n" .. (self.total_lines * 100), 80, 260, 120, "right")
			love.graphics.printf("ROLL LINES", 80, 320, 120, "left")
			love.graphics.printf(self.lines .. " x 1000\n" .. (self.lines * 1000), 80, 340, 120, "right")
		end
	end

	if(self.cool_timer > 0) then
		love.graphics.printf("COOL!!", 64, 400, 160, "center")
		self.cool_timer = self.cool_timer - 1
	end

	love.graphics.setFont(font_8x11)
	love.graphics.setColor(1, 1, 1, 1)
	love.graphics.printf(self.score, 48, 420, 180, "right")
	love.graphics.setFont(font_3x5_3)
	if self.show_loop then
		if self.loop == 2 then
			love.graphics.printf("2'-", 240, 310, 40, "right")
		elseif self.loop == 1 then
			love.graphics.printf("2-", 240, 310, 40, "left")
		end
	end
	love.graphics.printf(self:getLevel(), 240, 340, 40, "right")
	love.graphics.printf(self:getSectionEndLevel(), 240, 370, 40, "right")
	love.graphics.setFont(font_3x5_2)
	love.graphics.printf(formatTime(self.frames), 500, 420, 180, "left")

	love.graphics.setColor(1, 1, 1, 1)
	if self.loop == 0 then
		local prevSectionTotal = 0
		for i = 0, #self.section_scores do
			prevSectionTotal = prevSectionTotal + self.section_scores[i]
		end
		love.graphics.printf(self.score - prevSectionTotal, 240, 420, 70, "right")
		love.graphics.printf("/" .. lowest_section_cool_cutoff + 50000 * (math.floor(self.level / 100) + self.section_cools), 240, 436, 70, "right")
	end

    cool_counter = 0
	for i = 0, #self.section_scores do
		love.graphics.setColor(1, 1, 1, 1)
		if self.section_scores[i] > lowest_section_cool_cutoff + 50000 * (i + cool_counter) then
			love.graphics.setColor(0, 1, 0, 1)
			cool_counter = cool_counter + 1
		end
		love.graphics.printf(self.section_scores[i], 400, 80 + 16 * i, 180, "right")
	end

	love.graphics.setColor(1, 1, 1, 1)
	if self.detail_timer > 0 then
		for i = 1, #self.line_details do
			love.graphics.printf(self.line_details[i] .. "x" .. line_count_multiplier[#self.line_details], 240, 134 + 16 * i, 60, "right")
		end
		for i = 1, #self.line_details_second do
			love.graphics.printf(self.line_details_second[i] .. "x" .. line_count_multiplier[#self.line_details], 240, 196 + 16 * i, 60, "right")
		end
	end
end

function HighStackerGame:getHighscoreData()
	return {
		score = self.score,
		level = self.level,
		frames = self.frames,
	}
end

function HighStackerGame:getLevel()
	if self.loop ~=0 then return self.level - 500 end
	return self.level
end

function HighStackerGame:getSectionEndLevel()
	if self.loop ~=0 then return math.min(math.floor((self.level - 500) / 100 + 1) * 100, 500) end
	return math.min(math.floor(self.level / 100 + 1) * 100, 500)
end

function HighStackerGame:getBackground()
	return math.floor(self.level / 100)
end

return HighStackerGame