-- | Fast start

--

-- Create log config:

--

-- @

--myCfg = logCfg [(\"\", Info), (\"app\", Trace), (\"app.sub\", Debug)]

-- @

--

-- Create log and run log monad

--

-- @

--run ∷ IO ()

--run = runLog myCfg [handler text (file \"out.log\")] $ yourFunction

-- @

--

-- Function within log monad:

--

-- @

--yourFunction ∷ MonadLog m ⇒ m ()

--yourFunction = component \"app\" $ scope \"your\" $ do

--	sendLog Trace \"Hello from your function\"

-- @

--

-- Each component can have different level in config, subcomponents are specified with \'.\'

-- Components have independent scopes

-- Scopes can be nested and separated with \'/\':

--

-- @

--function2 ∷ MonadLog m ⇒ m ()

--function2 = component \"app.sub\" $ scope \"foo\" $ do

--	scope \"bar/baz\" $ do

--		sendLog Info \"Component app.sub and scope foo/bar/baz\"

--		sendLog Trace \"Invisible: app.sub configured with debug level\"

--	sendLog Info \"Same component and scope foo\"

--	component \"module\" $ sendLog Info \"Component module and root scope\"

-- @

--

-- You can update config with @updateLogConfig@ (or @modifyLogConfig@ within log monad) function

-- And change handlers with @updateLogHandlers@ (@modifyLogHandlers@)

-- 

-- There're also global logger @globalLog@, that can be used with @runGlobalLog@

--

-- @

--test ∷ IO ()

--test = do

--	updateLogHandlers globalLog ([handler text (file \"test.log\")]:)

--	runGlobalLog $ do

--		sendLog Info \"This will go to test.log too\"

--		modifyLogConfig (set (ix \"\") Debug)

--		sendLog Debug \"Now debug is logged too\"

-- @

--

module System.Log.Simple (

	module System.Log.Simple.Base,

	module System.Log.Simple.Monad,

	module System.Log.Simple.Text,

	module System.Log.Simple.Stream,

	module System.Log.Simple.File,



	globalLog,

	runGlobalLog, runConsoleLog, runLogMsgs, runLogTexts

	) where



import Prelude.Unicode



import Control.Monad.IO.Class

import Control.Monad.Catch (MonadMask)

import Control.Concurrent

import Data.Maybe

import Data.Text (Text)

import System.IO.Unsafe (unsafePerformIO)



import System.Log.Simple.Base (

	Level(..), Message, Converter, Consumer, LogHandler, handler,

	LogConfig(..), defCfg, logCfg, componentCfg, Log(..),

	newLog, rootLog, getLog, subLog,

	updateLogConfig, updateLogHandlers, writeLog, stopLog)

import System.Log.Simple.Monad (

	MonadLog(..), LogT(..), noLog, withLog, runLog, sendLog,

	component, scope_, scope, scopeM, scoper, scoperM, trace,

	modifyLogConfig, modifyLogHandlers)

import System.Log.Simple.Text

import System.Log.Simple.Stream

import System.Log.Simple.File

import System.Log.Simple.Chan



globalLog ∷ Log

globalLog = unsafePerformIO $ newLog defCfg [handler text coloredConsole]



runGlobalLog ∷ LogT m a → m a

runGlobalLog = withLog globalLog



runConsoleLog ∷ (MonadIO m, MonadMask m) ⇒ LogConfig → LogT m a → m a

runConsoleLog cfg = runLog cfg [handler text coloredConsole]



runLogChan ∷ (MonadIO m, MonadMask m) ⇒ (Chan w → LogHandler) → LogConfig → LogT m a → m (a, [w])

runLogChan c cfg act = do

	ch ← liftIO newChan

	mch ← liftIO newChan

	_ ← liftIO $ forkIO $ getChanContents ch >>= mapM_ (writeChan mch . Just)

	r ← runLog cfg [c ch] act

	liftIO $ writeChan mch Nothing

	msgs ← liftIO ((catMaybes ∘ takeWhile isJust) <$> getChanContents mch)

	return (r, msgs)



runLogMsgs ∷ (MonadIO m, MonadMask m) ⇒ LogConfig → LogT m a → m (a, [Message])

runLogMsgs = runLogChan chan



runLogTexts ∷ (MonadIO m, MonadMask m) ⇒ Converter Text → LogConfig → LogT m a → m (a, [Text])

runLogTexts txt = runLogChan (handler txt ∘ chan)