module Main where

import MPS.Env hiding (log)
import MPS.Extra (now, t2i)
import Prelude ()

import Data.Default
import Text.JSON.Generic

import PracticeRoom.Type
import System.Directory
import Control.Monad hiding (join)
import System.Environment
import Data.Maybe (isJust, isNothing)
import Text.Printf

import qualified Data.ByteString.Lazy.Char8 as B



{-

usage:  practice-room start
        practice-room stop
        practice-room reset
          
-}

log :: String -> IO ()
log = putStrLn

config_file :: String
config_file = ".practice.json"

write_config :: Practice -> IO ()
write_config x = B.writeFile config_file - B.pack - x.encodeJSON

main :: IO ()
main = do
  exist <- doesFileExist config_file
  when (not exist) - do
    write_config def
  
  saved_config <- B.readFile config_file ^ B.unpack ^ decodeJSON
  
  return (saved_config :: Practice)
  
  args <- getArgs
  
  let
      dispatch [] = show_stats
      dispatch (x:_)
        | x.is "start" = start_practice
        | x.is "stop"  = stop_practice
        | x.is "reset" = reset_practice
        | otherwise    = show_help
      
      
      show_stats = do
        let total_time = saved_config.intervals.map (\x -> x.end_time + (-x.start_time)).sum
        
            hours = total_time `div` 3600
            minites = ( total_time `mod` 3600 ) `div` 60
            seconds = total_time `mod` 60
                
        log - printf "Practiced: %d hours, %d minites and %d seconds" hours minites seconds
        -- log - printf "Practiced: %d hours and %d minites" hours minites
        
        
        when ( saved_config.started.isJust ) - do
          log "Still practicing..."

      start_practice =
        if saved_config.started.isJust
          then
            log "already started"
          else do
            timestamp <- now ^ t2i
            write_config saved_config {started = Just timestamp}
            log "started"
        
      stop_practice = 
        case saved_config.started of
          Nothing -> 
            log "already stopped"
          Just saved_start_time -> do
            timestamp <- now ^ t2i
            let intervals' = saved_config.intervals
                new_interval = def { start_time = saved_start_time, end_time = timestamp }
            write_config saved_config { started = Nothing, intervals = new_interval : intervals' }
            log "stopped"
      
      reset_practice = do
        write_config def
        log "resetted"
      
      show_help = log help
        
  dispatch args



help :: String
help = unlines - 

  [ "usage:  practice-room start"
  , "        practice-room stop "
  , "        practice-room reset"
  , "        practice-room      "
  , "                           "
  ]