{-# OPTIONS_GHC -fno-warn-orphans #-}

module Data.UnixTime.Diff (
    diffUnixTime,
    addUnixDiffTime,
    secondsToUnixDiffTime,
    microSecondsToUnixDiffTime,
) where

import Data.Int
import Data.UnixTime.Types
import Foreign.C.Types

-- $setup
-- >>> :set -XOverloadedStrings

----------------------------------------------------------------

-- 'UnixDiffTime' is normalized so that both fields share the sign of
-- the value and @|udtMicroSeconds| < 1000000@.
normDiff :: CTime -> Int64 -> UnixDiffTime
normDiff :: CTime -> Int64 -> UnixDiffTime
normDiff CTime
sec Int64
usec
    | CTime
s CTime -> CTime -> Bool
forall a. Ord a => a -> a -> Bool
> CTime
0 Bool -> Bool -> Bool
&& Int64
u Int64 -> Int64 -> Bool
forall a. Ord a => a -> a -> Bool
< Int64
0 = CTime -> Int32 -> UnixDiffTime
UnixDiffTime (CTime
s CTime -> CTime -> CTime
forall a. Num a => a -> a -> a
- CTime
1) (Int64 -> Int32
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int64
u Int64 -> Int64 -> Int64
forall a. Num a => a -> a -> a
+ Int64
forall a. Num a => a
micro))
    | CTime
s CTime -> CTime -> Bool
forall a. Ord a => a -> a -> Bool
< CTime
0 Bool -> Bool -> Bool
&& Int64
u Int64 -> Int64 -> Bool
forall a. Ord a => a -> a -> Bool
> Int64
0 = CTime -> Int32 -> UnixDiffTime
UnixDiffTime (CTime
s CTime -> CTime -> CTime
forall a. Num a => a -> a -> a
+ CTime
1) (Int64 -> Int32
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int64
u Int64 -> Int64 -> Int64
forall a. Num a => a -> a -> a
- Int64
forall a. Num a => a
micro))
    | Bool
otherwise = CTime -> Int32 -> UnixDiffTime
UnixDiffTime CTime
s (Int64 -> Int32
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int64
u)
  where
    (Int64
q, Int64
u) = Int64
usec Int64 -> Int64 -> (Int64, Int64)
forall a. Integral a => a -> a -> (a, a)
`quotRem` Int64
forall a. Num a => a
micro
    s :: CTime
s = CTime
sec CTime -> CTime -> CTime
forall a. Num a => a -> a -> a
+ Int64 -> CTime
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int64
q

-- 'UnixTime' is normalized so that @0 <= utMicroSeconds < 1000000@
-- as @struct timeval@.
normTime :: CTime -> Int64 -> UnixTime
normTime :: CTime -> Int64 -> UnixTime
normTime CTime
sec Int64
usec = CTime -> Int32 -> UnixTime
UnixTime (CTime
sec CTime -> CTime -> CTime
forall a. Num a => a -> a -> a
+ Int64 -> CTime
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int64
q) (Int64 -> Int32
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int64
u)
  where
    (Int64
q, Int64
u) = Int64
usec Int64 -> Int64 -> (Int64, Int64)
forall a. Integral a => a -> a -> (a, a)
`divMod` Int64
forall a. Num a => a
micro

normalize :: UnixDiffTime -> UnixDiffTime
normalize :: UnixDiffTime -> UnixDiffTime
normalize (UnixDiffTime CTime
s Int32
u) = CTime -> Int64 -> UnixDiffTime
normDiff CTime
s (Int32 -> Int64
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int32
u)

toMicro :: UnixDiffTime -> Integer
toMicro :: UnixDiffTime -> Integer
toMicro (UnixDiffTime (CTime Int64
s) Int32
u) = Int64 -> Integer
forall a. Integral a => a -> Integer
toInteger Int64
s Integer -> Integer -> Integer
forall a. Num a => a -> a -> a
* Integer
forall a. Num a => a
micro Integer -> Integer -> Integer
forall a. Num a => a -> a -> a
+ Int32 -> Integer
forall a. Integral a => a -> Integer
toInteger Int32
u

fromMicro :: Integer -> UnixDiffTime
fromMicro :: Integer -> UnixDiffTime
fromMicro Integer
n = CTime -> Int32 -> UnixDiffTime
UnixDiffTime (Integer -> CTime
forall a. Num a => Integer -> a
fromInteger Integer
s) (Integer -> Int32
forall a. Num a => Integer -> a
fromInteger Integer
u)
  where
    (Integer
s, Integer
u) = Integer
n Integer -> Integer -> (Integer, Integer)
forall a. Integral a => a -> a -> (a, a)
`quotRem` Integer
forall a. Num a => a
micro

micro :: Num a => a
micro :: forall a. Num a => a
micro = a
1000000

-- | Arithmetic operations where (1::UnixDiffTime) means 1 second.
--
-- >>> (3 :: UnixDiffTime) + 2
-- UnixDiffTime {udtSeconds = 5, udtMicroSeconds = 0}
-- >>> (2 :: UnixDiffTime) - 5
-- UnixDiffTime {udtSeconds = -3, udtMicroSeconds = 0}
-- >>> (3 :: UnixDiffTime) * 2
-- UnixDiffTime {udtSeconds = 6, udtMicroSeconds = 0}
-- >>> microSecondsToUnixDiffTime (1500000 :: Int) * microSecondsToUnixDiffTime (1500000 :: Int)
-- UnixDiffTime {udtSeconds = 2, udtMicroSeconds = 250000}
-- >>> negate (microSecondsToUnixDiffTime (500000 :: Int))
-- UnixDiffTime {udtSeconds = 0, udtMicroSeconds = -500000}
instance Num UnixDiffTime where
    UnixDiffTime CTime
s1 Int32
u1 + :: UnixDiffTime -> UnixDiffTime -> UnixDiffTime
+ UnixDiffTime CTime
s2 Int32
u2 =
        CTime -> Int64 -> UnixDiffTime
normDiff (CTime
s1 CTime -> CTime -> CTime
forall a. Num a => a -> a -> a
+ CTime
s2) (Int32 -> Int64
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int32
u1 Int64 -> Int64 -> Int64
forall a. Num a => a -> a -> a
+ Int32 -> Int64
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int32
u2)
    UnixDiffTime CTime
s1 Int32
u1 - :: UnixDiffTime -> UnixDiffTime -> UnixDiffTime
- UnixDiffTime CTime
s2 Int32
u2 =
        CTime -> Int64 -> UnixDiffTime
normDiff (CTime
s1 CTime -> CTime -> CTime
forall a. Num a => a -> a -> a
- CTime
s2) (Int32 -> Int64
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int32
u1 Int64 -> Int64 -> Int64
forall a. Num a => a -> a -> a
- Int32 -> Int64
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int32
u2)
    UnixDiffTime
x * :: UnixDiffTime -> UnixDiffTime -> UnixDiffTime
* UnixDiffTime
y = Integer -> UnixDiffTime
fromMicro (UnixDiffTime -> Integer
toMicro UnixDiffTime
x Integer -> Integer -> Integer
forall a. Num a => a -> a -> a
* UnixDiffTime -> Integer
toMicro UnixDiffTime
y Integer -> Integer -> Integer
forall a. Integral a => a -> a -> a
`quot` Integer
forall a. Num a => a
micro)
    negate :: UnixDiffTime -> UnixDiffTime
negate (UnixDiffTime CTime
s Int32
u) = CTime -> Int64 -> UnixDiffTime
normDiff (CTime -> CTime
forall a. Num a => a -> a
negate CTime
s) (Int64 -> Int64
forall a. Num a => a -> a
negate (Int32 -> Int64
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int32
u))
    abs :: UnixDiffTime -> UnixDiffTime
abs UnixDiffTime
x = CTime -> Int32 -> UnixDiffTime
UnixDiffTime (CTime -> CTime
forall a. Num a => a -> a
abs CTime
s) (Int32 -> Int32
forall a. Num a => a -> a
abs Int32
u)
      where
        UnixDiffTime CTime
s Int32
u = UnixDiffTime -> UnixDiffTime
normalize UnixDiffTime
x
    signum :: UnixDiffTime -> UnixDiffTime
signum UnixDiffTime
x
        | CTime
s CTime -> CTime -> Bool
forall a. Ord a => a -> a -> Bool
> CTime
0 Bool -> Bool -> Bool
|| Int32
u Int32 -> Int32 -> Bool
forall a. Ord a => a -> a -> Bool
> Int32
0 = UnixDiffTime
1
        | CTime
s CTime -> CTime -> Bool
forall a. Ord a => a -> a -> Bool
< CTime
0 Bool -> Bool -> Bool
|| Int32
u Int32 -> Int32 -> Bool
forall a. Ord a => a -> a -> Bool
< Int32
0 = -UnixDiffTime
1
        | Bool
otherwise = UnixDiffTime
0
      where
        UnixDiffTime CTime
s Int32
u = UnixDiffTime -> UnixDiffTime
normalize UnixDiffTime
x
    fromInteger :: Integer -> UnixDiffTime
fromInteger Integer
i = CTime -> Int32 -> UnixDiffTime
UnixDiffTime (Integer -> CTime
forall a. Num a => Integer -> a
fromInteger Integer
i) Int32
0

{-# RULES "Integral->UnixDiffTime" fromIntegral = secondsToUnixDiffTime #-}

instance Real UnixDiffTime where
    toRational :: UnixDiffTime -> Rational
toRational = UnixDiffTime -> Rational
forall a. Fractional a => UnixDiffTime -> a
toFractional

{-# RULES "UnixDiffTime->Fractional" realToFrac = toFractional #-}

----------------------------------------------------------------

-- | Calculating difference between two 'UnixTime'.
--
-- >>> UnixTime 100 2000 `diffUnixTime` UnixTime 98 2100
-- UnixDiffTime {udtSeconds = 1, udtMicroSeconds = 999900}
diffUnixTime :: UnixTime -> UnixTime -> UnixDiffTime
diffUnixTime :: UnixTime -> UnixTime -> UnixDiffTime
diffUnixTime (UnixTime CTime
s1 Int32
u1) (UnixTime CTime
s2 Int32
u2) =
    CTime -> Int64 -> UnixDiffTime
normDiff (CTime
s1 CTime -> CTime -> CTime
forall a. Num a => a -> a -> a
- CTime
s2) (Int32 -> Int64
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int32
u1 Int64 -> Int64 -> Int64
forall a. Num a => a -> a -> a
- Int32 -> Int64
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int32
u2)

-- | Adding difference to 'UnixTime'.
--
-- >>> UnixTime 100 2000 `addUnixDiffTime` microSecondsToUnixDiffTime ((-1003000) :: Int)
-- UnixTime {utSeconds = 98, utMicroSeconds = 999000}
addUnixDiffTime :: UnixTime -> UnixDiffTime -> UnixTime
addUnixDiffTime :: UnixTime -> UnixDiffTime -> UnixTime
addUnixDiffTime (UnixTime CTime
s1 Int32
u1) (UnixDiffTime CTime
s2 Int32
u2) =
    CTime -> Int64 -> UnixTime
normTime (CTime
s1 CTime -> CTime -> CTime
forall a. Num a => a -> a -> a
+ CTime
s2) (Int32 -> Int64
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int32
u1 Int64 -> Int64 -> Int64
forall a. Num a => a -> a -> a
+ Int32 -> Int64
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int32
u2)

-- | Creating difference from seconds.
--
-- >>> secondsToUnixDiffTime (100 :: Int)
-- UnixDiffTime {udtSeconds = 100, udtMicroSeconds = 0}
secondsToUnixDiffTime :: Integral a => a -> UnixDiffTime
secondsToUnixDiffTime :: forall a. Integral a => a -> UnixDiffTime
secondsToUnixDiffTime a
sec = CTime -> Int32 -> UnixDiffTime
UnixDiffTime (a -> CTime
forall a b. (Integral a, Num b) => a -> b
fromIntegral a
sec) Int32
0
{-# INLINE secondsToUnixDiffTime #-}

-- | Creating difference from micro seconds.
--
-- >>> microSecondsToUnixDiffTime (12345678 :: Int)
-- UnixDiffTime {udtSeconds = 12, udtMicroSeconds = 345678}
--
-- >>> microSecondsToUnixDiffTime ((-12345678) :: Int)
-- UnixDiffTime {udtSeconds = -12, udtMicroSeconds = -345678}
--
-- >>> microSecondsToUnixDiffTime ((-345678) :: Int)
-- UnixDiffTime {udtSeconds = 0, udtMicroSeconds = -345678}
microSecondsToUnixDiffTime :: Integral a => a -> UnixDiffTime
microSecondsToUnixDiffTime :: forall a. Integral a => a -> UnixDiffTime
microSecondsToUnixDiffTime = Integer -> UnixDiffTime
fromMicro (Integer -> UnixDiffTime) -> (a -> Integer) -> a -> UnixDiffTime
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> Integer
forall a. Integral a => a -> Integer
toInteger
{-# INLINE microSecondsToUnixDiffTime #-}

----------------------------------------------------------------

toFractional :: Fractional a => UnixDiffTime -> a
toFractional :: forall a. Fractional a => UnixDiffTime -> a
toFractional (UnixDiffTime CTime
s Int32
u) = CTime -> a
forall a b. (Real a, Fractional b) => a -> b
realToFrac CTime
s a -> a -> a
forall a. Num a => a -> a -> a
+ Int32 -> a
forall a b. (Real a, Fractional b) => a -> b
realToFrac Int32
u a -> a -> a
forall a. Fractional a => a -> a -> a
/ a
1000000
{-# SPECIALIZE toFractional :: UnixDiffTime -> Double #-}