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, fromMaybe)
import Text.Printf

import qualified Data.ByteString.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
      
      
      format_seconds secs = 
        let hours = secs `div` 3600
            minites = ( secs `mod` 3600 ) `div` 60
            seconds = secs `mod` 60
        in
        printf "%d hours, %d minites and %d seconds" hours minites seconds
            
      show_stats = do
        timestamp <- now ^ t2i
        
        let saved_practice_time = saved_config.intervals.map (\x -> x.end_time + (-x.start_time)).sum
        
            elapsed_practice_time_if_started = ( saved_config.started ^ (negate > (+ timestamp)) ).fromMaybe 0
            
            total_time = saved_practice_time + elapsed_practice_time_if_started
                
        log - "Practiced: " +  format_seconds total_time
        -- log - printf "Practiced: %d hours and %d minites" hours minites
        
        
        when ( saved_config.started.isJust ) - do
          log "Still practicing..."
          log - "This section: " + format_seconds elapsed_practice_time_if_started

      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      "
  , "                           "
  ]