// BRKOUT - A Breakout Clone for Sega Dreamcast
// Ported from: https://3e8.org/hacks/brkout/
//
// This example demonstrates how to build a complete game using Go on the
// Dreamcast. It showcases:
//   - Loading textures and sounds from the romdisk filesystem
//   - Reading controller input (D-pad and analog stick)
//   - Rendering 2D graphics using the PowerVR hardware
//   - Simple collision detection and game physics
//   - Game state management with menus and screens
//
// Controls:
//   D-Pad / Analog Stick - Move paddle
//   A or START          - Select menu option
//   START + B           - Return to menu during gameplay

package main

import "kos"

// =============================================================================
// GAME CONFIGURATION
// =============================================================================
//
// All game parameters are defined as constants, making them easy to tweak.
// Try changing these values to see how they affect gameplay!

// Screen size (Dreamcast outputs 640x480 by default)
const (
	ScreenWidth  = 640
	ScreenHeight = 480
)

// The playing field is where the action happens
const (
	FieldLeft   = 10  // Pixels from left edge
	FieldTop    = 40  // Pixels from top edge
	FieldWidth  = 500 // Width in pixels
	FieldHeight = 420 // Height in pixels
)

// Brick grid - the targets to destroy
const (
	BrickCols   = 20 // Columns of bricks
	BrickRows   = 15 // Maximum rows of bricks
	BrickWidth  = 25 // Width of each brick
	BrickHeight = 12 // Height of each brick
)

// Paddle - the player's bat
const (
	PaddleWidth  = 70               // Width in pixels
	PaddleHeight = 10               // Height in pixels
	PaddleSpeed  = 6.0              // Movement speed
	PaddleY      = FieldHeight - 30 // Distance from field bottom
)

// Ball physics
const (
	BallSize      = 12           // Ball diameter
	BallRadius    = BallSize / 2 // Ball radius
	StartSpeed    = 3.0          // Initial ball speed
	MaxSpeed      = 7.0          // Maximum ball speed
	SpeedIncrease = 0.5          // Speed boost per level
)

// Input sensitivity
const (
	StickDeadzone = 15   // Ignore small joystick movements
	StickScale    = 18.0 // How fast joystick moves paddle
)

// Game rules
const (
	StartingLives  = 3  // Lives at game start
	PointsPerBrick = 10 // Base score for each brick
)

// =============================================================================
// COLOR PALETTE
// =============================================================================
//
// Colors are packed into 32-bit values: Alpha, Red, Green, Blue (0.0 to 1.0)
// We use helper functions to make the code more readable.

func white() uint32      { return kos.PlxPackColor(1, 1, 1, 1) }
func gray() uint32       { return kos.PlxPackColor(1, 0.5, 0.5, 0.5) }
func darkBlue() uint32   { return kos.PlxPackColor(1, 0.05, 0.05, 0.1) }
func wallBlue() uint32   { return kos.PlxPackColor(1, 0.4, 0.4, 0.6) }
func paddleBlue() uint32 { return kos.PlxPackColor(1, 0.4, 0.4, 0.7) }
func shadow() uint32     { return kos.PlxPackColor(0.7, 0, 0, 0) }

// Rainbow colors for bricks - each row gets a different color!
var brickColors = []uint32{
	kos.PlxPackColor(1, 1.0, 0.2, 0.2), // 🔴 Red
	kos.PlxPackColor(1, 1.0, 0.6, 0.2), // 🟠 Orange
	kos.PlxPackColor(1, 1.0, 1.0, 0.2), // 🟡 Yellow
	kos.PlxPackColor(1, 0.2, 1.0, 0.2), // 🟢 Green
	kos.PlxPackColor(1, 0.2, 1.0, 1.0), // 🩵 Cyan
	kos.PlxPackColor(1, 0.2, 0.2, 1.0), // 🔵 Blue
	kos.PlxPackColor(1, 0.8, 0.2, 1.0), // 🟣 Purple
}

// =============================================================================
// GAME ASSETS
// =============================================================================
//
// Textures and sounds loaded from the romdisk (virtual filesystem compiled
// into the game executable).

var (
	titleImage *kos.PlxTexture // Title screen background
	fontImage  *kos.PlxTexture // Bitmap font for text
	fieldImage *kos.PlxTexture // Playing field background

	soundClick  kos.SfxHandle // Menu navigation
	soundBounce kos.SfxHandle // Ball bouncing
	soundHit    kos.SfxHandle // Brick destroyed
	soundLose   kos.SfxHandle // Lost a life
	soundWin    kos.SfxHandle // Level complete
)

func loadAssets() {
	// Initialize the PowerVR graphics chip
	kos.PvrInitDefaults()

	// Load images from the /rd (romdisk) filesystem
	titleImage = kos.PlxTxrLoad("/rd/brkout.png", false, 0)
	fontImage = kos.PlxTxrLoad("/rd/font.png", true, 0) // true = has transparency
	fieldImage = kos.PlxTxrLoad("/rd/field.png", false, 0)

	// Initialize sound system and load effects
	kos.SndStreamInit()
	soundClick = kos.SndSfxLoad("/rd/click.wav")
	soundBounce = kos.SndSfxLoad("/rd/bounce.wav")
	soundHit = kos.SndSfxLoad("/rd/toggled.wav")
	soundLose = kos.SndSfxLoad("/rd/failure.wav")
	soundWin = kos.SndSfxLoad("/rd/success.wav")
}

// =============================================================================
// CONTROLLER INPUT
// =============================================================================
//
// The Dreamcast controller has a D-pad, analog stick, and buttons.
// We track the previous frame's buttons to detect new presses.

var (
	buttonsNow  uint32 // Buttons held this frame
	buttonsPrev uint32 // Buttons held last frame
	stickX      int32  // Analog stick X position (-128 to 127)
)

func readController() {
	buttonsPrev = buttonsNow

	// Find the first controller plugged in
	controller := kos.MapleEnumType(0, kos.MAPLE_FUNC_CONTROLLER)
	if controller == nil {
		buttonsNow, stickX = 0, 0
		return
	}

	// Read its current state
	state := controller.ContState()
	if state == nil {
		buttonsNow, stickX = 0, 0
		return
	}

	buttonsNow = state.Buttons
	stickX = state.Joyx
}

// justPressed returns true only on the frame when a button is first pressed
func justPressed(button uint32) bool {
	wasUp := (buttonsPrev & button) == 0
	isDown := (buttonsNow & button) != 0
	return wasUp && isDown
}

// isHeld returns true every frame while a button is held down
func isHeld(button uint32) bool {
	return (buttonsNow & button) != 0
}

// getStickMovement returns paddle movement from the analog stick
func getStickMovement() float32 {
	// Ignore tiny movements (deadzone prevents drift)
	if stickX > -StickDeadzone && stickX < StickDeadzone {
		return 0
	}
	return float32(stickX) / StickScale
}

// =============================================================================
// GAME STATE
// =============================================================================
//
// All the variables that track what's happening in the game.

var (
	// Paddle position (X coordinate within the field)
	paddleX float32

	// Ball position and velocity
	ballX, ballY       float32
	ballSpeedX, speedY float32

	// Brick grid: 0 = empty, 1-7 = brick color
	bricks     [BrickCols * BrickRows]int
	bricksLeft int

	// Player progress
	lives int
	score int
	level int
)

// =============================================================================
// DRAWING HELPERS
// =============================================================================
//
// The Dreamcast's PowerVR chip renders 3D polygons. For 2D games, we draw
// rectangles (quads) at a fixed Z depth. The PLX library makes this easy!

// setupColors prepares for drawing solid-colored shapes
func setupColors(list uint32) {
	kos.PlxCxtInit()
	kos.PlxCxtTexture(nil) // No texture, just colors
	kos.PlxCxtCulling(kos.PLX_CULL_NONE)
	kos.PlxCxtSend(int32(list))
}

// setupTexture prepares for drawing textured shapes
func setupTexture(list uint32, texture *kos.PlxTexture) {
	kos.PlxCxtInit()
	kos.PlxCxtTexture(texture.Ptr())
	kos.PlxCxtCulling(kos.PLX_CULL_NONE)
	kos.PlxCxtSend(int32(list))
}

// drawRect draws a solid colored rectangle
func drawRect(x, y, w, h, z float32, color uint32) {
	// A quad needs 4 vertices, last one marked as "end of strip"
	kos.PlxVertInp(kos.PLX_VERT, x, y+h, z, color)
	kos.PlxVertInp(kos.PLX_VERT, x, y, z, color)
	kos.PlxVertInp(kos.PLX_VERT, x+w, y+h, z, color)
	kos.PlxVertInp(kos.PLX_VERT_EOS, x+w, y, z, color)
}

// drawImage draws a textured rectangle with UV coordinates
func drawImage(x, y, w, h, z float32, color uint32, u1, v1, u2, v2 float32) {
	kos.PlxVertIfp(kos.PLX_VERT, x, y+h, z, color, u1, v2)
	kos.PlxVertIfp(kos.PLX_VERT, x, y, z, color, u1, v1)
	kos.PlxVertIfp(kos.PLX_VERT, x+w, y+h, z, color, u2, v2)
	kos.PlxVertIfp(kos.PLX_VERT_EOS, x+w, y, z, color, u2, v1)
}

// =============================================================================
// TEXT RENDERING
// =============================================================================
//
// We use a bitmap font stored in a texture. Each character is 12x24 pixels,
// arranged in a 16x16 grid (256 characters total, ASCII order).

const (
	charW    = 12    // Character width
	charH    = 24    // Character height
	fontSize = 256.0 // Texture size
)

// drawText draws a string at the given position
func drawText(x, y, z float32, color uint32, text string) {
	for i, ch := range text {
		if ch < 32 {
			continue // Skip control characters
		}
		// Calculate UV coordinates for this character
		col := int(ch) % 16
		row := int(ch) / 16
		u1 := float32(col*charW) / fontSize
		v1 := float32(row*charH) / fontSize
		u2 := u1 + charW/fontSize
		v2 := v1 + charH/fontSize
		// Draw the character
		drawImage(x+float32(i*charW), y, charW, charH, z, color, u1, v1, u2, v2)
	}
}

// drawNumber draws an integer as text
func drawNumber(x, y, z float32, color uint32, n int) {
	if n == 0 {
		drawText(x, y, z, color, "0")
		return
	}
	// Build string from digits (right to left)
	text := ""
	for n > 0 {
		digit := byte(n % 10)
		text = string('0'+digit) + text
		n = n / 10
	}
	drawText(x, y, z, color, text)
}

// =============================================================================
// SOUND EFFECTS
// =============================================================================
//
// Simple wrappers for playing sounds with panning (left/center/right)

func playSound(sound kos.SfxHandle)      { kos.SndSfxPlay(sound, 160, 128) }
func playSoundLeft(sound kos.SfxHandle)  { kos.SndSfxPlay(sound, 140, 64) }
func playSoundRight(sound kos.SfxHandle) { kos.SndSfxPlay(sound, 140, 192) }

// =============================================================================
// MATH HELPERS
// =============================================================================

func abs(x float32) float32 {
	if x < 0 {
		return -x
	}
	return x
}

// =============================================================================
// TITLE MENU
// =============================================================================

func showMenu() bool {
	kos.PvrSetBgColor(0, 0, 0) // Black background
	choice := 0                // 0 = Play, 1 = Quit

	for {
		readController()

		// Navigate with D-pad
		if justPressed(kos.CONT_DPAD_UP) || justPressed(kos.CONT_DPAD_DOWN) {
			choice = 1 - choice // Toggle between 0 and 1
			playSound(soundClick)
		}

		// Select with A or START
		if justPressed(kos.CONT_A) || justPressed(kos.CONT_START) {
			playSound(soundHit)
			fadeOutMenu(choice)
			return choice == 1 // true = quit
		}

		renderMenu(choice, 1.0)
	}
}

func fadeOutMenu(choice int) {
	for frame := 30; frame >= 0; frame-- {
		renderMenu(choice, float32(frame)/30.0)
	}
}

func renderMenu(choice int, alpha float32) {
	kos.PvrWaitReady()
	kos.PvrSceneBegin()

	// Draw title image (opaque layer)
	kos.PvrListBegin(kos.PVR_LIST_OP_POLY)
	if titleImage != nil {
		setupTexture(kos.PVR_LIST_OP_POLY, titleImage)
		tint := kos.PlxPackColor(1, alpha, alpha, alpha)
		drawImage(0, 0, ScreenWidth, ScreenHeight, 100, tint, 0, 0, 640.0/1024.0, 480.0/512.0)
	}
	kos.PvrListFinish()

	// Draw menu cursor (translucent layer)
	kos.PvrListBegin(kos.PVR_LIST_TR_POLY)
	setupColors(kos.PVR_LIST_TR_POLY)
	cursorY := float32(314 + choice*50)
	drawRect(250, cursorY, 20, 20, 200, kos.PlxPackColor(alpha, 1, 1, 1))
	kos.PvrListFinish()

	kos.PvrSceneFinish()
}

// =============================================================================
// GAME INITIALIZATION
// =============================================================================

func startNewGame() {
	lives = StartingLives
	score = 0
	level = 1
	setupLevel()
}

func setupLevel() {
	// Center the paddle
	paddleX = float32(FieldWidth-PaddleWidth) / 2.0

	// Reset the ball
	resetBall()

	// Fill brick grid (more rows at higher levels)
	rows := 3 + level
	if rows > BrickRows {
		rows = BrickRows
	}

	bricksLeft = 0
	numColors := len(brickColors)

	for row := 0; row < BrickRows; row++ {
		for col := 0; col < BrickCols; col++ {
			i := row*BrickCols + col
			if row < rows {
				bricks[i] = (row % numColors) + 1 // Color index 1-7
				bricksLeft++
			} else {
				bricks[i] = 0 // Empty
			}
		}
	}
}

func resetBall() {
	// Position ball above paddle
	ballX = paddleX + PaddleWidth/2.0 - BallRadius
	ballY = FieldHeight - 50.0

	// Calculate speed for current level
	speed := StartSpeed + float32(level)*SpeedIncrease
	if speed > MaxSpeed {
		speed = MaxSpeed
	}

	// Launch at an angle
	ballSpeedX = speed * 0.6
	speedY = -speed
}

// =============================================================================
// GAME LOOP
// =============================================================================

func playGame() {
	kos.PvrSetBgColor(0.05, 0.05, 0.1) // Dark blue background
	startNewGame()

	for lives > 0 {
		readController()

		// Return to menu with START+B
		if isHeld(kos.CONT_START) && isHeld(kos.CONT_B) {
			return
		}

		updatePaddle()
		updateBall()
		renderGame()
	}
}

// =============================================================================
// PADDLE MOVEMENT
// =============================================================================

func updatePaddle() {
	// D-pad control
	if isHeld(kos.CONT_DPAD_LEFT) {
		paddleX -= PaddleSpeed
	}
	if isHeld(kos.CONT_DPAD_RIGHT) {
		paddleX += PaddleSpeed
	}

	// Analog stick control
	paddleX += getStickMovement()

	// Keep paddle inside the field
	if paddleX < 0 {
		paddleX = 0
	}
	if paddleX > FieldWidth-PaddleWidth {
		paddleX = FieldWidth - PaddleWidth
	}
}

// =============================================================================
// BALL PHYSICS
// =============================================================================

func updateBall() {
	// Move ball
	ballX += ballSpeedX
	ballY += speedY

	// Check all collisions
	checkWalls()
	checkPaddle()
	checkBricks()
	checkLost()
	checkWin()
}

func checkWalls() {
	// Left wall
	if ballX < 0 {
		ballX = 0
		ballSpeedX = -ballSpeedX
		playSoundLeft(soundBounce)
	}

	// Right wall
	if ballX > FieldWidth-BallSize {
		ballX = FieldWidth - BallSize
		ballSpeedX = -ballSpeedX
		playSoundRight(soundBounce)
	}

	// Top wall
	if ballY < 0 {
		ballY = 0
		speedY = -speedY
		playSound(soundBounce)
	}
}

func checkPaddle() {
	// Ball center coordinates
	ballCenterX := ballX + BallRadius
	ballBottom := ballY + BallSize

	// Is ball at paddle height?
	if ballBottom < PaddleY || ballY > PaddleY+PaddleHeight {
		return
	}

	// Is ball above paddle?
	if ballCenterX < paddleX || ballCenterX > paddleX+PaddleWidth {
		return
	}

	// Bounce!
	ballY = PaddleY - BallSize
	speedY = -abs(speedY)

	// Angle depends on where ball hit the paddle
	// Hit left = go left, hit right = go right
	hitPoint := (ballCenterX - paddleX) / PaddleWidth // 0.0 to 1.0
	ballSpeedX = (hitPoint - 0.5) * 8.0               // -4.0 to +4.0

	playSound(soundBounce)
}

func checkBricks() {
	// Ball center coordinates
	ballCenterX := ballX + BallRadius
	ballCenterY := ballY + BallRadius

	// Which brick is the ball in?
	col := int(ballCenterX) / BrickWidth
	row := int(ballCenterY) / BrickHeight

	// Out of bounds?
	if col < 0 || col >= BrickCols || row < 0 || row >= BrickRows {
		return
	}

	// Is there a brick here?
	i := row*BrickCols + col
	if bricks[i] == 0 {
		return
	}

	// Destroy the brick!
	bricks[i] = 0
	bricksLeft--
	score += PointsPerBrick * level

	// Bounce off brick (figure out which side we hit)
	brickCenterX := float32(col*BrickWidth) + BrickWidth/2.0
	brickCenterY := float32(row*BrickHeight) + BrickHeight/2.0

	horizDist := abs(ballCenterX-brickCenterX) / BrickWidth
	vertDist := abs(ballCenterY-brickCenterY) / BrickHeight

	if horizDist > vertDist {
		ballSpeedX = -ballSpeedX // Hit side
	} else {
		speedY = -speedY // Hit top/bottom
	}

	playSound(soundHit)
}

func checkLost() {
	// Ball fell below the field?
	if ballY <= FieldHeight {
		return
	}

	lives--
	playSound(soundLose)

	if lives <= 0 {
		showGameOver()
		return
	}

	// Continue with new ball
	resetBall()
	waitFrames(60) // Brief pause
}

func checkWin() {
	// All bricks destroyed?
	if bricksLeft > 0 {
		return
	}

	playSound(soundWin)
	level++
	setupLevel()
	waitFrames(60) // Brief pause
}

func waitFrames(n int) {
	for i := 0; i < n; i++ {
		renderGame()
	}
}

// =============================================================================
// GAME OVER SCREEN
// =============================================================================

func showGameOver() {
	bg := kos.PlxPackColor(1, 0.1, 0.1, 0.15)

	for frame := 0; frame < 180; frame++ { // 3 seconds
		kos.PvrWaitReady()
		kos.PvrSceneBegin()

		// Background
		kos.PvrListBegin(kos.PVR_LIST_OP_POLY)
		setupColors(kos.PVR_LIST_OP_POLY)
		drawRect(0, 0, ScreenWidth, ScreenHeight, 1, bg)
		kos.PvrListFinish()

		// Text
		kos.PvrListBegin(kos.PVR_LIST_TR_POLY)
		if fontImage != nil {
			setupTexture(kos.PVR_LIST_TR_POLY, fontImage)
			drawText(220, 180, 100, white(), "GAME OVER")
			drawText(220, 230, 100, gray(), "Score:")
			drawNumber(320, 230, 100, white(), score)
		}
		kos.PvrListFinish()

		kos.PvrSceneFinish()

		// Skip with A button
		readController()
		if justPressed(kos.CONT_A) {
			return
		}
	}
}

// =============================================================================
// GAME RENDERING
// =============================================================================

func renderGame() {
	kos.PvrWaitReady()
	kos.PvrSceneBegin()

	// === OPAQUE LAYER ===
	// Draw solid objects that don't need transparency
	kos.PvrListBegin(kos.PVR_LIST_OP_POLY)
	drawBackground()
	drawField()
	drawWalls()
	drawBricks()
	drawPaddle()
	drawBall()
	kos.PvrListFinish()

	// === TRANSLUCENT LAYER ===
	// Draw text (font has transparent background)
	kos.PvrListBegin(kos.PVR_LIST_TR_POLY)
	drawHUD()
	kos.PvrListFinish()

	kos.PvrSceneFinish()
}

func drawBackground() {
	setupColors(kos.PVR_LIST_OP_POLY)
	drawRect(0, 0, ScreenWidth, ScreenHeight, 1, darkBlue())
}

func drawField() {
	if fieldImage == nil {
		return
	}
	setupTexture(kos.PVR_LIST_OP_POLY, fieldImage)
	drawImage(FieldLeft, FieldTop, FieldWidth, FieldHeight, 50, white(),
		0, 0, float32(FieldWidth)/512.0, float32(FieldHeight)/512.0)
}

func drawWalls() {
	setupColors(kos.PVR_LIST_OP_POLY)
	color := wallBlue()
	drawRect(FieldLeft-5, FieldTop, 5, FieldHeight, 100, color)          // Left
	drawRect(FieldLeft+FieldWidth, FieldTop, 5, FieldHeight, 100, color) // Right
	drawRect(FieldLeft-5, FieldTop-5, FieldWidth+10, 5, 100, color)      // Top
}

func drawBricks() {
	numColors := len(brickColors)

	for row := 0; row < BrickRows; row++ {
		for col := 0; col < BrickCols; col++ {
			colorIndex := bricks[row*BrickCols+col]
			if colorIndex == 0 {
				continue // Empty space
			}

			// Calculate screen position
			x := float32(FieldLeft + col*BrickWidth)
			y := float32(FieldTop + row*BrickHeight)

			// Draw shadow first (slightly offset)
			drawRect(x+2, y+2, BrickWidth-2, BrickHeight-2, 99, shadow())

			// Draw brick on top
			color := brickColors[(colorIndex-1)%numColors]
			drawRect(x, y, BrickWidth-2, BrickHeight-2, 100, color)
		}
	}
}

func drawPaddle() {
	x := float32(FieldLeft) + paddleX
	y := float32(FieldTop + PaddleY)

	// Shadow
	drawRect(x+3, y+3, PaddleWidth, PaddleHeight, 99, shadow())
	// Paddle
	drawRect(x, y, PaddleWidth, PaddleHeight, 100, paddleBlue())
}

func drawBall() {
	x := float32(FieldLeft) + ballX
	y := float32(FieldTop) + ballY
	drawRect(x, y, BallSize, BallSize, 100, white())
}

func drawHUD() {
	if fontImage == nil {
		return
	}

	setupTexture(kos.PVR_LIST_TR_POLY, fontImage)

	// Position HUD to the right of the playing field
	x := float32(FieldLeft + FieldWidth + 15)

	drawText(x, 50, 200, white(), "BRKOUT")

	drawText(x, 100, 200, gray(), "Level")
	drawNumber(x, 125, 200, white(), level)

	drawText(x, 170, 200, gray(), "Score")
	drawNumber(x, 195, 200, white(), score)

	drawText(x, 250, 200, gray(), "Lives")
	drawNumber(x, 275, 200, white(), lives)
}

// =============================================================================
// MAIN ENTRY POINT
// =============================================================================

func main() {
	// Load all game assets (textures, sounds)
	loadAssets()

	// Main game loop - keeps returning to menu after each game
	for {
		if showMenu() {
			return // User chose "Quit"
		}
		playGame()
	}
}