{-# LANGUAGE DeriveFoldable #-}
module Util (module Util, toList) where

import Data.Foldable (toList)
import Data.Maybe (fromMaybe)
import Data.Time
import Data.Word (Word8)


data Snoc a = SnocNil | Snoc (Snoc a) a
  deriving (Show, Foldable)

-- | Time-of-day, in unspecified time zone
data YMDHMS = YMDHMS {-# UNPACK #-} !YMD
                     {-# UNPACK #-} !HMS
  deriving (Show)

-- | Calendar day
data YMD = YMD {-# UNPACK #-} !Int
               {-# UNPACK #-} !Word8  -- ^ 1-based
               {-# UNPACK #-} !Word8
  deriving (Show, Eq, Ord)

-- | Time-of-day in seconds, in unspecified time zone
data HMS = HMS {-# UNPACK #-} !Word8
               {-# UNPACK #-} !Word8
               {-# UNPACK #-} !Word8
  deriving (Show, Eq, Ord)

pad :: Show a => Char -> Int -> a -> String
pad c w val =
  let s = show val
  in replicate (w - length s) c ++ s

uncurry3 :: (a -> b -> c -> d) -> (a, b, c) -> d
uncurry3 f (x, y, z) = f x y z

dropWhileEnd :: (a -> Bool) -> [a] -> [a]
dropWhileEnd p = fromMaybe [] . go
  where
    go [] = Nothing
    go (x:xs) =
      case go xs of
        Nothing | p x -> Nothing
                | otherwise -> Just [x]
        Just xs' -> Just (x : xs')

ymdToString :: YMD -> String
ymdToString (YMD y m d) = pad '0' 4 y ++ '-' : pad '0' 2 m ++ '-' : pad '0' 2 d

dayToYMD :: Day -> YMD
dayToYMD day =
  let (y, m, d) = toGregorian day
  in YMD (fromIntegral y) (fromIntegral m) (fromIntegral d)

ymdToGregorian :: YMD -> (Year, MonthOfYear, DayOfMonth)
ymdToGregorian (YMD y m d) = (fromIntegral y, fromIntegral m, fromIntegral d)

ymdFromGregorian :: (Year, MonthOfYear, DayOfMonth) -> YMD
ymdFromGregorian (y, m, d) = YMD (fromIntegral y) (fromIntegral m) (fromIntegral d)