// Draw func
func (player *Player) Draw(screen *termloop.Screen) {
	if player.state != Dead {
		// Keep player in bounds
		x, y := player.entity.Position()
		if x < 0 {
			x = 0
		} else if x >= width {
			x = width - 1
		}

		if y < 0 {
			y = 0
		} else if y >= height {
			y = height - 1
		}

		player.entity.SetPosition(x, y)

		// Draw player
		player.entity.Draw(screen)
	}

	screenWidth, screenHeight := screen.Size()
	level.SetOffset((screenWidth-width)/2, (screenHeight-height)/2)
}

func (i *Iceblock) Draw(s *tl.Screen) {

	// if the iceblock has a direction
	if i.direction != NONE {
		// then move it in the direction specified
		i.time += s.TimeDelta()
		if i.time > i.update {
			switch i.direction {
			case RIGHT:
				i.r.SetPosition(i.endPos.x+1, i.endPos.y)
				break
			case LEFT:
				i.r.SetPosition(i.endPos.x-1, i.endPos.y)
				break
			case UP:
				i.r.SetPosition(i.endPos.x, i.endPos.y-1)
				break
			case DOWN:
				i.r.SetPosition(i.endPos.x, i.endPos.y+1)
			}
			// updated its previous position
			i.endPos.x, i.endPos.y = i.r.Position()
			i.time -= i.update
		}
	}
	i.r.Draw(s)
}

func (h *hud) Draw(screen *tl.Screen) {
	w, _ := screen.Size()
	h.offsetX = w - 80
mainLoop:
	for {
		select {
		case str := <-h.com:
			i := hudMem - 1
			for i > 0 {
				h.toDisp[i] = h.toDisp[i-1]
				if h.toDisp[i] != nil {
					h.toDisp[i].SetPosition(h.offsetX, h.offsetY+i+2)
				}
				i--
			}
			h.toDisp[0] = tl.NewText(h.offsetX, h.offsetY+2, str, Fg, Bg)
		default:
			break mainLoop
		}
	}
	for _, v := range h.toDisp {
		v.Draw(screen)
	}
	h.header.SetPosition(h.offsetX, h.offsetY)
	h.header2.SetPosition(h.offsetX, h.offsetY+1)
	h.header.Draw(screen)
	h.header2.Draw(screen)
}

func (player *Player) Draw(s *tl.Screen) {
	screenWidthidth, screenh := s.Size()
	x := player.sprite.x + screenWidthidth/2 - 30
	y := player.sprite.y + screenh - 25
	bg := tl.NewRectangle(x, y, x+20, y+10, StatsBG)
	bg.Draw(s)

	health := tl.NewText(x+1, y+1, fmt.Sprintf("%3.f%% health", float32(player.health)/float32(player.maxHealth)*100), tl.ColorRed, StatsBG)
	health.Draw(s)

	mana := tl.NewText(x+27, y+1, fmt.Sprintf("%3.f%% mana", float32(player.mana)/float32(player.maxMana)*100), tl.ColorBlue, StatsBG)
	mana.Draw(s)

	gold := tl.NewText(x+1, y+12, fmt.Sprintf("%d gold", player.gold), tl.ColorYellow, StatsBG)
	gold.Draw(s)

	experience := tl.NewText(x+29, y+12, fmt.Sprintf("%3.f%% xp", float32(player.experience)/float32(player.experienceToLevel)*100), tl.ColorMagenta, StatsBG)
	experience.Draw(s)

	if player.isCasting {
		player.isCasting = false

		newSpellEffect := NewSpellEffect(player.sprite, player.spellCanvases[player.sprite.direction], player.sprite.level)
		player.sprite.level.AddEntity(newSpellEffect)
	}

	e := tl.NewEntityFromCanvas(x+12, y+1, *player.portrait)
	e.Draw(s)
}

func (sq *Square) Draw(screen *tl.Screen) {
	if sq.visible {
		x, y := sq.getPosition()
		for i := 0; i < 5; i++ {
			screen.RenderCell(x+i, y, &sq.canvas[i])
		}
	}
}

func (text *StartLevel) Draw(screen *tl.Screen) {
	screenWidth, screenHeight := screen.Size()
	text.message.SetPosition(screenWidth/2, screenHeight/2)
	text.message.Draw(screen)
	text.instructions.SetPosition(screenWidth/2-5, screenHeight/2+1)
	text.instructions.Draw(screen)
	text.instructions2.SetPosition(screenWidth/2-5, screenHeight/2+2)
	text.instructions2.Draw(screen)
}

func (b *Block) Draw(s *tl.Screen) {
	if l, ok := b.g.Level().(*tl.BaseLevel); ok {
		// Set the level offset so the player is always in the
		// center of the screen. This simulates moving the camera.
		sw, sh := s.Size()
		x, y := b.r.Position()
		l.SetOffset(sw/2-x, sh/2-y)
	}
	b.r.Draw(s)
}

func (s *Snake) Draw(screen *tl.Screen) {
	s.bodyCollideDetect(s.px, s.py)
	// check border collision
	w, h := screen.Size()

	if s.px > w {
		s.px = 0
	} else if s.px < 0 {
		s.px = w
	}

	if s.py > h {
		s.py = 0
	} else if s.py < 0 {
		s.py = h
	}

	s.head.Draw(screen)
	s.drawBody(screen)

	if s.stop {
		return
	}

	// Control the speed.
	update := time.Now()
	delta := update.Sub(s.update).Seconds()

	if delta <= 1 {
		return
	} else {
		s.update = update
	}

	x, y := s.head.Position()
	switch s.dir {
	case KeyArrowRight:
		x += 1
		break
	case KeyArrowDown:
		y += 1
		break
	case KeyArrowLeft:
		x -= 1
		break
	case KeyArrowUp:
		y -= 1
		break
	}

	s.head.SetPosition(x, y)
	s.px = x
	s.py = y
	s.moveBody()
}

func (r *RemainingTime) Draw(s *tl.Screen) {
	if Status == 1 {
		r.t = math.Max(r.t-s.TimeDelta(), 0)
		if r.t == 0 {
			Status = 0
			r.e.SetText("Time up!")
		} else {
			if Response == 1 {
				s, _ := strconv.Atoi(r.s.Text())
				s = s + 1
				if s%5 == 0 {
					r.t = r.t + 1
				}
				r.s.SetText(strconv.Itoa(s))
				switch s {
				case 10:
					r.m.SetText("You've got it!")
				case 20:
					r.m.SetText("Keep going!")
				case 30:
					r.m.SetText("You're doing great!")
				case 40:
					r.m.SetText("You rock!")
				case 50:
					r.m.SetText("Don't stop!")
				case 60:
					r.m.SetText("I like your style!")
				case 70:
					r.m.SetText("Awesome!")
				case 80:
					r.m.SetText("How do you do that?")
				case 90:
					r.m.SetText("Don't ever stop!!")
				case 100:
					r.m.SetText("I'm really impressed.")
				case 150:
					r.m.SetText("You're really still here?")
				case 200:
					r.m.SetText("That's incredible!")
				}
			} else if Response == 2 {
				Status = 0
				r.e.SetText("Game Over")
			}
		}
		Response = 0
		r.r.SetText(fmt.Sprintf("%.3f", r.t))
	}
	r.r.Draw(s)
	r.s.Draw(s)
	r.m.Draw(s)
	r.e.Draw(s)
}

func (player *Player) Draw(screen *tl.Screen) {
	screenWidth, screenHeight := screen.Size()
	levelX, levelY := player.level.Offset()
	x, y := player.entity.Position()
	nearEdgeX := x+levelX < screenWidth/5 || x+levelX > (screenWidth-screenWidth/5)
	nearEdgeY := y+levelY < screenHeight/5 || y+levelY > (screenHeight-screenHeight/5)

	if nearEdgeX || nearEdgeY {
		player.level.SetOffset(screenWidth/2-x, screenHeight/2-y)
	}
	player.entity.Draw(screen)
}

func (food *Food) Draw(screen *tl.Screen) {
	if food.x == -1 {
		sx, sw := screen.Size()
		rx := random(1, sx)
		ry := random(1, sw)
		food.x = rx
		food.y = ry
		food.entity.SetPosition(rx, ry)
	}

	food.entity.Draw(screen)
}

func (w *welcome) Draw(screen *tl.Screen) {
	if !w.done {
		width, height := screen.Size()
		w.game.Screen().Level().(*tl.BaseLevel).SetOffset(width/2-(len(header[0])/2), height/2-(len(header)/2))
		for _, v := range w.header {
			v.Draw(screen)
		}
		w.msg.Draw(screen)
		w.choices[w.selected].SetColor(Bg, Fg)
		for _, v := range w.choices {
			v.Draw(screen)
		}
	} else {
	}
}

func (b *board) Draw(screen *tl.Screen) {
	if b.wel.done {
		b.initPlayers()
		w, h := screen.Size()
		b.level.SetOffset(w/2-((boardSize*tileSizeX)/2), h/2-((boardSize*tileSizeY)/2))
		b.tilesDisp[b.sY][b.sX].selected()
		if (b.turn == AI1 || b.turn == AI2) && b.state != WINP1 && b.state != WINP2 {
			b.handleAIInput()
		}
		for _, tY := range b.tilesDisp {
			for _, tX := range tY {
				tX.Draw(screen)
			}
		}
	}
	//TODO if b.state == WINP1 || b.state == WINP2 {
	// highlight win
}

func (body *Body) Draw(s *tl.Screen) {
	// border collision detect
	w, h := s.Size()

	if body.px > w {
		body.px = 0
	} else if body.px < 0 {
		body.px = w
	}

	if body.py > h {
		body.py = 0
	} else if body.py < 0 {
		body.py = h
	}

	body.entity.Draw(s)
}

func (gamestate *GameState) StartLevel(levelIndex int, screen *tl.Screen) {
	gamestate.LevelIndex = levelIndex
	gamestate.Level = gamestate.CreateLevelByIndex()

	gamestate.Bullets = make([]*Bullet, 0)

	gamestate.Player = NewPlayer(gamestate.Level.StartX, gamestate.Level.StartY)
	gamestate.Level.AddEntity(gamestate.Player)

	screen.SetLevel(gamestate.Level)

	screen.AddEntity(gamestate.Player.Score)
	screen.AddEntity(gamestate.Player.Level)
	screen.AddEntity(gamestate.Player.Health)

	// animate the beasts
	go func() {
		for {
			for _, enemy := range TheGameState.Level.Enemies {
				enemy.Animate()
			}
			time.Sleep(500 * time.Millisecond)
		}
	}()
}

// Handles player movement and food spawn rate.
func (player *Player) Update(screen *tl.Screen) {
	player.snakeTime += screen.TimeDelta()
	if player.snakeTime > snakeRate {
		player.snakeTime -= snakeRate

		player.prevX, player.prevY = player.Position()
		switch player.direction {
		case "right":
			player.SetPosition(player.prevX+1, player.prevY)
		case "left":
			player.SetPosition(player.prevX-1, player.prevY)
		case "up":
			player.SetPosition(player.prevX, player.prevY-1)
		case "down":
			player.SetPosition(player.prevX, player.prevY+1)
		}

		player.SnakeMovement()
	}

	player.spawnTime += screen.TimeDelta()
	if player.spawnTime > spawnRate {
		player.spawnTime -= spawnRate

		screenWidth, screenHeight := screen.Size()
		rando := rand.New(rand.NewSource(time.Now().UnixNano()))
		spawnX, spawnY := rando.Intn(screenWidth), rando.Intn(screenHeight)
		screen.Level().AddEntity(tl.NewRectangle(spawnX, spawnY, 1, 1, tl.ColorGreen))

		game.Log("Spawn at (%d,%d)", spawnX, spawnY)
	}

	//Check box boundaries
	playerX, playerY := player.Position()
	screenWidth, screenHeight := game.Screen().Size()

	//<= is used on the upper-boundaries to prevent the player from disappearing offscreen
	//by one square
	//(Funnily enough, when player.snake is more than one unit long, just stopping the player at
	//the boundaries also causes a game over state because the tail slides into the head)
	if playerX < 0 || playerX >= screenWidth {
		GameOver()
	}
	if playerY < 0 || playerY >= screenHeight {
		GameOver()
	}
}

// Draw draws the Dialog to the Screen s.
func (d *Dialog) Draw(s *termloop.Screen) {
	width, height := d.Size()

	// Render shadow
	for x := 1; x < width; x++ {
		s.RenderCell(d.x+x, d.y+height, &termloop.Cell{Ch: '▒', Fg: d.fg, Bg: termloop.ColorDefault})
	}
	for y := 1; y < height; y++ {
		s.RenderCell(d.x+width, d.y+y, &termloop.Cell{Ch: '▒', Fg: d.fg, Bg: termloop.ColorDefault})
	}
	s.RenderCell(d.x+width, d.y+height, &termloop.Cell{Ch: '▒', Fg: d.fg, Bg: termloop.ColorDefault})

	// Render content
	for x := 0; x < height; x++ {
		for y := 0; y < width; y++ {
			s.RenderCell(d.x+y, d.y+x, &d.canvas[x][y])
		}
	}
}

func (w *word) Draw(s *tl.Screen) {
	for i, ch := range w.str {
		if w.startedBy == 0 {
			s.RenderCell(w.x+i, w.y, &tl.Cell{Fg: w.fgTodo, Bg: tl.ColorDefault, Ch: ch})
		} else {
			var bg tl.Attr
			if w.startedBy == pc {
				bg = w.bgPlayer
			} else {
				bg = w.bgGoroutine
			}
			if i < w.completedChars {
				s.RenderCell(w.x+i, w.y, &tl.Cell{Fg: w.fgComplete, Bg: bg, Ch: ch})
			} else {
				s.RenderCell(w.x+i, w.y, &tl.Cell{Fg: w.fgTodo, Bg: bg, Ch: ch})
			}
		}
	}
}

func (player *Player) Draw(screen *tl.Screen) {
	screenWidth, screenHeight := screen.Size()
	x, y := player.entity.Position()
	TheGameState.Level.SetOffset(screenWidth/2-x, screenHeight/2-y)
	player.entity.Draw(screen)
}

func (l *gameLevel) Draw(screen *tl.Screen) {
	l.Level.Draw(screen)

	if time.Now().After(l.garbageCollectEndsAt) {
		for _, i := range l.gt.items {
			i.Tick(l)
		}
	}

	sw, sh := screen.Size()
	gameLost := false
	gameWon := false
	totalComplete := 0
	for _, w := range l.words {
		w.Update()
		if !w.Complete() && w.y > sh-3 {
			gameLost = true
		}
		if w.Complete() {
			totalComplete++
		}
	}
	if totalComplete == len(l.words) {
		gameWon = true
	}
	if l.currentWord != nil && l.currentWord.Complete() {
		l.currentWord = nil
	}
	var possibleWords []int
	for i, w := range l.words {
		if !w.Complete() && w.startedBy == 0 {
			possibleWords = append(possibleWords, i)
		}
	}

	if l.currentWord == nil && len(possibleWords) > 0 {
		l.currentWord = l.words[possibleWords[rand.Intn(len(possibleWords))]]
		l.currentWord.startedBy = pc
	}

	if l.gt.stats.GarbageCollect() {
		l.gt.stats.Garbage = 0
		if l.gt.stats.GoVersion < 1.5 {
			l.garbageCollectEndsAt = time.Now().Add(time.Second * 3)
		} else {
			l.garbageCollectEndsAt = time.Now().Add(time.Second)
		}

	}
	var msg string
	if time.Now().Before(l.garbageCollectEndsAt) {
		msg = fmt.Sprintf("COLLECTING GARBAGE: PLEASE WAIT")
		l.garbageText.SetText(msg)
		bgColor := tl.ColorBlue
		if math.Remainder(float64(time.Now().Sub(l.garbageCollectEndsAt)), float64(time.Second)) > 0.5 {
			bgColor = tl.ColorBlack
		}
		l.garbageText.SetColor(tl.ColorRed, bgColor)
		l.garbageText.SetPosition(sw/2-len(msg)/2, 4)
	} else {
		msg = fmt.Sprintf("Garbage: %d ", l.gt.stats.Garbage)
		l.garbageText.SetText(msg)
		l.garbageText.SetColor(tl.ColorRed, tl.ColorBlue)
		l.garbageText.SetPosition(sw-len(msg), sh-1)
	}

	if l.currentWord != nil {
		l.currentWordText.SetText("Current Word: " + l.currentWord.str[l.currentWord.completedChars:])
	} else {
		l.currentWordText.SetText("")
	}
	// End conditions
	if gameWon {
		l.gt.goToEndWin()
	}
	if gameLost {
		l.gt.goToEndFail()
	}
}