package main

import (
	"github.com/veandco/go-sdl2/sdl"
	"image/color"
	"math/rand"
)

type Player struct {
	local            bool
	playerColors     PlayerColors
	keyMap           KeyMap
	joyMap           JoyMap
	joyStick         *sdl.Joystick
	camera           *sdl.Rect
	energy           uint16
	ammunition       uint16
	shields          uint16
	digCooldown      uint8
	shootCooldown    uint8
	repairCooldown   uint8
	rechargeCooldown uint8
	movementCooldown uint8
	reloadCooldown   uint8
	gameObject       *GameObject

	window *sdl.Window

	logicalSurface *sdl.Surface
	playSurface    *sdl.Surface
	HUDSurface     *sdl.Surface

	playSurfaceRect *sdl.Rect
	HUDSurfaceRect  *sdl.Rect

	playSurfaceTargetRect *sdl.Rect
	HUDSurfaceTargetRect  *sdl.Rect

	totalHandleEventsTime uint64
	totalRenderTime       uint64
	totalFrameTime        uint64
	totalScalingTime      uint64
	frameCount            uint64
}

func (player *Player) track(camera *sdl.Rect) {
	camera.X = player.gameObject.baseRect.X - 37
	camera.Y = player.gameObject.baseRect.Y - 38
}

func (player *Player) render(camera *sdl.Rect, surface *sdl.Surface) {

	// Common part: Rendering player
	player.gameObject.baseRect = sdl.Rect{X: player.gameObject.baseRect.X, Y: player.gameObject.baseRect.Y, W: 7, H: 7}

	if player.shields > 0 && player.shields <= MaxShields {
		player.gameObject.render(camera, surface)
	}

}

func (player *Player) digBlock(posX, posY int32, gameMap *GameMap, isShooting bool) uint8 {
	collisionAtDigSite := gameMap.checkCollision(posX, posY)
	if collisionAtDigSite == 0 {
		return 0
	} else if collisionAtDigSite == 1 && (player.digCooldown == 0 || isShooting) {
		gameMap.tiles[posX][posY] = 0
		player.digCooldown = DiggingCooldown
		return 1
	}
	return 2
}

func (player *Player) tick(isShooting bool, bullets *[]*Bullet, format *sdl.PixelFormat) {
	if player.digCooldown > 0 {
		player.digCooldown--
	}
	if player.shootCooldown > 0 {
		player.shootCooldown--
	}
	if player.repairCooldown > 0 {
		player.repairCooldown--
	}
	if player.rechargeCooldown > 0 {
		player.rechargeCooldown--
	}
	if player.movementCooldown > 0 {
		player.movementCooldown--
	}
	if player.reloadCooldown > 0 {
		player.reloadCooldown--
	} else if player.ammunition < MaxAmmunition && !isShooting && player.energy > ReloadCost {
		player.ammunition++
		player.reloadCooldown = ReloadCooldown
		player.energy -= ReloadCost
	}
	if player.shields <= 0 {
		player.shields = MaxShields + 1
		player.explode(bullets)
	}
}

func (player *Player) tryMove(gameMap *GameMap, isShooting bool, players *[]*Player) (moved bool) {
	if player.movementCooldown > 0 {
		return false
	}
	ranOutOfEnergy := (isShooting && player.energy <= DiggingCost+ShootDiggingCostBonus) || player.energy <= DiggingCost
	if ranOutOfEnergy {
		isShooting = false
	}
	shouldPenalizeDigging := false
	stopped := false

	switch player.gameObject.orientation {
	case 0: // Up
		collisionRect := sdl.Rect{
			X: player.gameObject.baseRect.X,
			Y: player.gameObject.baseRect.Y - 1,
			W: 5,
			H: 7,
		}
		for _, opponent := range *players {
			if opponent != player && opponent.gameObject.baseRect.HasIntersection(&collisionRect) {
				return false
			}
		}
		for x := player.gameObject.baseRect.X; x < player.gameObject.baseRect.X+5 && !stopped; x++ {
			for y := player.gameObject.baseRect.Y - 1; y < player.gameObject.baseRect.Y+7; y++ {
				digResult := player.digBlock(x, y, gameMap, isShooting)
				if digResult == 1 {
					shouldPenalizeDigging = true
					if !isShooting {
						stopped = true
						break
					}
				} else if digResult != 0 {
					stopped = true
					break
				}
			}
		}
		if !stopped {
			moved = true
			player.gameObject.baseRect.Y--
		}

	case 1: // Right
		collisionRect := sdl.Rect{
			X: player.gameObject.baseRect.X + 1,
			Y: player.gameObject.baseRect.Y,
			W: 7,
			H: 5,
		}
		for _, opponent := range *players {
			if opponent != player && opponent.gameObject.baseRect.HasIntersection(&collisionRect) {
				return false
			}
		}
		for y := player.gameObject.baseRect.Y + 1; y < player.gameObject.baseRect.Y+6 && !stopped; y++ {
			for x := player.gameObject.baseRect.X + 1; x < player.gameObject.baseRect.X+8; x++ {
				digResult := player.digBlock(x, y, gameMap, isShooting)
				if digResult == 1 {
					shouldPenalizeDigging = true
					if !isShooting {
						stopped = true
						break
					}
				} else if digResult != 0 {
					stopped = true
					break
				}
			}
		}
		if !stopped {
			moved = true
			player.gameObject.baseRect.X++
		}

	case 2: // Down
		collisionRect := sdl.Rect{
			X: player.gameObject.baseRect.X,
			Y: player.gameObject.baseRect.Y + 1,
			W: 5,
			H: 7,
		}
		for _, opponent := range *players {
			if opponent != player && opponent.gameObject.baseRect.HasIntersection(&collisionRect) {
				return false
			}
		}
		for x := player.gameObject.baseRect.X; x < player.gameObject.baseRect.X+5 && !stopped; x++ {
			for y := player.gameObject.baseRect.Y + 1; y < player.gameObject.baseRect.Y+8; y++ {
				digResult := player.digBlock(x, y, gameMap, isShooting)
				if digResult == 1 {
					shouldPenalizeDigging = true
					if !isShooting {
						stopped = true
						break
					}
				} else if digResult != 0 {
					stopped = true
					break
				}
			}
		}
		if !stopped {
			moved = true
			player.gameObject.baseRect.Y++
		}

	case 3: // Left
		collisionRect := sdl.Rect{
			X: player.gameObject.baseRect.X - 1,
			Y: player.gameObject.baseRect.Y,
			W: 7,
			H: 5,
		}
		for _, opponent := range *players {
			if opponent != player && opponent.gameObject.baseRect.HasIntersection(&collisionRect) {
				return false
			}
		}
		for y := player.gameObject.baseRect.Y + 1; y < player.gameObject.baseRect.Y+6 && !stopped; y++ {
			for x := player.gameObject.baseRect.X - 1; x < player.gameObject.baseRect.X+6; x++ {
				digResult := player.digBlock(x, y, gameMap, isShooting)
				if digResult == 1 {
					shouldPenalizeDigging = true
					if !isShooting {
						stopped = true
						break
					}
				} else if digResult != 0 {
					stopped = true
					break
				}
			}
		}
		if !stopped {
			moved = true
			player.gameObject.baseRect.X--
		}

	case 4: // Up-Right
		collisionRect := sdl.Rect{
			X: player.gameObject.baseRect.X + 1,
			Y: player.gameObject.baseRect.Y - 1,
			W: 7,
			H: 7,
		}
		for _, opponent := range *players {
			if opponent != player && opponent.gameObject.baseRect.HasIntersection(&collisionRect) {
				return false
			}
		}
		for x := player.gameObject.baseRect.X + 1; x < player.gameObject.baseRect.X+8 && !stopped; x++ {
			for y := player.gameObject.baseRect.Y - 1; y < player.gameObject.baseRect.Y+6; y++ {
				digResult := player.digBlock(x, y, gameMap, isShooting)
				if digResult == 1 {
					shouldPenalizeDigging = true
					if !isShooting {
						stopped = true
						break
					}
				} else if digResult != 0 {
					stopped = true
					break
				}
			}
		}
		if !stopped {
			moved = true
			player.gameObject.baseRect.X++
			player.gameObject.baseRect.Y--
		}

	case 5: // Up-Left
		collisionRect := sdl.Rect{
			X: player.gameObject.baseRect.X - 1,
			Y: player.gameObject.baseRect.Y - 1,
			W: 7,
			H: 7,
		}
		for _, opponent := range *players {
			if opponent != player && opponent.gameObject.baseRect.HasIntersection(&collisionRect) {
				return false
			}
		}
		for x := player.gameObject.baseRect.X - 1; x < player.gameObject.baseRect.X+6 && !stopped; x++ {
			for y := player.gameObject.baseRect.Y - 1; y < player.gameObject.baseRect.Y+6; y++ {
				digResult := player.digBlock(x, y, gameMap, isShooting)
				if digResult == 1 {
					shouldPenalizeDigging = true
					if !isShooting {
						stopped = true
						break
					}
				} else if digResult != 0 {
					stopped = true
					break
				}
			}
		}
		if !stopped {
			moved = true
			player.gameObject.baseRect.X--
			player.gameObject.baseRect.Y--
		}

	case 6: // Down-Right
		collisionRect := sdl.Rect{
			X: player.gameObject.baseRect.X + 1,
			Y: player.gameObject.baseRect.Y + 1,
			W: 7,
			H: 7,
		}
		for _, opponent := range *players {
			if opponent != player && opponent.gameObject.baseRect.HasIntersection(&collisionRect) {
				return false
			}
		}
		for x := player.gameObject.baseRect.X + 1; x < player.gameObject.baseRect.X+8 && !stopped; x++ {
			for y := player.gameObject.baseRect.Y + 1; y < player.gameObject.baseRect.Y+8; y++ {
				digResult := player.digBlock(x, y, gameMap, isShooting)
				if digResult == 1 {
					shouldPenalizeDigging = true
					if !isShooting {
						stopped = true
						break
					}
				} else if digResult != 0 {
					stopped = true
					break
				}
			}
		}
		if !stopped {
			moved = true
			player.gameObject.baseRect.X++
			player.gameObject.baseRect.Y++
		}

	case 7: // Down-Left
		collisionRect := sdl.Rect{
			X: player.gameObject.baseRect.X - 1,
			Y: player.gameObject.baseRect.Y + 1,
			W: 7,
			H: 7,
		}
		for _, opponent := range *players {
			if opponent != player && opponent.gameObject.baseRect.HasIntersection(&collisionRect) {
				return false
			}
		}
		for x := player.gameObject.baseRect.X - 1; x < player.gameObject.baseRect.X+6 && !stopped; x++ {
			for y := player.gameObject.baseRect.Y + 1; y < player.gameObject.baseRect.Y+8; y++ {
				digResult := player.digBlock(x, y, gameMap, isShooting)
				if digResult == 1 {
					shouldPenalizeDigging = true
					if !isShooting {
						stopped = true
						break
					}
				} else if digResult != 0 {
					stopped = true
					break
				}
			}
		}
		if !stopped {
			moved = true
			player.gameObject.baseRect.X--
			player.gameObject.baseRect.Y++
		}
	}

	// Penalties and cooldown handling
	if shouldPenalizeDigging {
		if isShooting && player.ammunition < MaxAmmunition && rand.Intn(2) == 0 {
			player.ammunition++
		}
		if ranOutOfEnergy {
			player.digCooldown = DiggingCooldownNoEnergy
		}
		player.energy -= DiggingCost
		if isShooting {
			player.energy -= ShootDiggingCostBonus
		}
	}
	if moved {
		if ranOutOfEnergy {
			player.movementCooldown = MovementCooldownNoEnergy
		} else {
			player.movementCooldown = MovementCooldown
		}
	}
	return
}

func (player *Player) getRGBAColor(colorIndex uint8, format *sdl.PixelFormat) uint32 {
	var selectedColor color.Color
	switch colorIndex {
	case 0:
		selectedColor = player.playerColors.tracks
	case 1:
		selectedColor = player.playerColors.body
	case 2:
		selectedColor = player.playerColors.cannon
	}
	var r, g, b, a uint8
	if selectedColor != nil {
		rt, gt, bt, at := selectedColor.RGBA()
		r, g, b, a = uint8(rt), uint8(gt), uint8(bt), uint8(at)
	}
	return sdl.MapRGBA(format, r, g, b, a)

}

func (player *Player) shoot(super bool, bullets *[]*Bullet) {
	if (super && (player.energy <= SuperShotCost || player.ammunition < MaxAmmunition)) || (!super && (player.energy <= NormalShotCost || player.ammunition < 1)) {
		return
	}
	if player.shootCooldown == 0 {
		var shootX, shootY int32

		switch player.gameObject.orientation {
		case 0: // Up
			shootY = player.gameObject.baseRect.Y - 1
			shootX = player.gameObject.baseRect.X + 2
			break
		case 1: // Right
			shootY = player.gameObject.baseRect.Y + 3
			shootX = player.gameObject.baseRect.X + 8
			break
		case 2: // Down
			shootX = player.gameObject.baseRect.X + 2
			shootY = player.gameObject.baseRect.Y + 8
			break
		case 3: // Left
			shootY = player.gameObject.baseRect.Y + 3
			shootX = player.gameObject.baseRect.X - 2
			break
		case 4: // Up-Right
			shootY = player.gameObject.baseRect.Y
			shootX = player.gameObject.baseRect.X + 5
			break
		case 5: // Up-Left
			shootY = player.gameObject.baseRect.Y
			shootX = player.gameObject.baseRect.X - 1
			break
		case 6: // Down-Right
			shootY = player.gameObject.baseRect.Y + 5
			shootX = player.gameObject.baseRect.X + 5
			break
		case 7: // Down-Left
			shootY = player.gameObject.baseRect.Y + 5
			shootX = player.gameObject.baseRect.X - 1
			break
		}

		// Set bullet color
		bulletColor := player.playerColors.body

		// Create and add the bullet
		*bullets = append(*bullets, &Bullet{
			posX:      shootX,
			posY:      shootY,
			direction: player.gameObject.orientation,
			color:     bulletColor,
			super:     super,
		})
		// Set cooldown and decrease energy
		player.shootCooldown = ShootCooldown
		if super {
			player.energy -= SuperShotCost
			player.ammunition = 0
		} else {
			player.energy -= NormalShotCost
			player.ammunition--
		}
	}
}

func (player *Player) explode(bullets *[]*Bullet) {
	// Set bullet color
	bulletColor := player.playerColors.body

	for x := player.gameObject.baseRect.X - BlastRadius; x < BlastRadius*2+1; x++ {
		for y := player.gameObject.baseRect.Y - BlastRadius; y < BlastRadius*2+1; y++ {
			// Create and add the bullet
			*bullets = append(*bullets, &Bullet{
				posX:      x,
				posY:      y,
				direction: uint8(rand.Intn(8)),
				color:     bulletColor,
				super:     true,
			})

		}
	}
}

func createPlayers(amount uint8, playerColors []PlayerColors, keyMaps []KeyMap, joyMaps []JoyMap, gameMap *GameMap, players *[]*Player) {
	joyStickCount := sdl.NumJoysticks()
	if amount > uint8(len(keyMaps)+len(joyMaps)) || amount > uint8(len(keyMaps)+joyStickCount) {
		panic("Too many players, not enough inputs")
	}
	if amount >= uint8(len(playerColors)) {
		panic("Too many players, not enough colors")
	}
	addedKeyboardPlayers := 0
	for i := uint8(0); i < amount; i++ {
		var keyMap KeyMap
		var joyMap JoyMap
		var joyStick *sdl.Joystick

		if (DoAllKeymapsPlayers && i <= uint8(len(keyMaps))) || (DoKeymapPlayer && i == 0) || (uint8(joyStickCount) <= i) {
			keyMap = keyMaps[addedKeyboardPlayers]
			addedKeyboardPlayers++
		} else {
			joyStickIndex := i - uint8(addedKeyboardPlayers)
			joyMap = joyMaps[joyStickIndex]
			joyStick = sdl.JoystickOpen(int(joyStickIndex))
		}
		createPlayer(
			playerColors[i],
			keyMap,
			joyMap,
			joyStick,
			gameMap,
			players,
		)
	}
}

func closeThings(players *[]*Player) {
	for _, player := range *players {
		if player.joyStick != nil {
			player.joyStick.Close()
		}
		if player.window != nil {
			player.window.Destroy()
		}
		if player.logicalSurface != nil {
			player.logicalSurface.Free()
		}
		if player.playSurface != nil {
			player.playSurface.Free()
		}
		if player.HUDSurface != nil {
			player.HUDSurface.Free()
		}
	}
}

func createPlayer(playerColors PlayerColors, keyMap KeyMap, joyMap JoyMap, joyStick *sdl.Joystick, gameMap *GameMap, players *[]*Player) {
	coordsAreValid := false
	var posX, posY int32
	maxTries := 1000
	for !coordsAreValid && maxTries >= 0 {
		maxTries--
		posX = int32(16 + rand.Intn(int(gameMap.width-43)))
		posY = int32(16 + rand.Intn(int(gameMap.height-43)))

		coordsAreValid = true
		for _, player := range *players {
			distance := (player.gameObject.baseRect.X-posX)*(player.gameObject.baseRect.X-posX) +
				(player.gameObject.baseRect.Y-posY)*(player.gameObject.baseRect.Y-posY)
			if distance < 300*300 { // Check if distance is less than 300 units
				coordsAreValid = false
				break
			}
		}
		if posX < 16 || posX > gameMap.width-36-7 || posY < 16 || posY > gameMap.height-36-7 {
			coordsAreValid = false
			break
		}
	}
	if maxTries < 0 {
		panic("Could not place all players, increase map size")
	}

	gameObject := &GameObject{}

	gameObject.baseRect = sdl.Rect{
		X: posX,
		Y: posY,
		W: 7,
		H: 7,
	}

	gameObject.addColor(playerColors.tracks)
	gameObject.addColor(playerColors.body)
	gameObject.addColor(playerColors.cannon)

	gameObject.orientation = 0 // Up
	gameObject.addColoredRect(0, 1, 1, 6, 0)
	gameObject.addColoredRect(4, 1, 1, 6, 0)
	gameObject.addColoredRect(1, 2, 3, 4, 1)
	gameObject.addColoredRect(2, 0, 1, 4, 2)

	gameObject.orientation = 1 // Right
	gameObject.addColoredRect(1, 1, 6, 1, 0)
	gameObject.addColoredRect(1, 5, 6, 1, 0)
	gameObject.addColoredRect(2, 2, 4, 3, 1)
	gameObject.addColoredRect(4, 3, 4, 1, 2)

	gameObject.orientation = 2 // Down
	gameObject.addColoredRect(0, 1, 1, 6, 0)
	gameObject.addColoredRect(4, 1, 1, 6, 0)
	gameObject.addColoredRect(1, 2, 3, 4, 1)
	gameObject.addColoredRect(2, 4, 1, 4, 2)

	gameObject.orientation = 3 // Left
	gameObject.addColoredRect(1, 1, 6, 1, 0)
	gameObject.addColoredRect(1, 5, 6, 1, 0)
	gameObject.addColoredRect(2, 2, 4, 3, 1)
	gameObject.addColoredRect(0, 3, 4, 1, 2)

	gameObject.orientation = 4 // Up-Right
	gameObject.addColoredRect(3, 0, 1, 1, 0)
	gameObject.addColoredRect(2, 1, 1, 1, 0)
	gameObject.addColoredRect(1, 2, 1, 1, 0)
	gameObject.addColoredRect(0, 3, 1, 1, 0)
	gameObject.addColoredRect(6, 3, 1, 1, 0)
	gameObject.addColoredRect(5, 4, 1, 1, 0)
	gameObject.addColoredRect(4, 5, 1, 1, 0)
	gameObject.addColoredRect(3, 6, 1, 1, 0)

	gameObject.addColoredRect(3, 1, 1, 1, 1)
	gameObject.addColoredRect(2, 2, 2, 1, 1)
	gameObject.addColoredRect(1, 3, 2, 1, 1)

	gameObject.addColoredRect(4, 3, 2, 1, 1)
	gameObject.addColoredRect(2, 4, 3, 1, 1)
	gameObject.addColoredRect(3, 5, 1, 1, 1)

	gameObject.addColoredRect(5, 1, 1, 1, 2)
	gameObject.addColoredRect(4, 2, 1, 1, 2)
	gameObject.addColoredRect(3, 3, 1, 1, 2)

	// Up-Left orientation (Y-axis reflection)
	gameObject.orientation = 5 // Up-Left
	gameObject.addColoredRect(3, 0, 1, 1, 0)
	gameObject.addColoredRect(4, 1, 1, 1, 0)
	gameObject.addColoredRect(5, 2, 1, 1, 0)
	gameObject.addColoredRect(6, 3, 1, 1, 0)
	gameObject.addColoredRect(0, 3, 1, 1, 0)
	gameObject.addColoredRect(1, 4, 1, 1, 0)
	gameObject.addColoredRect(2, 5, 1, 1, 0)
	gameObject.addColoredRect(3, 6, 1, 1, 0)

	gameObject.addColoredRect(3, 1, 1, 1, 1)
	gameObject.addColoredRect(3, 2, 2, 1, 1)
	gameObject.addColoredRect(4, 3, 2, 1, 1)

	gameObject.addColoredRect(1, 3, 2, 1, 1)
	gameObject.addColoredRect(2, 4, 3, 1, 1)
	gameObject.addColoredRect(3, 5, 1, 1, 1)

	gameObject.addColoredRect(1, 1, 1, 1, 2)
	gameObject.addColoredRect(2, 2, 1, 1, 2)
	gameObject.addColoredRect(3, 3, 1, 1, 2)

	// Down-Right orientation (X-axis reflection)
	gameObject.orientation = 6 // Down-Right
	gameObject.addColoredRect(3, 6, 1, 1, 0)
	gameObject.addColoredRect(2, 5, 1, 1, 0)
	gameObject.addColoredRect(1, 4, 1, 1, 0)
	gameObject.addColoredRect(0, 3, 1, 1, 0)
	gameObject.addColoredRect(6, 3, 1, 1, 0)
	gameObject.addColoredRect(5, 2, 1, 1, 0)
	gameObject.addColoredRect(4, 1, 1, 1, 0)
	gameObject.addColoredRect(3, 0, 1, 1, 0)

	gameObject.addColoredRect(3, 5, 1, 1, 1)
	gameObject.addColoredRect(2, 4, 2, 1, 1)
	gameObject.addColoredRect(1, 3, 2, 1, 1)

	gameObject.addColoredRect(4, 3, 2, 1, 1)
	gameObject.addColoredRect(2, 2, 3, 1, 1)
	gameObject.addColoredRect(3, 1, 1, 1, 1)

	gameObject.addColoredRect(5, 5, 1, 1, 2)
	gameObject.addColoredRect(4, 4, 1, 1, 2)
	gameObject.addColoredRect(3, 3, 1, 1, 2)

	// Down-Left orientation (XY reflection)
	gameObject.orientation = 7 // Down-Left
	gameObject.addColoredRect(3, 6, 1, 1, 0)
	gameObject.addColoredRect(4, 5, 1, 1, 0)
	gameObject.addColoredRect(5, 4, 1, 1, 0)
	gameObject.addColoredRect(6, 3, 1, 1, 0)
	gameObject.addColoredRect(0, 3, 1, 1, 0)
	gameObject.addColoredRect(1, 2, 1, 1, 0)
	gameObject.addColoredRect(2, 1, 1, 1, 0)
	gameObject.addColoredRect(3, 0, 1, 1, 0)

	gameObject.addColoredRect(3, 1, 1, 1, 1)
	gameObject.addColoredRect(2, 2, 3, 1, 1)
	gameObject.addColoredRect(1, 3, 2, 1, 1)

	gameObject.addColoredRect(4, 3, 2, 1, 1)
	gameObject.addColoredRect(3, 4, 2, 1, 1)
	gameObject.addColoredRect(3, 5, 1, 1, 1)

	gameObject.addColoredRect(1, 5, 1, 1, 2)
	gameObject.addColoredRect(2, 4, 1, 1, 2)
	gameObject.addColoredRect(3, 3, 1, 1, 2)

	gameObject.orientation = 0

	*players = append(*players, &Player{
		playerColors: playerColors,
		keyMap:       keyMap,
		joyMap:       joyMap,
		joyStick:     joyStick,
		shields:      MaxShields,
		energy:       MaxEnergy,
		gameObject:   gameObject,
		local:        true,
	})
}