module Render where

import Control.Monad
import qualified Graphics.UI.SDL as SDL hiding (init)
import qualified Graphics.UI.SDL.TTF as SDL
import qualified Graphics.Rendering.OpenGL as GL
import Data.Word
import qualified Data.Map as M
import qualified Data.Traversable as M
import System.IO
import System.Random
import Data.Maybe

import States

import RenderInterface
import RenderUtil

import StaticInterface 

import Pic 
import Utilities
import Config

standardRenderEngine :: Static -> RenderEngine
standardRenderEngine static = RenderEngine (render static)
                                           (renderEnd static)

-- type Render a = Int -> a -> IO ()
-- type RenderStatic a = Static -> Int -> a -> IO ()

render :: RenderStatic State 
render st dt s = do 
                  clearScreen
                  -- painting the virtual screen 
                  renderVirtualScreen dt s st
                  -- update the image on screen
                  showScreen

renderVirtualScreen :: Int -> State -> Static -> IO ()
renderVirtualScreen dt s st
    = do
       -- interpolate the new positions (using dt)
       let s' = if dt /= 0 then interpolateState s dt
                           else s
       -- render the background
       renderBackground st 
       -- render the rocks
       mapM_ (renderRock st) (rocks s)
       -- render the collectibles
       mapM_ (renderCollectible st) (collectibles s)
       -- render the player's ship
       renderPlayer st (player s')
       -- render the score 
       renderScore st (score s')
       return ()

---------------------------------------------------------------------------
-- * Rendering parts of the level state
---------------------------------------------------------------------------
    
-- | Render the background.
renderBackground :: Static -> IO ()
renderBackground st = renderImg (bg_image (images st)) 
                                (fromIntegral maxXview/2, fromIntegral maxYview/2)

-- | Render a rock at the given position.
renderRock :: Static -> Rock -> IO ()
renderRock st f = renderImgAttr (defaultRenderAttr { ra_scale = scale f})
                                (rock_image (images st))
                                (pos f)

-- | Render a collectible at the given position.
renderCollectible :: Static -> Collectible -> IO ()
renderCollectible st f = renderImgAttr (defaultRenderAttr { ra_scale = scale f})
                                       (coll_image (images st))
                                       (pos f)

-- | Render the player's ship.
renderPlayer :: Static -> Player -> IO ()
renderPlayer st f = renderImgAttr (defaultRenderAttr { ra_scale = scale f})
                                  (pl_image (images st))
                                  (pos f)

-- | Render the score.
renderScore :: Static -> Int -> IO ()
renderScore st n = renderText ("score: " ++ show n) textColour (5,5) st

---------------------------------------------------------------------------
-- * Render end of this level
---------------------------------------------------------------------------

renderEnd :: RenderEndStatic
renderEnd st s 
  = do 
      renderEndOverlay st s
      let msg = "game over! collected: " ++ show (score s)
      renderBigText msg textColour (0, fromIntegral maxYview - 80) st
      SDL.glSwapBuffers

renderEndOverlay :: Static -> State -> IO ()
renderEndOverlay st s =
  let overlay_img = overlay . images $ st
  in  renderImg overlay_img (pos (player s))