-- This file is part of the Wire Server implementation.
--
-- Copyright (C) 2022 Wire Swiss GmbH <opensource@wire.com>
--
-- This program is free software: you can redistribute it and/or modify it under
-- the terms of the GNU Affero General Public License as published by the Free
-- Software Foundation, either version 3 of the License, or (at your option) any
-- later version.
--
-- This program is distributed in the hope that it will be useful, but WITHOUT
-- ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
-- FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License for more
-- details.
--
-- You should have received a copy of the GNU Affero General Public License along
-- with this program. If not, see <https://www.gnu.org/licenses/>.

module Galley.Data.Services
  ( -- * BotMember
    BotMember (..),
    newBotMember,
    botMemId,
    botMemService,
  )
where

import Data.Id
import Galley.Types.Conversations.Members
import Imports
import Wire.API.Provider.Service

-- BotMember ------------------------------------------------------------------

-- | For now we assume bots to always be local
--
-- FUTUREWORK(federation): allow remote bots
newtype BotMember = BotMember {BotMember -> LocalMember
fromBotMember :: LocalMember} deriving (Int -> BotMember -> ShowS
[BotMember] -> ShowS
BotMember -> String
(Int -> BotMember -> ShowS)
-> (BotMember -> String)
-> ([BotMember] -> ShowS)
-> Show BotMember
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> BotMember -> ShowS
showsPrec :: Int -> BotMember -> ShowS
$cshow :: BotMember -> String
show :: BotMember -> String
$cshowList :: [BotMember] -> ShowS
showList :: [BotMember] -> ShowS
Show)

instance Eq BotMember where
  == :: BotMember -> BotMember -> Bool
(==) = BotId -> BotId -> Bool
forall a. Eq a => a -> a -> Bool
(==) (BotId -> BotId -> Bool)
-> (BotMember -> BotId) -> BotMember -> BotMember -> Bool
forall b c a. (b -> b -> c) -> (a -> b) -> a -> a -> c
`on` BotMember -> BotId
botMemId

instance Ord BotMember where
  compare :: BotMember -> BotMember -> Ordering
compare = BotId -> BotId -> Ordering
forall a. Ord a => a -> a -> Ordering
compare (BotId -> BotId -> Ordering)
-> (BotMember -> BotId) -> BotMember -> BotMember -> Ordering
forall b c a. (b -> b -> c) -> (a -> b) -> a -> a -> c
`on` BotMember -> BotId
botMemId

newBotMember :: LocalMember -> Maybe BotMember
newBotMember :: LocalMember -> Maybe BotMember
newBotMember LocalMember
m = LocalMember -> BotMember
BotMember LocalMember
m BotMember -> Maybe ServiceRef -> Maybe BotMember
forall a b. a -> Maybe b -> Maybe a
forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ LocalMember -> Maybe ServiceRef
lmService LocalMember
m

botMemId :: BotMember -> BotId
botMemId :: BotMember -> BotId
botMemId = UserId -> BotId
BotId (UserId -> BotId) -> (BotMember -> UserId) -> BotMember -> BotId
forall b c a. (b -> c) -> (a -> b) -> a -> c
. LocalMember -> UserId
lmId (LocalMember -> UserId)
-> (BotMember -> LocalMember) -> BotMember -> UserId
forall b c a. (b -> c) -> (a -> b) -> a -> c
. BotMember -> LocalMember
fromBotMember

botMemService :: BotMember -> ServiceRef
botMemService :: BotMember -> ServiceRef
botMemService = Maybe ServiceRef -> ServiceRef
forall a. HasCallStack => Maybe a -> a
fromJust (Maybe ServiceRef -> ServiceRef)
-> (BotMember -> Maybe ServiceRef) -> BotMember -> ServiceRef
forall b c a. (b -> c) -> (a -> b) -> a -> c
. LocalMember -> Maybe ServiceRef
lmService (LocalMember -> Maybe ServiceRef)
-> (BotMember -> LocalMember) -> BotMember -> Maybe ServiceRef
forall b c a. (b -> c) -> (a -> b) -> a -> c
. BotMember -> LocalMember
fromBotMember