module Main where
import Loop
import LoadConfig
import Dodge.Data
import Dodge.Initialisation
import Dodge.Update
import Dodge.Event
import Dodge.Render
import Dodge.Config.Data
import Dodge.Config.KeyConfig
import Dodge.Config.Load
import Dodge.Config.Update
import Dodge.LoadSound
import Dodge.Debug.Flag.Data
import Picture
import Picture.Render
import Preload.Render
import Picture.Tree
import Sound
import Preload
import Sound.Data
import Music
import Data.Preload

import Control.Lens
--import Foreign (Word32)
import Control.Monad
--import System.Random
import qualified Data.Map                  as M
import qualified Data.IntMap               as IM
import Graphics.Rendering.OpenGL hiding (color, rotate, scale, translate)
import qualified SDL
import qualified SDL.Mixer                 as Mix

main :: IO ()
main = do
    (sizex,sizey) <- loadConfig
    theKeyConfig <- loadKeyConfig
    dodgeConfig <- loadDodgeConfig
    setupLoop
        (sizex,sizey)
        (SDL.cursorVisible $= False >> doPreload >>= applyWorldConfig dodgeConfig)
        (\x -> (SDL.cursorVisible $= True) >> cleanUpPreload x)
        (fmap (setWindowSize sizex sizey theKeyConfig . (config .~ dodgeConfig)) firstWorld)
        doSideEffects
        handleEvent
        (Just . update)

doSideEffects :: PreloadData SoundOrigin -> World -> IO (PreloadData SoundOrigin)
doSideEffects preData w = do
    --startTicks <- SDL.ticks
    void $ doDrawing (_renderData preData) w
    playPositionalSoundQueue (_loadedChunks $ _soundData preData) (_soundQueue w)
    newPlayingSounds <- playAndUpdate (_soundData preData) (_sounds w)
    
    endTicks <- SDL.ticks
    let lastFrameTicks = _frameTimer preData
    when (_displaySecondsPerFrame $ _debugFlags w) $ void $ renderFoldable
                (_renderData preData)
                (picToLTree Nothing . setLayer 1 . setDepth (-1)
                    . translate (-0.5) (-0.8) . scale 0.0005 0.0005
                    . text $ "ms/frame " ++ show (endTicks - lastFrameTicks)
                )
    foldr (=<<) (return (preData & soundData . playingSounds .~ newPlayingSounds
                    & frameTimer .~ endTicks)) (_doneSideEffects w)

doPreload :: IO (PreloadData a)
doPreload = do
    lChunks <- loadSounds
    lMusic  <- loadMusic
    let sData = SoundData {_loadedChunks = lChunks, _playingSounds = M.empty}
        mData = MusicData {_loadedMusic = lMusic}
    Mix.playMusic Mix.Forever (lMusic IM.! 0)
    rData <- preloadRender
    return $ PreloadData 
        { _renderData   = rData 
        , _soundData    = sData 
        , _musicData    = mData
        , _frameTimer   = 0
        }

checkForGlErrors :: IO ()
checkForGlErrors = do
    errs <- errors
    unless (null errs) $ putStrLn $ "GLerror during doLoop: " ++ unwords (map show errs)

setWindowSize :: Int -> Int -> KeyConfigSDL-> World -> World
setWindowSize x y z w = w 
    & config . windowX .~ fromIntegral x
    & config . windowY .~ fromIntegral y
    & keyConfig .~ z