// Copyright 2015 The Vanadium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// view handles the loading of new UI screens.
// Currently supported screens: Opening, Table, Pass, Take, Play, Score
// Future support: All screens part of the discovery process

package view

import (
	"sort"
	"strconv"

	"hearts/img/coords"
	"hearts/img/direction"
	"hearts/img/reposition"
	"hearts/img/staticimg"
	"hearts/img/texture"
	"hearts/img/uistate"
	"hearts/logic/card"

	"golang.org/x/mobile/exp/f32"
	"golang.org/x/mobile/exp/sprite"
)

// Opening View: Only temporary, for debugging, while discovery is not integrated
func LoadOpeningView(u *uistate.UIState) {
	u.CurView = uistate.Opening
	resetScene(u)
	buttonX := (u.WindowSize.X - u.CardDim.X) / 2
	tableButtonY := (u.WindowSize.Y - 2*u.CardDim.Y - u.Padding) / 2
	passButtonY := tableButtonY + u.CardDim.Y + u.Padding
	tableButtonXY := coords.MakeVec(buttonX, tableButtonY)
	passButtonXY := coords.MakeVec(buttonX, passButtonY)
	tableButtonPos := coords.MakePosition(tableButtonXY, tableButtonXY, u.CardDim)
	passButtonPos := coords.MakePosition(passButtonXY, passButtonXY, u.CardDim)
	tableButtonImage := u.Texs["BakuSquare.png"]
	passButtonImage := u.Texs["Clubs-2.png"]
	tableButton := texture.MakeImgWithAlt(tableButtonImage, tableButtonImage, tableButtonPos, true, u.Eng, u.Scene)
	passButton := texture.MakeImgWithAlt(passButtonImage, passButtonImage, passButtonPos, true, u.Eng, u.Scene)
	u.Buttons = append(u.Buttons, tableButton)
	u.Buttons = append(u.Buttons, passButton)
}

// Table View: Displays the table. Intended for public devices
func LoadTableView(u *uistate.UIState) {
	u.CurView = uistate.Table
	resetImgs(u)
	resetScene(u)
	scaler := float32(4)
	maxWidth := 4 * u.TableCardDim.X
	// adding four drop targets for trick
	dropTargetImage := u.Texs["trickDrop.png"]
	dropTargetDimensions := u.CardDim
	dropTargetX := (u.WindowSize.X - u.CardDim.X) / 2
	var dropTargetY float32
	if u.WindowSize.X < u.WindowSize.Y {
		dropTargetY = u.WindowSize.Y/2 + u.CardDim.Y/2 + u.Padding
	} else {
		dropTargetY = u.WindowSize.Y/2 + u.Padding
	}
	dropTargetXY := coords.MakeVec(dropTargetX, dropTargetY)
	dropTargetPos := coords.MakePosition(dropTargetXY, dropTargetXY, dropTargetDimensions)
	dropTarget := texture.MakeImgWithoutAlt(dropTargetImage, dropTargetPos, u.Eng, u.Scene)
	u.DropTargets = append(u.DropTargets, dropTarget)
	// card on top of first drop target
	dropCard := u.CurTable.GetTrick()[0]
	if dropCard != nil {
		texture.PopulateCardImage(dropCard, u.Texs, u.Eng, u.Scene)
		dropCard.Move(dropTargetXY, dropTargetDimensions, u.Eng)
		u.Cards = append(u.Cards, dropCard)
	}
	// second drop target
	dropTargetY = (u.WindowSize.Y - u.CardDim.Y) / 2
	if u.WindowSize.X < u.WindowSize.Y {
		dropTargetX = u.WindowSize.X/2 - u.CardDim.X - u.Padding
	} else {
		dropTargetX = u.WindowSize.X/2 - 3*u.CardDim.X/2 - u.Padding
	}
	dropTargetXY = coords.MakeVec(dropTargetX, dropTargetY)
	dropTargetPos = coords.MakePosition(dropTargetXY, dropTargetXY, dropTargetDimensions)
	dropTarget = texture.MakeImgWithoutAlt(dropTargetImage, dropTargetPos, u.Eng, u.Scene)
	u.DropTargets = append(u.DropTargets, dropTarget)
	// card on top of second drop target
	dropCard = u.CurTable.GetTrick()[1]
	if dropCard != nil {
		texture.PopulateCardImage(dropCard, u.Texs, u.Eng, u.Scene)
		dropCard.Move(dropTargetXY, dropTargetDimensions, u.Eng)
		u.Cards = append(u.Cards, dropCard)
	}
	// third drop target
	dropTargetX = (u.WindowSize.X - u.CardDim.X) / 2
	if u.WindowSize.X < u.WindowSize.Y {
		dropTargetY = u.WindowSize.Y/2 - 3*u.CardDim.Y/2 - u.Padding
	} else {
		dropTargetY = u.WindowSize.Y/2 - u.Padding - u.CardDim.Y
	}
	dropTargetXY = coords.MakeVec(dropTargetX, dropTargetY)
	dropTargetPos = coords.MakePosition(dropTargetXY, dropTargetXY, dropTargetDimensions)
	dropTarget = texture.MakeImgWithoutAlt(dropTargetImage, dropTargetPos, u.Eng, u.Scene)
	u.DropTargets = append(u.DropTargets, dropTarget)
	// card on top of third drop target
	dropCard = u.CurTable.GetTrick()[2]
	if dropCard != nil {
		texture.PopulateCardImage(dropCard, u.Texs, u.Eng, u.Scene)
		dropCard.Move(dropTargetXY, dropTargetDimensions, u.Eng)
		u.Cards = append(u.Cards, dropCard)
	}
	// fourth drop target
	dropTargetY = (u.WindowSize.Y - u.CardDim.Y) / 2
	if u.WindowSize.X < u.WindowSize.Y {
		dropTargetX = u.WindowSize.X/2 + u.Padding
	} else {
		dropTargetX = u.WindowSize.X/2 + u.CardDim.X/2 + u.Padding
	}
	dropTargetXY = coords.MakeVec(dropTargetX, dropTargetY)
	dropTargetPos = coords.MakePosition(dropTargetXY, dropTargetXY, dropTargetDimensions)
	dropTarget = texture.MakeImgWithoutAlt(dropTargetImage, dropTargetPos, u.Eng, u.Scene)
	u.DropTargets = append(u.DropTargets, dropTarget)
	// card on top of fourth drop target
	dropCard = u.CurTable.GetTrick()[3]
	if dropCard != nil {
		texture.PopulateCardImage(dropCard, u.Texs, u.Eng, u.Scene)
		dropCard.Move(dropTargetXY, dropTargetDimensions, u.Eng)
		u.Cards = append(u.Cards, dropCard)
	}
	// adding 4 player icons, text, and device icons
	playerIconImage := u.CurTable.GetPlayers()[0].GetImage()
	playerIconX := (u.WindowSize.X - u.PlayerIconDim.X) / 2
	playerIconY := u.WindowSize.Y - u.TableCardDim.Y - u.BottomPadding - u.Padding - u.PlayerIconDim.Y
	playerIconXY := coords.MakeVec(playerIconX, playerIconY)
	playerIconPos := coords.MakePosition(playerIconXY, playerIconXY, u.PlayerIconDim)
	playerIcon := texture.MakeImgWithoutAlt(playerIconImage, playerIconPos, u.Eng, u.Scene)
	if u.Debug {
		u.Buttons = append(u.Buttons, playerIcon)
	} else {
		u.BackgroundImgs = append(u.BackgroundImgs, playerIcon)
	}
	// player 0's name
	center := coords.MakeVec(playerIconX+u.PlayerIconDim.X/2, playerIconY-30)
	textImgs := texture.MakeStringImgCenterAlign(u.CurTable.GetPlayers()[0].GetName(), "", "", true, center, scaler, maxWidth, u)
	for _, img := range textImgs {
		u.BackgroundImgs = append(u.BackgroundImgs, img)
	}
	// player 0's device icon
	deviceIconImage := u.Texs["phoneIcon.png"]
	deviceIconDim := coords.MakeVec(u.PlayerIconDim.X/2, u.PlayerIconDim.Y/2)
	deviceIconX := playerIconXY.X + u.PlayerIconDim.X
	deviceIconY := playerIconXY.Y
	deviceIconXY := coords.MakeVec(deviceIconX, deviceIconY)
	deviceIconPos := coords.MakePosition(deviceIconXY, deviceIconXY, deviceIconDim)
	deviceIcon := texture.MakeImgWithoutAlt(deviceIconImage, deviceIconPos, u.Eng, u.Scene)
	u.BackgroundImgs = append(u.BackgroundImgs, deviceIcon)
	// player 1's icon
	playerIconImage = u.CurTable.GetPlayers()[1].GetImage()
	playerIconX = u.BottomPadding
	playerIconY = (u.WindowSize.Y+2*u.BottomPadding+u.PlayerIconDim.Y-(float32(len(u.CurTable.GetPlayers()[1].GetHand()))*(u.TableCardDim.Y-u.Overlap.Y)+u.TableCardDim.Y))/2 - u.PlayerIconDim.Y - u.Padding
	playerIconXY = coords.MakeVec(playerIconX, playerIconY)
	playerIconPos = coords.MakePosition(playerIconXY, playerIconXY, u.PlayerIconDim)
	playerIcon = texture.MakeImgWithoutAlt(playerIconImage, playerIconPos, u.Eng, u.Scene)
	if u.Debug {
		u.Buttons = append(u.Buttons, playerIcon)
	} else {
		u.BackgroundImgs = append(u.BackgroundImgs, playerIcon)
	}
	// player 1's name
	start := coords.MakeVec(playerIconX, playerIconY-30)
	textImgs = texture.MakeStringImgLeftAlign(u.CurTable.GetPlayers()[1].GetName(), "", "", true, start, scaler, maxWidth, u)
	for _, img := range textImgs {
		u.BackgroundImgs = append(u.BackgroundImgs, img)
	}
	// player 1's device icon
	deviceIconImage = u.Texs["tabletIcon.png"]
	deviceIconX = playerIconXY.X + u.PlayerIconDim.X
	deviceIconY = playerIconXY.Y + u.PlayerIconDim.Y - deviceIconDim.Y
	deviceIconXY = coords.MakeVec(deviceIconX, deviceIconY)
	deviceIconPos = coords.MakePosition(deviceIconXY, deviceIconXY, deviceIconDim)
	deviceIcon = texture.MakeImgWithoutAlt(deviceIconImage, deviceIconPos, u.Eng, u.Scene)
	u.BackgroundImgs = append(u.BackgroundImgs, deviceIcon)
	// player 2's icon
	playerIconImage = u.CurTable.GetPlayers()[2].GetImage()
	playerIconX = (u.WindowSize.X - u.PlayerIconDim.X) / 2
	playerIconY = u.TopPadding + u.TableCardDim.Y + u.Padding
	playerIconXY = coords.MakeVec(playerIconX, playerIconY)
	playerIconPos = coords.MakePosition(playerIconXY, playerIconXY, u.PlayerIconDim)
	playerIcon = texture.MakeImgWithoutAlt(playerIconImage, playerIconPos, u.Eng, u.Scene)
	if u.Debug {
		u.Buttons = append(u.Buttons, playerIcon)
	} else {
		u.BackgroundImgs = append(u.BackgroundImgs, playerIcon)
	}
	// player 3's name
	center = coords.MakeVec(playerIconX+u.PlayerIconDim.X/2, playerIconY+u.PlayerIconDim.Y+5)
	textImgs = texture.MakeStringImgCenterAlign(u.CurTable.GetPlayers()[2].GetName(), "", "", true, center, scaler, maxWidth, u)
	for _, img := range textImgs {
		u.BackgroundImgs = append(u.BackgroundImgs, img)
	}
	// player 2's device icon
	deviceIconImage = u.Texs["watchIcon.png"]
	deviceIconX = playerIconXY.X + u.PlayerIconDim.X
	deviceIconY = playerIconXY.Y + u.PlayerIconDim.Y - deviceIconDim.Y
	deviceIconXY = coords.MakeVec(deviceIconX, deviceIconY)
	deviceIconPos = coords.MakePosition(deviceIconXY, deviceIconXY, deviceIconDim)
	deviceIcon = texture.MakeImgWithoutAlt(deviceIconImage, deviceIconPos, u.Eng, u.Scene)
	u.BackgroundImgs = append(u.BackgroundImgs, deviceIcon)
	// player 3's icon
	playerIconImage = u.CurTable.GetPlayers()[3].GetImage()
	playerIconX = u.WindowSize.X - u.BottomPadding - u.PlayerIconDim.X
	playerIconY = (u.WindowSize.Y+2*u.BottomPadding+u.PlayerIconDim.Y-(float32(len(u.CurTable.GetPlayers()[3].GetHand()))*(u.TableCardDim.Y-u.Overlap.Y)+u.TableCardDim.Y))/2 - u.PlayerIconDim.Y - u.Padding
	playerIconXY = coords.MakeVec(playerIconX, playerIconY)
	playerIconPos = coords.MakePosition(playerIconXY, playerIconXY, u.PlayerIconDim)
	playerIcon = texture.MakeImgWithoutAlt(playerIconImage, playerIconPos, u.Eng, u.Scene)
	if u.Debug {
		u.Buttons = append(u.Buttons, playerIcon)
	} else {
		u.BackgroundImgs = append(u.BackgroundImgs, playerIcon)
	}
	// player 3's name
	end := coords.MakeVec(playerIconX+u.PlayerIconDim.X, playerIconY-30)
	textImgs = texture.MakeStringImgRightAlign(u.CurTable.GetPlayers()[3].GetName(), "", "", true, end, scaler, maxWidth, u)
	for _, img := range textImgs {
		u.BackgroundImgs = append(u.BackgroundImgs, img)
	}
	// player 3's device icon
	deviceIconImage = u.Texs["laptopIcon.png"]
	deviceIconX = playerIconXY.X - deviceIconDim.X
	deviceIconY = playerIconXY.Y + u.PlayerIconDim.Y - deviceIconDim.Y
	deviceIconXY = coords.MakeVec(deviceIconX, deviceIconY)
	deviceIconPos = coords.MakePosition(deviceIconXY, deviceIconXY, deviceIconDim)
	deviceIcon = texture.MakeImgWithoutAlt(deviceIconImage, deviceIconPos, u.Eng, u.Scene)
	u.BackgroundImgs = append(u.BackgroundImgs, deviceIcon)
	// adding cards
	for _, p := range u.CurTable.GetPlayers() {
		hand := p.GetHand()
		for i, c := range hand {
			texture.PopulateCardImage(c, u.Texs, u.Eng, u.Scene)
			cardIndex := coords.MakeVec(float32(len(hand)), float32(i))
			reposition.SetCardPositionTable(c, p.GetPlayerIndex(), cardIndex, u)
			u.Eng.SetSubTex(c.GetNode(), c.GetBack())
			u.TableCards = append(u.TableCards, c)
		}
	}
	if u.Debug {
		addDebugBar(u)
	}
}

// Decides which view of the player's hand to load based on what steps of the round they have completed
func LoadPassOrTakeOrPlay(u *uistate.UIState) {
	p := u.CurTable.GetPlayers()[u.CurPlayerIndex]
	if p.GetDoneTaking() || u.CurTable.GetDir() == direction.None {
		loadPlayView(u)
	} else if p.GetDonePassing() {
		loadTakeView(u)
	} else {
		loadPassView(u)
	}
}

// Score View: Shows current player standings at the end of every round, including the end of the game
func LoadScoreView(winners []int, u *uistate.UIState) {
	u.CurView = uistate.Score
	resetImgs(u)
	resetScene(u)
	// adding score text
	textImgs := make([]*staticimg.StaticImg, 0)
	center := coords.MakeVec(u.WindowSize.X/2, u.WindowSize.Y/4)
	scaler := float32(4)
	maxWidthBanner := u.WindowSize.X - 2*u.Padding
	maxWidthScores := u.WindowSize.X / 2
	if len(winners) == 0 {
		textImgs = texture.MakeStringImgCenterAlign("Current Standings", "", "", true, center, scaler, maxWidthBanner, u)
	} else {
		str := "Game over! Congratulations " + u.CurTable.GetPlayers()[winners[0]].GetName()
		for i := 1; i < len(winners); i++ {
			str += " and " + u.CurTable.GetPlayers()[winners[i]].GetName()
		}
		str += "!"
		textImgs = texture.MakeStringImgCenterAlign(str, "", "", true, center, scaler, maxWidthBanner, u)
	}
	left := coords.MakeVec(u.WindowSize.X/4, center.Y+40)
	for _, p := range u.CurTable.GetPlayers() {
		str := p.GetName() + ": " + strconv.Itoa(p.GetScore())
		newTextImgs := texture.MakeStringImgLeftAlign(str, "", "", true, left, scaler, maxWidthScores, u)
		textImgs = append(textImgs, newTextImgs...)
		left = coords.MakeVec(left.X, left.Y+30)
	}
	for _, img := range textImgs {
		u.BackgroundImgs = append(u.BackgroundImgs, img)
	}
	// adding play button to move to next round
	pressedImg := u.Texs["playPressed.png"]
	unpressedImg := u.Texs["playUnpressed.png"]
	buttonDim := coords.MakeVec(2*u.CardDim.X, u.CardDim.Y)
	buttonX := (u.WindowSize.X - u.CardDim.X) / 2
	buttonY := u.WindowSize.Y - u.CardDim.Y - u.BottomPadding
	buttonXY := coords.MakeVec(buttonX, buttonY)
	buttonPos := coords.MakePosition(buttonXY, buttonXY, buttonDim)
	button := texture.MakeImgWithAlt(unpressedImg, pressedImg, buttonPos, true, u.Eng, u.Scene)
	u.Buttons = append(u.Buttons, button)
}

// Pass View: Shows player's hand and allows them to pass cards
func loadPassView(u *uistate.UIState) {
	u.CurView = uistate.Pass
	resetImgs(u)
	resetScene(u)
	addHeader(u)
	addGrayPassBar(u)
	addPassDrops(u)
	addHand(u)
	if u.Debug {
		addDebugBar(u)
	}
}

// Take View: Shows player's hand and allows them to take the cards that have been passed to them
func loadTakeView(u *uistate.UIState) {
	u.CurView = uistate.Take
	resetImgs(u)
	resetScene(u)
	addHeader(u)
	addGrayTakeBar(u)
	addHand(u)
	moveTakeCards(u)
	if u.Debug {
		addDebugBar(u)
	}
}

// Play View: Shows player's hand and allows them to play cards
func loadPlayView(u *uistate.UIState) {
	u.CurView = uistate.Play
	resetImgs(u)
	resetScene(u)
	addHeader(u)
	addHand(u)
	if u.Debug {
		addDebugBar(u)
	}
}

func addHeader(u *uistate.UIState) {
	// adding blue banner
	headerImage := u.Texs["RoundedRectangle-DBlue.png"]
	headerXY := coords.MakeVec(0, -10)
	headerWidth := u.WindowSize.X
	headerHeight := float32(20)
	headerDimensions := coords.MakeVec(headerWidth, headerHeight)
	headerPos := coords.MakePosition(headerXY, headerXY, headerDimensions)
	header := texture.MakeImgWithoutAlt(headerImage, headerPos, u.Eng, u.Scene)
	u.BackgroundImgs = append(u.BackgroundImgs, header)
}

func addHeaderButton(u *uistate.UIState) {
	// adding blue banner for croupier header
	headerUnpressed := u.Texs["blue.png"]
	headerPressed := u.Texs["bluePressed.png"]
	headerXY := coords.MakeVec(0, 0)
	headerWidth := u.WindowSize.X
	var headerHeight float32
	if 2*u.CardDim.Y < headerWidth/4 {
		headerHeight = 2 * u.CardDim.Y
	} else {
		headerHeight = headerWidth / 4
	}
	headerDimensions := coords.MakeVec(headerWidth, headerHeight)
	headerPos := coords.MakePosition(headerXY, headerXY, headerDimensions)
	header := texture.MakeImgWithAlt(headerUnpressed, headerPressed, headerPos, true, u.Eng, u.Scene)
	u.Buttons = append(u.Buttons, header)
	// adding play button
	playUnpressed := u.Texs["playUnpressed.png"]
	playPressed := u.Texs["playPressed.png"]
	playDim := coords.MakeVec(headerHeight, headerHeight/2)
	playX := (u.WindowSize.X - playDim.X) / 2
	playY := (u.TopPadding + playDim.Y) / 2
	playXY := coords.MakeVec(playX, playY)
	playPos := coords.MakePosition(playXY, playXY, playDim)
	play := texture.MakeImgWithAlt(playUnpressed, playPressed, playPos, true, u.Eng, u.Scene)
	u.Buttons = append(u.Buttons, play)
}

func addGrayPassBar(u *uistate.UIState) {
	// adding gray bar
	grayBarImg := u.Texs["RoundedRectangle-Gray.png"]
	blueBarImg := u.Texs["RoundedRectangle-LBlue.png"]
	grayBarXY := coords.MakeVec(2*u.BottomPadding, 40-u.WindowSize.Y+4*u.BottomPadding)
	grayBarDim := coords.MakeVec(u.WindowSize.X-4*u.BottomPadding, u.WindowSize.Y-4*u.BottomPadding)
	grayBarPos := coords.MakePosition(grayBarXY, grayBarXY, grayBarDim)
	grayBar := texture.MakeImgWithAlt(grayBarImg, blueBarImg, grayBarPos, true, u.Eng, u.Scene)
	u.Other = append(u.Other, grayBar)
	// adding name
	var receivingPlayer int
	switch u.CurTable.GetDir() {
	case direction.Right:
		receivingPlayer = (u.CurPlayerIndex + 3) % u.NumPlayers
	case direction.Left:
		receivingPlayer = (u.CurPlayerIndex + 1) % u.NumPlayers
	case direction.Across:
		receivingPlayer = (u.CurPlayerIndex + 2) % u.NumPlayers
	}
	name := u.CurTable.GetPlayers()[receivingPlayer].GetName()
	color := "Gray"
	altColor := "LBlue"
	center := coords.MakeVec(u.WindowSize.X/2, 5)
	scaler := float32(3)
	maxWidth := u.WindowSize.X
	nameImgs := texture.MakeStringImgCenterAlign(name, color, altColor, true, center, scaler, maxWidth, u)
	u.Other = append(u.Other, nameImgs...)
}

func addGrayTakeBar(u *uistate.UIState) {
	passedCards := u.CurTable.GetPlayers()[u.CurPlayerIndex].GetPassedTo()
	display := len(passedCards) == 0
	// adding gray bar
	grayBarImg := u.Texs["RoundedRectangle-Gray.png"]
	grayBarAlt := u.Texs["RoundedRectangle-LBlue.png"]
	grayBarXY := coords.MakeVec(2*u.BottomPadding, -30)
	topOfHand := u.WindowSize.Y - 5*(u.CardDim.Y+u.Padding) - (2 * u.Padding / 5) - u.BottomPadding
	var grayBarHeight float32
	if display {
		grayBarHeight = 105
	} else {
		grayBarHeight = topOfHand - u.CardDim.Y
	}
	grayBarDim := coords.MakeVec(u.WindowSize.X-4*u.BottomPadding, grayBarHeight)
	grayBarPos := coords.MakePosition(grayBarXY, grayBarXY, grayBarDim)
	grayBar := texture.MakeImgWithAlt(grayBarImg, grayBarAlt, grayBarPos, display, u.Eng, u.Scene)
	u.Other = append(u.Other, grayBar)
	// adding name
	var passingPlayer int
	switch u.CurTable.GetDir() {
	case direction.Right:
		passingPlayer = (u.CurPlayerIndex + 1) % u.NumPlayers
	case direction.Left:
		passingPlayer = (u.CurPlayerIndex + 3) % u.NumPlayers
	case direction.Across:
		passingPlayer = (u.CurPlayerIndex + 2) % u.NumPlayers
	}
	name := u.CurTable.GetPlayers()[passingPlayer].GetName()
	color := "Gray"
	nameAltColor := "LBlue"
	awaitingAltColor := "None"
	center := coords.MakeVec(u.WindowSize.X/2, 5)
	scaler := float32(3)
	maxWidth := u.WindowSize.X
	nameImgs := texture.MakeStringImgCenterAlign(name, color, nameAltColor, display, center, scaler, maxWidth, u)
	u.Other = append(u.Other, nameImgs...)
	center = coords.MakeVec(center.X, center.Y+40)
	scaler = float32(5)
	awaitingImgs := texture.MakeStringImgCenterAlign("Awaiting pass", color, awaitingAltColor, display, center, scaler, maxWidth, u)
	u.Other = append(u.Other, awaitingImgs...)
	// adding cards to take, if cards have been passed
	if !display {
		u.Cards = append(u.Cards, passedCards...)
	}
}

func moveTakeCards(u *uistate.UIState) {
	passedCards := u.CurTable.GetPlayers()[u.CurPlayerIndex].GetPassedTo()
	if len(passedCards) > 0 {
		topOfHand := u.WindowSize.Y - 5*(u.CardDim.Y+u.Padding) - (2 * u.Padding / 5) - u.BottomPadding
		cardY := topOfHand - 3*u.CardDim.Y
		numCards := float32(3)
		cardXStart := (u.WindowSize.X - (numCards*u.CardDim.X + (numCards-1)*u.Padding)) / 2
		for i, c := range passedCards {
			cardX := cardXStart + float32(i)*(u.Padding+u.CardDim.X)
			cardXY := coords.MakeVec(cardX, cardY)
			c.Move(cardXY, u.CardDim, u.Eng)
			reposition.RealignSuit(c.GetSuit(), c.GetInitial().Y, u)
			// invisible drop target holding card
			var emptyTex sprite.SubTex
			dropPos := coords.MakePosition(cardXY, cardXY, u.CardDim)
			d := texture.MakeImgWithoutAlt(emptyTex, dropPos, u.Eng, u.Scene)
			d.SetCardHere(c)
			u.DropTargets = append(u.DropTargets, d)
		}
	}
}

func addPassDrops(u *uistate.UIState) {
	// adding blue background banner for drop targets
	topOfHand := u.WindowSize.Y - 5*(u.CardDim.Y+u.Padding) - (2 * u.Padding / 5) - u.BottomPadding
	passBannerImage := u.Texs["Rectangle-LBlue.png"]
	passBannerX := 6 * u.BottomPadding
	passBannerY := topOfHand - (2 * u.Padding)
	passBannerWidth := u.WindowSize.X - 8*u.BottomPadding
	passBannerHeight := u.CardDim.Y + 2*u.Padding
	passBannerXY := coords.MakeVec(passBannerX, passBannerY)
	passBannerDimensions := coords.MakeVec(passBannerWidth, passBannerHeight)
	passBannerPos := coords.MakePosition(passBannerXY, passBannerXY, passBannerDimensions)
	passBanner := texture.MakeImgWithoutAlt(passBannerImage, passBannerPos, u.Eng, u.Scene)
	u.BackgroundImgs = append(u.BackgroundImgs, passBanner)
	// adding undisplayed pull tab
	pullTabSpotImage := u.Texs["Rectangle-LBlue.png"]
	pullTabImage := u.Texs["VerticalPullTab.png"]
	pullTabSpotX := 2 * u.BottomPadding
	pullTabSpotY := passBannerY
	pullTabSpotWidth := 4 * u.BottomPadding
	pullTabSpotHeight := u.CardDim.Y + 2*u.Padding
	pullTabSpotXY := coords.MakeVec(pullTabSpotX, pullTabSpotY)
	pullTabSpotDimensions := coords.MakeVec(pullTabSpotWidth, pullTabSpotHeight)
	pullTabSpotPos := coords.MakePosition(pullTabSpotXY, pullTabSpotXY, pullTabSpotDimensions)
	pullTabSpot := texture.MakeImgWithAlt(pullTabImage, pullTabSpotImage, pullTabSpotPos, false, u.Eng, u.Scene)
	u.Buttons = append(u.Buttons, pullTabSpot)
	// adding text
	textLeft := coords.MakeVec(pullTabSpotX+pullTabSpotWidth/2, passBannerY-20)
	scaler := float32(5)
	maxWidth := passBannerWidth
	text := texture.MakeStringImgLeftAlign("Pass:", "", "None", true, textLeft, scaler, maxWidth, u)
	u.BackgroundImgs = append(u.BackgroundImgs, text...)
	// adding drop targets
	dropTargetImage := u.Texs["trickDrop.png"]
	dropTargetDimensions := u.CardDim
	dropTargetY := passBannerY + u.Padding
	numDropTargets := float32(3)
	dropTargetXStart := (u.WindowSize.X - (numDropTargets*dropTargetDimensions.X + (numDropTargets-1)*u.Padding)) / 2
	for i := 0; i < int(numDropTargets); i++ {
		dropTargetX := dropTargetXStart + float32(i)*(u.Padding+dropTargetDimensions.X)
		dropTargetXY := coords.MakeVec(dropTargetX, dropTargetY)
		dropTargetPos := coords.MakePosition(dropTargetXY, dropTargetXY, dropTargetDimensions)
		newTarget := texture.MakeImgWithoutAlt(dropTargetImage, dropTargetPos, u.Eng, u.Scene)
		u.DropTargets = append(u.DropTargets, newTarget)
	}
}

func addHand(u *uistate.UIState) {
	p := u.CurTable.GetPlayers()[u.CurPlayerIndex]
	u.Cards = append(u.Cards, p.GetHand()...)
	sort.Sort(card.CardSorter(u.Cards))
	clubCount := 0
	diamondCount := 0
	spadeCount := 0
	heartCount := 0
	for i := 0; i < len(u.Cards); i++ {
		switch u.Cards[i].GetSuit() {
		case card.Club:
			clubCount++
		case card.Diamond:
			diamondCount++
		case card.Spade:
			spadeCount++
		case card.Heart:
			heartCount++
		}
	}
	suitCounts := []int{clubCount, diamondCount, spadeCount, heartCount}
	// adding gray background banners for each suit
	suitBannerImage := u.Texs["gray.jpeg"]
	suitBannerX := float32(0)
	suitBannerWidth := u.WindowSize.X
	suitBannerHeight := u.CardDim.Y + (4 * u.Padding / 5)
	suitBannerDim := coords.MakeVec(suitBannerWidth, suitBannerHeight)
	for i := 0; i < u.NumSuits; i++ {
		suitBannerY := u.WindowSize.Y - float32(i+1)*(u.CardDim.Y+u.Padding) - (2 * u.Padding / 5) - u.BottomPadding
		suitBannerXY := coords.MakeVec(suitBannerX, suitBannerY)
		suitBannerPos := coords.MakePosition(suitBannerXY, suitBannerXY, suitBannerDim)
		suitBanner := texture.MakeImgWithoutAlt(suitBannerImage, suitBannerPos, u.Eng, u.Scene)
		u.BackgroundImgs = append(u.BackgroundImgs, suitBanner)
	}
	// adding suit image to any empty suit in hand
	for i, c := range suitCounts {
		var texKey string
		switch i {
		case 0:
			texKey = "Club.png"
		case 1:
			texKey = "Diamond.png"
		case 2:
			texKey = "Spade.png"
		case 3:
			texKey = "Heart.png"
		}
		suitIconImage := u.Texs[texKey]
		suitIconAlt := u.Texs["gray.png"]
		suitIconX := u.WindowSize.X/2 - u.CardDim.X/3
		suitIconY := u.WindowSize.Y - float32(4-i)*(u.CardDim.Y+u.Padding) + u.CardDim.Y/6 - u.BottomPadding
		suitIconWidth := 2 * u.CardDim.X / 3
		suitIconHeight := 2 * u.CardDim.Y / 3
		display := c == 0
		suitIconXY := coords.MakeVec(suitIconX, suitIconY)
		suitIconDim := coords.MakeVec(suitIconWidth, suitIconHeight)
		suitIconPos := coords.MakePosition(suitIconXY, suitIconXY, suitIconDim)
		suitIcon := texture.MakeImgWithAlt(suitIconImage, suitIconAlt, suitIconPos, display, u.Eng, u.Scene)
		u.EmptySuitImgs = append(u.EmptySuitImgs, suitIcon)
	}
	// adding clubs
	for i := 0; i < clubCount; i++ {
		numInSuit := i
		texture.PopulateCardImage(u.Cards[i], u.Texs, u.Eng, u.Scene)
		reposition.SetCardPositionHand(u.Cards[i], numInSuit, suitCounts, u)
	}
	// adding diamonds
	for i := clubCount; i < clubCount+diamondCount; i++ {
		numInSuit := i - clubCount
		texture.PopulateCardImage(u.Cards[i], u.Texs, u.Eng, u.Scene)
		reposition.SetCardPositionHand(u.Cards[i], numInSuit, suitCounts, u)
	}
	// adding spades
	for i := clubCount + diamondCount; i < clubCount+diamondCount+spadeCount; i++ {
		numInSuit := i - clubCount - diamondCount
		texture.PopulateCardImage(u.Cards[i], u.Texs, u.Eng, u.Scene)
		reposition.SetCardPositionHand(u.Cards[i], numInSuit, suitCounts, u)
	}
	// adding hearts
	for i := clubCount + diamondCount + spadeCount; i < clubCount+diamondCount+spadeCount+heartCount; i++ {
		numInSuit := i - clubCount - diamondCount - spadeCount
		texture.PopulateCardImage(u.Cards[i], u.Texs, u.Eng, u.Scene)
		reposition.SetCardPositionHand(u.Cards[i], numInSuit, suitCounts, u)
	}
}

func resetImgs(u *uistate.UIState) {
	u.Cards = make([]*card.Card, 0)
	u.TableCards = make([]*card.Card, 0)
	u.BackgroundImgs = make([]*staticimg.StaticImg, 0)
	u.EmptySuitImgs = make([]*staticimg.StaticImg, 0)
	u.DropTargets = make([]*staticimg.StaticImg, 0)
	u.Buttons = make([]*staticimg.StaticImg, 0)
	u.Other = make([]*staticimg.StaticImg, 0)
}

func resetScene(u *uistate.UIState) {
	u.Scene = &sprite.Node{}
	u.Eng.Register(u.Scene)
	u.Eng.SetTransform(u.Scene, f32.Affine{
		{1, 0, 0},
		{0, 1, 0},
	})
}

func addDebugBar(u *uistate.UIState) {
	buttonDim := u.CardDim
	debugTableImage := u.Texs["BakuSquare.png"]
	debugTableX := u.WindowSize.X - buttonDim.X
	debugTableY := u.WindowSize.Y - buttonDim.Y
	debugTableXY := coords.MakeVec(debugTableX, debugTableY)
	debugTablePos := coords.MakePosition(debugTableXY, debugTableXY, buttonDim)
	debugTable := texture.MakeImgWithoutAlt(debugTableImage, debugTablePos, u.Eng, u.Scene)
	u.Buttons = append(u.Buttons, debugTable)
	debugPassImage := u.Texs["Clubs-2.png"]
	debugPassX := u.WindowSize.X - 2*buttonDim.X
	debugPassY := u.WindowSize.Y - buttonDim.Y
	debugPassXY := coords.MakeVec(debugPassX, debugPassY)
	debugPassPos := coords.MakePosition(debugPassXY, debugPassXY, buttonDim)
	debugPass := texture.MakeImgWithoutAlt(debugPassImage, debugPassPos, u.Eng, u.Scene)
	u.Buttons = append(u.Buttons, debugPass)
}