module Step where

import Vec2 (..)
import Game (..)
import Player (..)
import EnemyState (..)
import Player (playerSpeed)
import Enemy (enemySpeed, enemyMove, enemyAwayDist)
import Input (Input)
import Physics (getNewPosAndSpeed, getMove)
import Board (boardSize, boardDiagonal)
import Geometry (..)
import RandomValues (RandomValues)
import Target(..)

step : Input -> Game -> Game
step {dir, delta, randomValues} {time, player, target, enemyState, bestScore} =
  if(playerEnemiesCollision time player enemyState.enemies) then
    let newBestScore = if(target.score > bestScore) then target.score else bestScore
    in  initialGame player.pos newBestScore
  else
    let newTime = time + delta
        newPlayer = playerStep delta dir player
        newTarget = targetStep player randomValues target
        newEnemyState = enemyStep time randomValues enemyState
    in  { time = newTime
        , player = newPlayer
        , target = newTarget
        , enemyState = newEnemyState
        , bestScore = bestScore
        }

playerStep : Float -> Vec2 -> Player -> Player
playerStep dt dir player =
  let (pos, speed) = getNewPosAndSpeed dt dir playerSpeed (player.pos, player.speed)
  in  { pos = inBoard playerSize pos
      , speed = speed
      }

targetStep : Player -> RandomValues -> Target -> Target
targetStep player randomValues target =
  if(targetCollision player target) then
    { score = target.score + 1
    , pos = randomBoardPosition (randomValues.targetX, randomValues.targetY) (0.8, 0.8)
    }
  else
    target

enemyStep : Float -> RandomValues -> EnemyState -> EnemyState
enemyStep time randomValues {enemies, spawn, lastSpawn} =
  let isPresent enemy = (distance (enemyMove enemy time) originVec) < enemyAwayDist
      presentEnemies = filter isPresent enemies
  in  if time > lastSpawn + spawn then
        let newEnemy =
          { initTime = time
          , initPos = enemyInitPos randomValues
          , initDest = enemyDestination randomValues
          , move initTime initPos initDest time =
              let delta = time - initTime
                  move = getMove (enemySpeed delta) (initDest `sub` initPos)
              in  initPos `add` move
          }
        in { enemies = newEnemy :: presentEnemies
           , spawn = spawn - sqrt(spawn) / 50
           , lastSpawn = time
           }
      else { enemies = presentEnemies
           , spawn = spawn
           , lastSpawn = lastSpawn
           }

enemyInitPos : RandomValues -> Vec2
enemyInitPos randomValues =
  let angle = randomValues.enemyAngle * (degrees 360)
      dist = boardDiagonal * 3 / 5
  in  polarToCartesian angle dist

enemyDestination : RandomValues -> Vec2
enemyDestination randomValues =
  randomBoardPosition (randomValues.enemyX, randomValues.enemyY) (1, 1)

randomBoardPosition : (Float, Float) -> (Float, Float) -> Vec2
randomBoardPosition (randomX, randomY) (percentX, percentY) =
  let width = boardSize.x * percentX
      height = boardSize.y * percentY
  in  { x = width * randomX - width / 2
      , y = height * randomY - height / 2
      }