module RPGEngine.Render.Playing
( renderPlaying
) where

import RPGEngine.Render.Core (Renderer, getRender, setRenderPos, overlay)

import RPGEngine.Config (resolution, zoom, uizoom)
import RPGEngine.Data (State(..), Player (..), Game (..), Level (..), Layout, Physical (..), Item (..), Entity (..))

import Graphics.Gloss ( pictures, Picture, translate, white )
import Graphics.Gloss.Data.Picture ( blank, text, color, scale )

------------------------------ Exported ------------------------------

renderPlaying :: Renderer State
renderPlaying Playing { level = lvl, player = player } = pictures [
    renderLevel lvl,
    renderPlayer player,
    renderInventory player
    ]
renderPlaying _ = blank

------------------------------- Player -------------------------------

renderPlayer :: Renderer Player
renderPlayer Player{ position = (x, y) } = move picture
    where move    = setRenderPos x y
          picture = getRender "player"

-- Center the player in the middle of the screen.
-- Not in use at the moment, might be useful later.
focusPlayer :: Game -> Picture -> Picture
focusPlayer Game{ state = Playing{ player = Player{ position = (x, y) }}} = move
    where move    = translate centerX centerY
          centerX = resolution * zoom * fromIntegral (negate x)
          centerY = resolution * zoom * fromIntegral (negate y)
focusPlayer _ = id

------------------------------- Level --------------------------------

renderLevel :: Renderer Level
renderLevel Level{ layout = l, items = i, entities = e } = level
    where level    = pictures [void, layout, items, entities]
          void     = createVoid
          layout   = renderLayout l
          items    = renderItems i
          entities = renderEntities e

renderLayout :: Layout -> Picture
renderLayout strips = pictures [setRenderPos 0 y (renderStrip (strips !! y)) | y <- [0 .. count]]
    where count = length strips - 1

renderStrip :: [Physical] -> Picture
renderStrip list = pictures physicals
    where physicals       = [setRenderPos x 0 (image (list !! x)) | x <- [0 .. count]]
          image Void      = getRender "void"
          image Walkable  = getRender "tile"
          image Blocked   = getRender "wall"
          image Entrance  = pictures [getRender "tile", getRender "entrance"]
          image Exit      = pictures [getRender "tile", getRender "exit"]
          count           = length list - 1

createVoid :: Picture
createVoid = setRenderPos offX offY $ pictures voids
    where voids = [setRenderPos x y void | x <- [0 .. width], y <- [0 .. height]]
          void  = getRender "void"
          intZoom = round zoom :: Int
          height = round $ 4320 / resolution / zoom
          width  = round $ 7680 / resolution / zoom
          offX   = negate (width `div` 2)
          offY   = negate (height `div` 2)

-------------------------- Items & Entities --------------------------

renderItems :: [Item] -> Picture
renderItems list = pictures $ map renderItem list

renderItem :: Item -> Picture
renderItem Item{ itemId = id, itemX = x, itemY = y} = setRenderPos x y image
    where image = getRender id

renderEntities :: [Entity] -> Picture
renderEntities list = pictures $ map renderEntity list

renderEntity :: Entity -> Picture
renderEntity Entity{ entityId = id, entityX = x, entityY = y} = setRenderPos x y image
    where image = getRender id

renderInventory :: Player -> Picture
renderInventory Player{ showInventory = False } = blank
renderInventory Player{ inventory = list } = pictures [overlay, title, items]
    where title = translate 0 (offset (-1)) $ scale uizoom uizoom $ color white $ text "Inventory"
          items = pictures $ map move $ zip [0::Int ..] (map (getRender . itemId) list)
          move (i, pic) = translate 0 (offset i) pic
          offset i      = negate (zoom * resolution * fromIntegral i)