{-#LANGUAGE CPP #-}
{-# LANGUAGE BangPatterns #-}
-----------------------------------------------------------------------------
-- |
-- Module      :  Plugins.Monitors.Top
-- Copyright   :  (c) 2010-2014, 2018, 2022, 2025 Jose A Ortega Ruiz
-- License     :  BSD-style (see LICENSE)
--
-- Maintainer  :  Jose A Ortega Ruiz <jao@gnu.org>
-- Stability   :  unstable
-- Portability :  unportable
--
--  Process activity and memory consumption monitors
--
-----------------------------------------------------------------------------

module Xmobar.Plugins.Monitors.Top (startTop, topMemConfig, runTopMem) where

import Xmobar.Plugins.Monitors.Common

import Data.IORef (newIORef, readIORef, writeIORef)
import Data.List (sortBy)
import Data.Ord (comparing, Down (..))
import Data.Time.Clock (getCurrentTime, diffUTCTime)

import Xmobar.Plugins.Monitors.Top.Common (
  MemInfo
  , TimeInfo
  , Times
  , TimesRef)

#if defined(freebsd_HOST_OS)
import qualified Xmobar.Plugins.Monitors.Top.FreeBSD as MT
#else
import qualified Xmobar.Plugins.Monitors.Top.Linux as MT
#endif


maxEntries :: Int
maxEntries :: Int
maxEntries = Int
10

intStrs :: [String]
intStrs :: [[Char]]
intStrs = (Int -> [Char]) -> [Int] -> [[Char]]
forall a b. (a -> b) -> [a] -> [b]
map Int -> [Char]
forall a. Show a => a -> [Char]
show [Int
1..Int
maxEntries]

topMemConfig :: IO MConfig
topMemConfig :: IO MConfig
topMemConfig = [Char] -> [[Char]] -> IO MConfig
mkMConfig [Char]
"<both1>"
                 [ [Char]
k [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
n | [Char]
n <- [[Char]]
intStrs , [Char]
k <- [[Char]
"name", [Char]
"mem", [Char]
"both"]]

topConfig :: IO MConfig
topConfig :: IO MConfig
topConfig = [Char] -> [[Char]] -> IO MConfig
mkMConfig [Char]
"<both1>"
              ([Char]
"no" [Char] -> [[Char]] -> [[Char]]
forall a. a -> [a] -> [a]
: [ [Char]
k [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
n | [Char]
n <- [[Char]]
intStrs
                               , [Char]
k <- [ [Char]
"name", [Char]
"cpu", [Char]
"both"
                                      , [Char]
"mname", [Char]
"mem", [Char]
"mboth"]])

showInfo :: String -> String -> Float -> Monitor [String]
showInfo :: [Char] -> [Char] -> Float -> Monitor [[Char]]
showInfo [Char]
nm [Char]
sms Float
mms = do
  mnw <- Selector Int -> Monitor Int
forall a. Selector a -> Monitor a
getConfigValue Selector Int
maxWidth
  mxw <- getConfigValue minWidth
  let lsms = [Char] -> Int
forall a. [a] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length [Char]
sms
      nmw = Int
mnw Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
lsms Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
1
      nmx = Int
mxw Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
lsms Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
1
      rnm = if Int
nmw Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
> Int
0 then Int -> Int -> [Char] -> Bool -> [Char] -> [Char] -> [Char]
padString Int
nmw Int
nmx [Char]
" " Bool
True [Char]
"" [Char]
nm else [Char]
nm
  mstr <- showWithColors' sms mms
  both <- showWithColors' (rnm ++ " " ++ sms) mms
  return [nm, mstr, both]


sortTop :: [(String, Float)] -> [(String, Float)]
sortTop :: [([Char], Float)] -> [([Char], Float)]
sortTop =  (([Char], Float) -> ([Char], Float) -> Ordering)
-> [([Char], Float)] -> [([Char], Float)]
forall a. (a -> a -> Ordering) -> [a] -> [a]
sortBy ((([Char], Float) -> Down Float)
-> ([Char], Float) -> ([Char], Float) -> Ordering
forall a b. Ord a => (b -> a) -> b -> b -> Ordering
comparing (Float -> Down Float
forall a. a -> Down a
Down (Float -> Down Float)
-> (([Char], Float) -> Float) -> ([Char], Float) -> Down Float
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ([Char], Float) -> Float
forall a b. (a, b) -> b
snd))

showMemInfo :: Float -> MemInfo -> Monitor [String]
showMemInfo :: Float -> ([Char], Float) -> Monitor [[Char]]
showMemInfo Float
scale ([Char]
nm, Float
rss) =
  [Char] -> [Char] -> Float -> Monitor [[Char]]
showInfo [Char]
nm (Int -> Int -> Float -> [Char]
showWithUnits Int
3 Int
1 Float
rss) (Float
100 Float -> Float -> Float
forall a. Num a => a -> a -> a
* Float
rss Float -> Float -> Float
forall a. Fractional a => a -> a -> a
/ Float
sc)
  where sc :: Float
sc = if Float
scale Float -> Float -> Bool
forall a. Ord a => a -> a -> Bool
> Float
0 then Float
scale else Float
100

showMemInfos :: [MemInfo] -> Monitor [[String]]
showMemInfos :: [([Char], Float)] -> Monitor [[[Char]]]
showMemInfos [([Char], Float)]
ms = (([Char], Float) -> Monitor [[Char]])
-> [([Char], Float)] -> Monitor [[[Char]]]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
mapM (Float -> ([Char], Float) -> Monitor [[Char]]
showMemInfo Float
tm) [([Char], Float)]
ms
  where tm :: Float
tm = [Float] -> Float
forall a. Num a => [a] -> a
forall (t :: * -> *) a. (Foldable t, Num a) => t a -> a
sum ((([Char], Float) -> Float) -> [([Char], Float)] -> [Float]
forall a b. (a -> b) -> [a] -> [b]
map ([Char], Float) -> Float
forall a b. (a, b) -> b
snd [([Char], Float)]
ms)

timeMemInfos :: IO (Times, [MemInfo], Int)
timeMemInfos :: IO (Times, [([Char], Float)], Int)
timeMemInfos = ([((Int, ([Char], Float)), ([Char], Float))]
 -> (Times, [([Char], Float)], Int))
-> IO [((Int, ([Char], Float)), ([Char], Float))]
-> IO (Times, [([Char], Float)], Int)
forall a b. (a -> b) -> IO a -> IO b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap [((Int, ([Char], Float)), ([Char], Float))]
-> (Times, [([Char], Float)], Int)
forall {a} {b} {b}. Ord a => [((a, b), b)] -> ([(a, b)], [b], Int)
res IO [((Int, ([Char], Float)), ([Char], Float))]
MT.timeMemEntries
  where res :: [((a, b), b)] -> ([(a, b)], [b], Int)
res [((a, b), b)]
x = (((a, b) -> (a, b) -> Ordering) -> [(a, b)] -> [(a, b)]
forall a. (a -> a -> Ordering) -> [a] -> [a]
sortBy (((a, b) -> a) -> (a, b) -> (a, b) -> Ordering
forall a b. Ord a => (b -> a) -> b -> b -> Ordering
comparing (a, b) -> a
forall a b. (a, b) -> a
fst) ([(a, b)] -> [(a, b)]) -> [(a, b)] -> [(a, b)]
forall a b. (a -> b) -> a -> b
$ (((a, b), b) -> (a, b)) -> [((a, b), b)] -> [(a, b)]
forall a b. (a -> b) -> [a] -> [b]
map ((a, b), b) -> (a, b)
forall a b. (a, b) -> a
fst [((a, b), b)]
x, (((a, b), b) -> b) -> [((a, b), b)] -> [b]
forall a b. (a -> b) -> [a] -> [b]
map ((a, b), b) -> b
forall a b. (a, b) -> b
snd [((a, b), b)]
x, [((a, b), b)] -> Int
forall a. [a] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length [((a, b), b)]
x)

combine :: Times -> Times -> Times
combine :: Times -> Times -> Times
combine Times
_ [] = []
combine [] Times
ts = Times
ts
combine l :: Times
l@((Int
p0, ([Char]
n0, Float
t0)):Times
ls) r :: Times
r@((Int
p1, ([Char]
n1, Float
t1)):Times
rs)
  | Int
p0 Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
p1 Bool -> Bool -> Bool
&& [Char]
n0 [Char] -> [Char] -> Bool
forall a. Eq a => a -> a -> Bool
== [Char]
n1 = (Int
p0, ([Char]
n0, Float
t1 Float -> Float -> Float
forall a. Num a => a -> a -> a
- Float
t0)) (Int, ([Char], Float)) -> Times -> Times
forall a. a -> [a] -> [a]
: Times -> Times -> Times
combine Times
ls Times
rs
  | Int
p0 Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
<= Int
p1 = Times -> Times -> Times
combine Times
ls Times
r
  | Bool
otherwise = (Int
p1, ([Char]
n1, Float
t1)) (Int, ([Char], Float)) -> Times -> Times
forall a. a -> [a] -> [a]
: Times -> Times -> Times
combine Times
l Times
rs

take' :: Int -> [a] -> [a]
take' :: forall a. Int -> [a] -> [a]
take' Int
m [a]
l = let !r :: [a]
r = Int -> [a] -> [a]
forall {a} {a}. (Eq a, Num a) => a -> [a] -> [a]
tk Int
m [a]
l in [a] -> Int
forall a. [a] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length [a]
l Int -> [a] -> [a]
forall a b. a -> b -> b
`seq` [a]
r
  where tk :: a -> [a] -> [a]
tk a
0 [a]
_ = []
        tk a
_ [] = []
        tk a
n (a
x:[a]
xs) = let !r :: [a]
r = a -> [a] -> [a]
tk (a
n a -> a -> a
forall a. Num a => a -> a -> a
- a
1) [a]
xs in a
x a -> [a] -> [a]
forall a. a -> [a] -> [a]
: [a]
r

topProcesses :: TimesRef -> Float -> IO (Int, [TimeInfo], [MemInfo])
topProcesses :: TimesRef -> Float -> IO (Int, [([Char], Float)], [([Char], Float)])
topProcesses TimesRef
tref Float
scale = do
  (t0, c0) <- TimesRef -> IO (Times, UTCTime)
forall a. IORef a -> IO a
readIORef TimesRef
tref
  (t1, mis, len) <- timeMemInfos
  c1 <- getCurrentTime
  let scx = NominalDiffTime -> Float
forall a b. (Real a, Fractional b) => a -> b
realToFrac (UTCTime -> UTCTime -> NominalDiffTime
diffUTCTime UTCTime
c1 UTCTime
c0) Float -> Float -> Float
forall a. Num a => a -> a -> a
* Float
scale
      !scx' = if Float
scx Float -> Float -> Bool
forall a. Ord a => a -> a -> Bool
> Float
0 then Float
scx else Float
scale
      nts = ((Int, ([Char], Float)) -> ([Char], Float))
-> Times -> [([Char], Float)]
forall a b. (a -> b) -> [a] -> [b]
map (\(Int
_, ([Char]
nm, Float
t)) -> ([Char]
nm, Float
t Float -> Float -> Float
forall a. Fractional a => a -> a -> a
/ Float
scx')) (Times -> Times -> Times
combine Times
t0 Times
t1)
      !t1' = Int -> Times -> Times
forall a. Int -> [a] -> [a]
take' (Times -> Int
forall a. [a] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length Times
t1) Times
t1
      !nts' = Int -> [([Char], Float)] -> [([Char], Float)]
forall a. Int -> [a] -> [a]
take' Int
maxEntries ([([Char], Float)] -> [([Char], Float)]
sortTop [([Char], Float)]
nts)
      !mis' = Int -> [([Char], Float)] -> [([Char], Float)]
forall a. Int -> [a] -> [a]
take' Int
maxEntries ([([Char], Float)] -> [([Char], Float)]
sortTop [([Char], Float)]
mis)
  writeIORef tref (t1', c1)
  return (len, nts', mis')

showTimeInfo :: TimeInfo -> Monitor [String]
showTimeInfo :: ([Char], Float) -> Monitor [[Char]]
showTimeInfo ([Char]
n, Float
t) =
  Selector Int -> Monitor Int
forall a. Selector a -> Monitor a
getConfigValue Selector Int
decDigits Monitor Int -> (Int -> Monitor [[Char]]) -> Monitor [[Char]]
forall a b.
ReaderT MConfig IO a
-> (a -> ReaderT MConfig IO b) -> ReaderT MConfig IO b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \Int
d -> [Char] -> [Char] -> Float -> Monitor [[Char]]
showInfo [Char]
n (Int -> Float -> [Char]
forall a. RealFloat a => Int -> a -> [Char]
showDigits Int
d Float
t) Float
t

showTimeInfos :: [TimeInfo] -> Monitor [[String]]
showTimeInfos :: [([Char], Float)] -> Monitor [[[Char]]]
showTimeInfos = (([Char], Float) -> Monitor [[Char]])
-> [([Char], Float)] -> Monitor [[[Char]]]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
mapM ([Char], Float) -> Monitor [[Char]]
showTimeInfo

runTopMem :: [String] -> Monitor String
runTopMem :: [[Char]] -> Monitor [Char]
runTopMem [[Char]]
_ = do
  mis <- IO [([Char], Float)] -> Monitor [([Char], Float)]
forall a. IO a -> Monitor a
io IO [([Char], Float)]
MT.meminfos
  pstr <- showMemInfos (sortTop mis)
  parseTemplate $ concat pstr

runTop :: TimesRef -> Float -> [String] -> Monitor String
runTop :: TimesRef -> Float -> [[Char]] -> Monitor [Char]
runTop TimesRef
tref Float
scale [[Char]]
_ = do
  (no, ps, ms) <- IO (Int, [([Char], Float)], [([Char], Float)])
-> Monitor (Int, [([Char], Float)], [([Char], Float)])
forall a. IO a -> Monitor a
io (IO (Int, [([Char], Float)], [([Char], Float)])
 -> Monitor (Int, [([Char], Float)], [([Char], Float)]))
-> IO (Int, [([Char], Float)], [([Char], Float)])
-> Monitor (Int, [([Char], Float)], [([Char], Float)])
forall a b. (a -> b) -> a -> b
$ TimesRef -> Float -> IO (Int, [([Char], Float)], [([Char], Float)])
topProcesses TimesRef
tref Float
scale
  pstr <- showTimeInfos ps
  mstr <- showMemInfos ms
  na <- getConfigValue naString
  parseTemplate $ show no : concat (zipWith (++) pstr mstr) ++ repeat na

startTop :: [String] -> Int -> (String -> IO ()) -> IO ()
startTop :: [[Char]] -> Int -> ([Char] -> IO ()) -> IO ()
startTop [[Char]]
a Int
r [Char] -> IO ()
cb = do
  c <- IO UTCTime
getCurrentTime
  tref <- newIORef ([], c)
  scale <- MT.scale
  _ <- topProcesses tref scale
  runM a topConfig (runTop tref scale) r cb