{-# OPTIONS_GHC -Wno-orphans #-} -- :/

{-|
Module:      SignalDBus.Types
Description: Types used by this package
Copyright:   (c) Lia Lenckowski, 2022
License:     AGPL
Maintainer:  lialenck@protonmail.com
Stability:   experimental
Portability: GNU/Linux, MacOS

This module contains types used by this package. Please import SignalDBus instead.
-}

module SignalDBus.Types (
    SignalConn(..),
    Timestamp,
    Device(..),
    Group(..),
    ReceivedMessage(..),
) where

import Data.Int (Int64)
import DBus.Client (Client)
import DBus.Internal.Types
import Text.Read (readPrec)

-- |Opaque connection object, aquired by 'SignalDBus.withConn' or
-- 'SignalDBus.withConnNum'
data SignalConn = SignalConn !ObjectPath !Client

-- |Timestamp, represented as an ms-precision unix timestamp
newtype Timestamp = Timestamp Int64 deriving (Int -> Timestamp -> ShowS
[Timestamp] -> ShowS
Timestamp -> String
(Int -> Timestamp -> ShowS)
-> (Timestamp -> String)
-> ([Timestamp] -> ShowS)
-> Show Timestamp
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Timestamp] -> ShowS
$cshowList :: [Timestamp] -> ShowS
show :: Timestamp -> String
$cshow :: Timestamp -> String
showsPrec :: Int -> Timestamp -> ShowS
$cshowsPrec :: Int -> Timestamp -> ShowS
Show, ReadPrec [Timestamp]
ReadPrec Timestamp
Int -> ReadS Timestamp
ReadS [Timestamp]
(Int -> ReadS Timestamp)
-> ReadS [Timestamp]
-> ReadPrec Timestamp
-> ReadPrec [Timestamp]
-> Read Timestamp
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [Timestamp]
$creadListPrec :: ReadPrec [Timestamp]
readPrec :: ReadPrec Timestamp
$creadPrec :: ReadPrec Timestamp
readList :: ReadS [Timestamp]
$creadList :: ReadS [Timestamp]
readsPrec :: Int -> ReadS Timestamp
$creadsPrec :: Int -> ReadS Timestamp
Read, Timestamp -> Timestamp -> Bool
(Timestamp -> Timestamp -> Bool)
-> (Timestamp -> Timestamp -> Bool) -> Eq Timestamp
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Timestamp -> Timestamp -> Bool
$c/= :: Timestamp -> Timestamp -> Bool
== :: Timestamp -> Timestamp -> Bool
$c== :: Timestamp -> Timestamp -> Bool
Eq, Eq Timestamp
Eq Timestamp
-> (Timestamp -> Timestamp -> Ordering)
-> (Timestamp -> Timestamp -> Bool)
-> (Timestamp -> Timestamp -> Bool)
-> (Timestamp -> Timestamp -> Bool)
-> (Timestamp -> Timestamp -> Bool)
-> (Timestamp -> Timestamp -> Timestamp)
-> (Timestamp -> Timestamp -> Timestamp)
-> Ord Timestamp
Timestamp -> Timestamp -> Bool
Timestamp -> Timestamp -> Ordering
Timestamp -> Timestamp -> Timestamp
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: Timestamp -> Timestamp -> Timestamp
$cmin :: Timestamp -> Timestamp -> Timestamp
max :: Timestamp -> Timestamp -> Timestamp
$cmax :: Timestamp -> Timestamp -> Timestamp
>= :: Timestamp -> Timestamp -> Bool
$c>= :: Timestamp -> Timestamp -> Bool
> :: Timestamp -> Timestamp -> Bool
$c> :: Timestamp -> Timestamp -> Bool
<= :: Timestamp -> Timestamp -> Bool
$c<= :: Timestamp -> Timestamp -> Bool
< :: Timestamp -> Timestamp -> Bool
$c< :: Timestamp -> Timestamp -> Bool
compare :: Timestamp -> Timestamp -> Ordering
$ccompare :: Timestamp -> Timestamp -> Ordering
$cp1Ord :: Eq Timestamp
Ord)

instance IsVariant Timestamp where
    toVariant :: Timestamp -> Variant
toVariant (Timestamp Int64
ts) = Int64 -> Variant
forall a. IsVariant a => a -> Variant
toVariant Int64
ts
    fromVariant :: Variant -> Maybe Timestamp
fromVariant Variant
v = Int64 -> Timestamp
Timestamp (Int64 -> Timestamp) -> Maybe Int64 -> Maybe Timestamp
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Variant -> Maybe Int64
forall a. IsVariant a => Variant -> Maybe a
fromVariant Variant
v

instance IsValue Timestamp where
    typeOf_ :: Proxy Timestamp -> Type
typeOf_ Proxy Timestamp
_ = Type
TypeInt64
    toValue :: Timestamp -> Value
toValue (Timestamp Int64
ts) = Int64 -> Value
forall a. IsValue a => a -> Value
toValue Int64
ts
    fromValue :: Value -> Maybe Timestamp
fromValue Value
v = Int64 -> Timestamp
Timestamp (Int64 -> Timestamp) -> Maybe Int64 -> Maybe Timestamp
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Value -> Maybe Int64
forall a. IsValue a => Value -> Maybe a
fromValue Value
v

-- |Opaque object representing a linked device
newtype Device = Device Int64 deriving (Int -> Device -> ShowS
[Device] -> ShowS
Device -> String
(Int -> Device -> ShowS)
-> (Device -> String) -> ([Device] -> ShowS) -> Show Device
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Device] -> ShowS
$cshowList :: [Device] -> ShowS
show :: Device -> String
$cshow :: Device -> String
showsPrec :: Int -> Device -> ShowS
$cshowsPrec :: Int -> Device -> ShowS
Show, ReadPrec [Device]
ReadPrec Device
Int -> ReadS Device
ReadS [Device]
(Int -> ReadS Device)
-> ReadS [Device]
-> ReadPrec Device
-> ReadPrec [Device]
-> Read Device
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [Device]
$creadListPrec :: ReadPrec [Device]
readPrec :: ReadPrec Device
$creadPrec :: ReadPrec Device
readList :: ReadS [Device]
$creadList :: ReadS [Device]
readsPrec :: Int -> ReadS Device
$creadsPrec :: Int -> ReadS Device
Read, Device -> Device -> Bool
(Device -> Device -> Bool)
-> (Device -> Device -> Bool) -> Eq Device
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Device -> Device -> Bool
$c/= :: Device -> Device -> Bool
== :: Device -> Device -> Bool
$c== :: Device -> Device -> Bool
Eq)
instance IsVariant Device where
    toVariant :: Device -> Variant
toVariant (Device Int64
i) = Int64 -> Variant
forall a. IsVariant a => a -> Variant
toVariant Int64
i
    fromVariant :: Variant -> Maybe Device
fromVariant Variant
v = Int64 -> Device
Device (Int64 -> Device) -> Maybe Int64 -> Maybe Device
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Variant -> Maybe Int64
forall a. IsVariant a => Variant -> Maybe a
fromVariant Variant
v

instance IsValue Device where
    typeOf_ :: Proxy Device -> Type
typeOf_ Proxy Device
_ = Type
TypeInt64
    toValue :: Device -> Value
toValue (Device Int64
i) = Int64 -> Value
forall a. IsValue a => a -> Value
toValue Int64
i
    fromValue :: Value -> Maybe Device
fromValue Value
v = Int64 -> Device
Device (Int64 -> Device) -> Maybe Int64 -> Maybe Device
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Value -> Maybe Int64
forall a. IsValue a => Value -> Maybe a
fromValue Value
v

instance Read ObjectPath where -- :/
    readPrec :: ReadPrec ObjectPath
readPrec = String -> ObjectPath
ObjectPath (String -> ObjectPath) -> ReadPrec String -> ReadPrec ObjectPath
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ReadPrec String
forall a. Read a => ReadPrec a
readPrec

-- |Opaque Group object, aquired by 'SignalDBus.listGroups' or 'SignalDBus.getGroup'
newtype Group = Group ObjectPath deriving (Int -> Group -> ShowS
[Group] -> ShowS
Group -> String
(Int -> Group -> ShowS)
-> (Group -> String) -> ([Group] -> ShowS) -> Show Group
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Group] -> ShowS
$cshowList :: [Group] -> ShowS
show :: Group -> String
$cshow :: Group -> String
showsPrec :: Int -> Group -> ShowS
$cshowsPrec :: Int -> Group -> ShowS
Show, ReadPrec [Group]
ReadPrec Group
Int -> ReadS Group
ReadS [Group]
(Int -> ReadS Group)
-> ReadS [Group]
-> ReadPrec Group
-> ReadPrec [Group]
-> Read Group
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [Group]
$creadListPrec :: ReadPrec [Group]
readPrec :: ReadPrec Group
$creadPrec :: ReadPrec Group
readList :: ReadS [Group]
$creadList :: ReadS [Group]
readsPrec :: Int -> ReadS Group
$creadsPrec :: Int -> ReadS Group
Read, Group -> Group -> Bool
(Group -> Group -> Bool) -> (Group -> Group -> Bool) -> Eq Group
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Group -> Group -> Bool
$c/= :: Group -> Group -> Bool
== :: Group -> Group -> Bool
$c== :: Group -> Group -> Bool
Eq, Eq Group
Eq Group
-> (Group -> Group -> Ordering)
-> (Group -> Group -> Bool)
-> (Group -> Group -> Bool)
-> (Group -> Group -> Bool)
-> (Group -> Group -> Bool)
-> (Group -> Group -> Group)
-> (Group -> Group -> Group)
-> Ord Group
Group -> Group -> Bool
Group -> Group -> Ordering
Group -> Group -> Group
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: Group -> Group -> Group
$cmin :: Group -> Group -> Group
max :: Group -> Group -> Group
$cmax :: Group -> Group -> Group
>= :: Group -> Group -> Bool
$c>= :: Group -> Group -> Bool
> :: Group -> Group -> Bool
$c> :: Group -> Group -> Bool
<= :: Group -> Group -> Bool
$c<= :: Group -> Group -> Bool
< :: Group -> Group -> Bool
$c< :: Group -> Group -> Bool
compare :: Group -> Group -> Ordering
$ccompare :: Group -> Group -> Ordering
$cp1Ord :: Eq Group
Ord)
instance IsVariant Group where
    toVariant :: Group -> Variant
toVariant (Group ObjectPath
i) = ObjectPath -> Variant
forall a. IsVariant a => a -> Variant
toVariant ObjectPath
i
    fromVariant :: Variant -> Maybe Group
fromVariant Variant
v = ObjectPath -> Group
Group (ObjectPath -> Group) -> Maybe ObjectPath -> Maybe Group
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Variant -> Maybe ObjectPath
forall a. IsVariant a => Variant -> Maybe a
fromVariant Variant
v

instance IsValue Group where
    typeOf_ :: Proxy Group -> Type
typeOf_ Proxy Group
_ = Type
TypeObjectPath
    toValue :: Group -> Value
toValue (Group ObjectPath
i) = ObjectPath -> Value
forall a. IsValue a => a -> Value
toValue ObjectPath
i
    fromValue :: Value -> Maybe Group
fromValue Value
v = ObjectPath -> Group
Group (ObjectPath -> Group) -> Maybe ObjectPath -> Maybe Group
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Value -> Maybe ObjectPath
forall a. IsValue a => Value -> Maybe a
fromValue Value
v

-- |Received message
data ReceivedMessage =
    -- |Message sent by a linked device to someone else
    SyncMessage
        Timestamp     -- ^ When this message was sent
        String        -- ^ Message sender (TODO: always yourself?)
        (Maybe Group) -- ^ If sent in a group, corresponding group object
        String        -- ^ Message text
        [String]      -- ^ Paths to stored attachments

    -- |Read receipt sent by someone else in response to one of your messages
  | Receipt
        Timestamp -- ^ Which message was read
        String    -- ^ Phone number of the receipt sender

    -- |Message sent to you by someone else
  | Message
        Timestamp     -- ^ When this message was sent
        String        -- ^ Message sender
        (Maybe Group) -- ^ If sent in a group, corresponding group object
        String        -- ^ Message text
        [String]      -- ^ Paths to stored attachments

    deriving (Int -> ReceivedMessage -> ShowS
[ReceivedMessage] -> ShowS
ReceivedMessage -> String
(Int -> ReceivedMessage -> ShowS)
-> (ReceivedMessage -> String)
-> ([ReceivedMessage] -> ShowS)
-> Show ReceivedMessage
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ReceivedMessage] -> ShowS
$cshowList :: [ReceivedMessage] -> ShowS
show :: ReceivedMessage -> String
$cshow :: ReceivedMessage -> String
showsPrec :: Int -> ReceivedMessage -> ShowS
$cshowsPrec :: Int -> ReceivedMessage -> ShowS
Show, ReadPrec [ReceivedMessage]
ReadPrec ReceivedMessage
Int -> ReadS ReceivedMessage
ReadS [ReceivedMessage]
(Int -> ReadS ReceivedMessage)
-> ReadS [ReceivedMessage]
-> ReadPrec ReceivedMessage
-> ReadPrec [ReceivedMessage]
-> Read ReceivedMessage
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [ReceivedMessage]
$creadListPrec :: ReadPrec [ReceivedMessage]
readPrec :: ReadPrec ReceivedMessage
$creadPrec :: ReadPrec ReceivedMessage
readList :: ReadS [ReceivedMessage]
$creadList :: ReadS [ReceivedMessage]
readsPrec :: Int -> ReadS ReceivedMessage
$creadsPrec :: Int -> ReadS ReceivedMessage
Read, ReceivedMessage -> ReceivedMessage -> Bool
(ReceivedMessage -> ReceivedMessage -> Bool)
-> (ReceivedMessage -> ReceivedMessage -> Bool)
-> Eq ReceivedMessage
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ReceivedMessage -> ReceivedMessage -> Bool
$c/= :: ReceivedMessage -> ReceivedMessage -> Bool
== :: ReceivedMessage -> ReceivedMessage -> Bool
$c== :: ReceivedMessage -> ReceivedMessage -> Bool
Eq, Eq ReceivedMessage
Eq ReceivedMessage
-> (ReceivedMessage -> ReceivedMessage -> Ordering)
-> (ReceivedMessage -> ReceivedMessage -> Bool)
-> (ReceivedMessage -> ReceivedMessage -> Bool)
-> (ReceivedMessage -> ReceivedMessage -> Bool)
-> (ReceivedMessage -> ReceivedMessage -> Bool)
-> (ReceivedMessage -> ReceivedMessage -> ReceivedMessage)
-> (ReceivedMessage -> ReceivedMessage -> ReceivedMessage)
-> Ord ReceivedMessage
ReceivedMessage -> ReceivedMessage -> Bool
ReceivedMessage -> ReceivedMessage -> Ordering
ReceivedMessage -> ReceivedMessage -> ReceivedMessage
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: ReceivedMessage -> ReceivedMessage -> ReceivedMessage
$cmin :: ReceivedMessage -> ReceivedMessage -> ReceivedMessage
max :: ReceivedMessage -> ReceivedMessage -> ReceivedMessage
$cmax :: ReceivedMessage -> ReceivedMessage -> ReceivedMessage
>= :: ReceivedMessage -> ReceivedMessage -> Bool
$c>= :: ReceivedMessage -> ReceivedMessage -> Bool
> :: ReceivedMessage -> ReceivedMessage -> Bool
$c> :: ReceivedMessage -> ReceivedMessage -> Bool
<= :: ReceivedMessage -> ReceivedMessage -> Bool
$c<= :: ReceivedMessage -> ReceivedMessage -> Bool
< :: ReceivedMessage -> ReceivedMessage -> Bool
$c< :: ReceivedMessage -> ReceivedMessage -> Bool
compare :: ReceivedMessage -> ReceivedMessage -> Ordering
$ccompare :: ReceivedMessage -> ReceivedMessage -> Ordering
$cp1Ord :: Eq ReceivedMessage
Ord)