module Matterhorn.State.PostListOverlay
  ( enterFlaggedPostListMode
  , enterPinnedPostListMode
  , enterSearchResultPostListMode
  , postListJumpToCurrent
  , postListSelectUp
  , postListSelectDown
  , postListUnflagSelected
  , exitPostListMode
  )
where

import           GHC.Exts ( IsList(..) )
import           Prelude ()
import           Matterhorn.Prelude

import qualified Data.Foldable as F
import qualified Data.Text as T
import           Lens.Micro.Platform ( (.=) )
import           Network.Mattermost.Endpoints
import           Network.Mattermost.Types

import           Matterhorn.State.Messages ( jumpToPost )
import           Matterhorn.State.Common
import           Matterhorn.State.MessageSelect
import           Matterhorn.State.Messages ( addObtainedMessages
                                           , asyncFetchMessagesSurrounding )
import           Matterhorn.Types
import           Matterhorn.Types.DirectionalSeq (emptyDirSeq)


-- | Create a PostListOverlay with the given content description and
-- with a specified list of messages.
enterPostListMode ::  PostListContents -> Messages -> MH ()
enterPostListMode :: PostListContents -> Messages -> MH ()
enterPostListMode PostListContents
contents Messages
msgs = do
  (TeamState -> Identity TeamState)
-> ChatState -> Identity ChatState
Lens' ChatState TeamState
csCurrentTeam((TeamState -> Identity TeamState)
 -> ChatState -> Identity ChatState)
-> ((Messages -> Identity Messages)
    -> TeamState -> Identity TeamState)
-> (Messages -> Identity Messages)
-> ChatState
-> Identity ChatState
forall b c a. (b -> c) -> (a -> b) -> a -> c
.(PostListOverlayState -> Identity PostListOverlayState)
-> TeamState -> Identity TeamState
Lens' TeamState PostListOverlayState
tsPostListOverlay((PostListOverlayState -> Identity PostListOverlayState)
 -> TeamState -> Identity TeamState)
-> ((Messages -> Identity Messages)
    -> PostListOverlayState -> Identity PostListOverlayState)
-> (Messages -> Identity Messages)
-> TeamState
-> Identity TeamState
forall b c a. (b -> c) -> (a -> b) -> a -> c
.(Messages -> Identity Messages)
-> PostListOverlayState -> Identity PostListOverlayState
Lens' PostListOverlayState Messages
postListPosts ((Messages -> Identity Messages)
 -> ChatState -> Identity ChatState)
-> Messages -> MH ()
forall s (m :: * -> *) a b.
MonadState s m =>
ASetter s s a b -> b -> m ()
.= Messages
msgs
  let mlatest :: Maybe Message
mlatest = Messages -> Maybe Message
getLatestPostMsg Messages
msgs
      pId :: Maybe PostId
pId = Maybe Message
mlatest Maybe Message -> (Message -> Maybe PostId) -> Maybe PostId
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Message -> Maybe PostId
messagePostId
      cId :: Maybe ChannelId
cId = Maybe Message
mlatest Maybe Message -> (Message -> Maybe ChannelId) -> Maybe ChannelId
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \Message
m -> Message
mMessage
-> Getting (Maybe ChannelId) Message (Maybe ChannelId)
-> Maybe ChannelId
forall s a. s -> Getting a s a -> a
^.Getting (Maybe ChannelId) Message (Maybe ChannelId)
Lens' Message (Maybe ChannelId)
mChannelId
  (TeamState -> Identity TeamState)
-> ChatState -> Identity ChatState
Lens' ChatState TeamState
csCurrentTeam((TeamState -> Identity TeamState)
 -> ChatState -> Identity ChatState)
-> ((Maybe PostId -> Identity (Maybe PostId))
    -> TeamState -> Identity TeamState)
-> (Maybe PostId -> Identity (Maybe PostId))
-> ChatState
-> Identity ChatState
forall b c a. (b -> c) -> (a -> b) -> a -> c
.(PostListOverlayState -> Identity PostListOverlayState)
-> TeamState -> Identity TeamState
Lens' TeamState PostListOverlayState
tsPostListOverlay((PostListOverlayState -> Identity PostListOverlayState)
 -> TeamState -> Identity TeamState)
-> ((Maybe PostId -> Identity (Maybe PostId))
    -> PostListOverlayState -> Identity PostListOverlayState)
-> (Maybe PostId -> Identity (Maybe PostId))
-> TeamState
-> Identity TeamState
forall b c a. (b -> c) -> (a -> b) -> a -> c
.(Maybe PostId -> Identity (Maybe PostId))
-> PostListOverlayState -> Identity PostListOverlayState
Lens' PostListOverlayState (Maybe PostId)
postListSelected ((Maybe PostId -> Identity (Maybe PostId))
 -> ChatState -> Identity ChatState)
-> Maybe PostId -> MH ()
forall s (m :: * -> *) a b.
MonadState s m =>
ASetter s s a b -> b -> m ()
.= Maybe PostId
pId
  Mode -> MH ()
setMode (Mode -> MH ()) -> Mode -> MH ()
forall a b. (a -> b) -> a -> b
$ PostListContents -> Mode
PostListOverlay PostListContents
contents
  case (Maybe PostId
pId, Maybe ChannelId
cId) of
    (Just PostId
p, Just ChannelId
c) -> ChannelId -> PostId -> MH ()
asyncFetchMessagesSurrounding ChannelId
c PostId
p
    (Maybe PostId, Maybe ChannelId)
_ -> () -> MH ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

-- | Clear out the state of a PostListOverlay
exitPostListMode :: MH ()
exitPostListMode :: MH ()
exitPostListMode = do
  (TeamState -> Identity TeamState)
-> ChatState -> Identity ChatState
Lens' ChatState TeamState
csCurrentTeam((TeamState -> Identity TeamState)
 -> ChatState -> Identity ChatState)
-> ((Messages -> Identity Messages)
    -> TeamState -> Identity TeamState)
-> (Messages -> Identity Messages)
-> ChatState
-> Identity ChatState
forall b c a. (b -> c) -> (a -> b) -> a -> c
.(PostListOverlayState -> Identity PostListOverlayState)
-> TeamState -> Identity TeamState
Lens' TeamState PostListOverlayState
tsPostListOverlay((PostListOverlayState -> Identity PostListOverlayState)
 -> TeamState -> Identity TeamState)
-> ((Messages -> Identity Messages)
    -> PostListOverlayState -> Identity PostListOverlayState)
-> (Messages -> Identity Messages)
-> TeamState
-> Identity TeamState
forall b c a. (b -> c) -> (a -> b) -> a -> c
.(Messages -> Identity Messages)
-> PostListOverlayState -> Identity PostListOverlayState
Lens' PostListOverlayState Messages
postListPosts ((Messages -> Identity Messages)
 -> ChatState -> Identity ChatState)
-> Messages -> MH ()
forall s (m :: * -> *) a b.
MonadState s m =>
ASetter s s a b -> b -> m ()
.= Messages
forall dir a. DirectionalSeq dir a
emptyDirSeq
  (TeamState -> Identity TeamState)
-> ChatState -> Identity ChatState
Lens' ChatState TeamState
csCurrentTeam((TeamState -> Identity TeamState)
 -> ChatState -> Identity ChatState)
-> ((Maybe PostId -> Identity (Maybe PostId))
    -> TeamState -> Identity TeamState)
-> (Maybe PostId -> Identity (Maybe PostId))
-> ChatState
-> Identity ChatState
forall b c a. (b -> c) -> (a -> b) -> a -> c
.(PostListOverlayState -> Identity PostListOverlayState)
-> TeamState -> Identity TeamState
Lens' TeamState PostListOverlayState
tsPostListOverlay((PostListOverlayState -> Identity PostListOverlayState)
 -> TeamState -> Identity TeamState)
-> ((Maybe PostId -> Identity (Maybe PostId))
    -> PostListOverlayState -> Identity PostListOverlayState)
-> (Maybe PostId -> Identity (Maybe PostId))
-> TeamState
-> Identity TeamState
forall b c a. (b -> c) -> (a -> b) -> a -> c
.(Maybe PostId -> Identity (Maybe PostId))
-> PostListOverlayState -> Identity PostListOverlayState
Lens' PostListOverlayState (Maybe PostId)
postListSelected ((Maybe PostId -> Identity (Maybe PostId))
 -> ChatState -> Identity ChatState)
-> Maybe PostId -> MH ()
forall s (m :: * -> *) a b.
MonadState s m =>
ASetter s s a b -> b -> m ()
.= Maybe PostId
forall a. Maybe a
Nothing
  Mode -> MH ()
setMode Mode
Main


createPostList :: TeamId -> PostListContents -> (Session -> IO Posts) -> MH ()
createPostList :: TeamId -> PostListContents -> (Session -> IO Posts) -> MH ()
createPostList TeamId
tId PostListContents
contentsType Session -> IO Posts
fetchOp = do
  Session
session <- MH Session
getSession
  AsyncPriority -> IO (Maybe (MH ())) -> MH ()
doAsyncWith AsyncPriority
Preempt (IO (Maybe (MH ())) -> MH ()) -> IO (Maybe (MH ())) -> MH ()
forall a b. (a -> b) -> a -> b
$ do
    Posts
posts <- Session -> IO Posts
fetchOp Session
session
    Maybe (MH ()) -> IO (Maybe (MH ()))
forall (m :: * -> *) a. Monad m => a -> m a
return (Maybe (MH ()) -> IO (Maybe (MH ())))
-> Maybe (MH ()) -> IO (Maybe (MH ()))
forall a b. (a -> b) -> a -> b
$ MH () -> Maybe (MH ())
forall a. a -> Maybe a
Just (MH () -> Maybe (MH ())) -> MH () -> Maybe (MH ())
forall a b. (a -> b) -> a -> b
$ do
      Messages
messages <- Maybe TeamId -> Posts -> MH Messages
installMessagesFromPosts (TeamId -> Maybe TeamId
forall a. a -> Maybe a
Just TeamId
tId) Posts
posts
      -- n.b. do not use addNewPostedMessage because these messages
      -- are not new, and so no notifications or channel highlighting
      -- or other post-processing should be performed.
      let plist :: [Post]
plist = HashMap PostId Post -> [Post]
forall (t :: * -> *) a. Foldable t => t a -> [a]
F.toList (HashMap PostId Post -> [Post]) -> HashMap PostId Post -> [Post]
forall a b. (a -> b) -> a -> b
$ Posts -> HashMap PostId Post
postsPosts Posts
posts
          postsSpec :: Post -> Posts
postsSpec Post
p = Posts :: HashMap PostId Post -> Seq PostId -> Posts
Posts { postsPosts :: HashMap PostId Post
postsPosts = [Item (HashMap PostId Post)] -> HashMap PostId Post
forall l. IsList l => [Item l] -> l
fromList [(Post -> PostId
postId Post
p, Post
p)]
                              , postsOrder :: Seq PostId
postsOrder = [Item (Seq PostId)] -> Seq PostId
forall l. IsList l => [Item l] -> l
fromList [Post -> PostId
postId Post
p]
                              }
      (Post -> MH PostProcessMessageAdd) -> [Post] -> MH ()
forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
(a -> m b) -> t a -> m ()
mapM_ (\Post
p -> ChannelId -> Int -> Bool -> Posts -> MH PostProcessMessageAdd
addObtainedMessages (Post -> ChannelId
postChannelId Post
p) Int
0 Bool
False (Posts -> MH PostProcessMessageAdd)
-> Posts -> MH PostProcessMessageAdd
forall a b. (a -> b) -> a -> b
$ Post -> Posts
postsSpec Post
p) [Post]
plist
      PostListContents -> Messages -> MH ()
enterPostListMode PostListContents
contentsType Messages
messages


-- | Create a PostListOverlay with flagged messages from the server.
enterFlaggedPostListMode :: MH ()
enterFlaggedPostListMode :: MH ()
enterFlaggedPostListMode = do
    TeamId
tId <- Getting TeamId ChatState TeamId -> MH TeamId
forall s (m :: * -> *) a. MonadState s m => Getting a s a -> m a
use Getting TeamId ChatState TeamId
SimpleGetter ChatState TeamId
csCurrentTeamId
    TeamId -> PostListContents -> (Session -> IO Posts) -> MH ()
createPostList TeamId
tId PostListContents
PostListFlagged ((Session -> IO Posts) -> MH ()) -> (Session -> IO Posts) -> MH ()
forall a b. (a -> b) -> a -> b
$
        UserParam -> FlaggedPostsQuery -> Session -> IO Posts
mmGetListOfFlaggedPosts UserParam
UserMe FlaggedPostsQuery
defaultFlaggedPostsQuery

-- | Create a PostListOverlay with pinned messages from the server for
-- the current channel.
enterPinnedPostListMode :: MH ()
enterPinnedPostListMode :: MH ()
enterPinnedPostListMode = do
    TeamId
tId <- Getting TeamId ChatState TeamId -> MH TeamId
forall s (m :: * -> *) a. MonadState s m => Getting a s a -> m a
use Getting TeamId ChatState TeamId
SimpleGetter ChatState TeamId
csCurrentTeamId
    ChannelId
cId <- Getting ChannelId ChatState ChannelId -> MH ChannelId
forall s (m :: * -> *) a. MonadState s m => Getting a s a -> m a
use (TeamId -> SimpleGetter ChatState ChannelId
csCurrentChannelId TeamId
tId)
    TeamId -> PostListContents -> (Session -> IO Posts) -> MH ()
createPostList TeamId
tId (ChannelId -> PostListContents
PostListPinned ChannelId
cId) ((Session -> IO Posts) -> MH ()) -> (Session -> IO Posts) -> MH ()
forall a b. (a -> b) -> a -> b
$ ChannelId -> Session -> IO Posts
mmGetChannelPinnedPosts ChannelId
cId

-- | Create a PostListOverlay with post search result messages from the
-- server.
enterSearchResultPostListMode :: Text -> MH ()
enterSearchResultPostListMode :: Text -> MH ()
enterSearchResultPostListMode Text
terms
  | Text -> Bool
T.null (Text -> Text
T.strip Text
terms) = Text -> MH ()
postInfoMessage Text
"Search command requires at least one search term."
  | Bool
otherwise = do
      PostListContents -> Messages -> MH ()
enterPostListMode (Text -> Bool -> PostListContents
PostListSearch Text
terms Bool
True) Messages
noMessages
      TeamId
tId <- Getting TeamId ChatState TeamId -> MH TeamId
forall s (m :: * -> *) a. MonadState s m => Getting a s a -> m a
use Getting TeamId ChatState TeamId
SimpleGetter ChatState TeamId
csCurrentTeamId
      TeamId -> PostListContents -> (Session -> IO Posts) -> MH ()
createPostList TeamId
tId (Text -> Bool -> PostListContents
PostListSearch Text
terms Bool
False) ((Session -> IO Posts) -> MH ()) -> (Session -> IO Posts) -> MH ()
forall a b. (a -> b) -> a -> b
$
        TeamId -> SearchPosts -> Session -> IO Posts
mmSearchForTeamPosts TeamId
tId (Text -> Bool -> SearchPosts
SearchPosts Text
terms Bool
False)


-- | Move the selection up in the PostListOverlay, which corresponds
-- to finding a chronologically /newer/ message.
postListSelectUp :: MH ()
postListSelectUp :: MH ()
postListSelectUp = do
  Maybe PostId
selId <- Getting (Maybe PostId) ChatState (Maybe PostId)
-> MH (Maybe PostId)
forall s (m :: * -> *) a. MonadState s m => Getting a s a -> m a
use ((TeamState -> Const (Maybe PostId) TeamState)
-> ChatState -> Const (Maybe PostId) ChatState
Lens' ChatState TeamState
csCurrentTeam((TeamState -> Const (Maybe PostId) TeamState)
 -> ChatState -> Const (Maybe PostId) ChatState)
-> ((Maybe PostId -> Const (Maybe PostId) (Maybe PostId))
    -> TeamState -> Const (Maybe PostId) TeamState)
-> Getting (Maybe PostId) ChatState (Maybe PostId)
forall b c a. (b -> c) -> (a -> b) -> a -> c
.(PostListOverlayState -> Const (Maybe PostId) PostListOverlayState)
-> TeamState -> Const (Maybe PostId) TeamState
Lens' TeamState PostListOverlayState
tsPostListOverlay((PostListOverlayState
  -> Const (Maybe PostId) PostListOverlayState)
 -> TeamState -> Const (Maybe PostId) TeamState)
-> ((Maybe PostId -> Const (Maybe PostId) (Maybe PostId))
    -> PostListOverlayState
    -> Const (Maybe PostId) PostListOverlayState)
-> (Maybe PostId -> Const (Maybe PostId) (Maybe PostId))
-> TeamState
-> Const (Maybe PostId) TeamState
forall b c a. (b -> c) -> (a -> b) -> a -> c
.(Maybe PostId -> Const (Maybe PostId) (Maybe PostId))
-> PostListOverlayState
-> Const (Maybe PostId) PostListOverlayState
Lens' PostListOverlayState (Maybe PostId)
postListSelected)
  Messages
posts <- Getting Messages ChatState Messages -> MH Messages
forall s (m :: * -> *) a. MonadState s m => Getting a s a -> m a
use ((TeamState -> Const Messages TeamState)
-> ChatState -> Const Messages ChatState
Lens' ChatState TeamState
csCurrentTeam((TeamState -> Const Messages TeamState)
 -> ChatState -> Const Messages ChatState)
-> ((Messages -> Const Messages Messages)
    -> TeamState -> Const Messages TeamState)
-> Getting Messages ChatState Messages
forall b c a. (b -> c) -> (a -> b) -> a -> c
.(PostListOverlayState -> Const Messages PostListOverlayState)
-> TeamState -> Const Messages TeamState
Lens' TeamState PostListOverlayState
tsPostListOverlay((PostListOverlayState -> Const Messages PostListOverlayState)
 -> TeamState -> Const Messages TeamState)
-> ((Messages -> Const Messages Messages)
    -> PostListOverlayState -> Const Messages PostListOverlayState)
-> (Messages -> Const Messages Messages)
-> TeamState
-> Const Messages TeamState
forall b c a. (b -> c) -> (a -> b) -> a -> c
.(Messages -> Const Messages Messages)
-> PostListOverlayState -> Const Messages PostListOverlayState
Lens' PostListOverlayState Messages
postListPosts)
  let nextMsg :: Maybe Message
nextMsg = Maybe MessageId -> Messages -> Maybe Message
getNextMessage (PostId -> MessageId
MessagePostId (PostId -> MessageId) -> Maybe PostId -> Maybe MessageId
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe PostId
selId) Messages
posts
  case Maybe Message
nextMsg of
    Maybe Message
Nothing -> () -> MH ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
    Just Message
m -> do
      let pId :: Maybe PostId
pId = Message
mMessage
-> Getting (Maybe MessageId) Message (Maybe MessageId)
-> Maybe MessageId
forall s a. s -> Getting a s a -> a
^.Getting (Maybe MessageId) Message (Maybe MessageId)
Lens' Message (Maybe MessageId)
mMessageId Maybe MessageId -> (MessageId -> Maybe PostId) -> Maybe PostId
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= MessageId -> Maybe PostId
messageIdPostId
      (TeamState -> Identity TeamState)
-> ChatState -> Identity ChatState
Lens' ChatState TeamState
csCurrentTeam((TeamState -> Identity TeamState)
 -> ChatState -> Identity ChatState)
-> ((Maybe PostId -> Identity (Maybe PostId))
    -> TeamState -> Identity TeamState)
-> (Maybe PostId -> Identity (Maybe PostId))
-> ChatState
-> Identity ChatState
forall b c a. (b -> c) -> (a -> b) -> a -> c
.(PostListOverlayState -> Identity PostListOverlayState)
-> TeamState -> Identity TeamState
Lens' TeamState PostListOverlayState
tsPostListOverlay((PostListOverlayState -> Identity PostListOverlayState)
 -> TeamState -> Identity TeamState)
-> ((Maybe PostId -> Identity (Maybe PostId))
    -> PostListOverlayState -> Identity PostListOverlayState)
-> (Maybe PostId -> Identity (Maybe PostId))
-> TeamState
-> Identity TeamState
forall b c a. (b -> c) -> (a -> b) -> a -> c
.(Maybe PostId -> Identity (Maybe PostId))
-> PostListOverlayState -> Identity PostListOverlayState
Lens' PostListOverlayState (Maybe PostId)
postListSelected ((Maybe PostId -> Identity (Maybe PostId))
 -> ChatState -> Identity ChatState)
-> Maybe PostId -> MH ()
forall s (m :: * -> *) a b.
MonadState s m =>
ASetter s s a b -> b -> m ()
.= Maybe PostId
pId
      case (Message
mMessage
-> Getting (Maybe ChannelId) Message (Maybe ChannelId)
-> Maybe ChannelId
forall s a. s -> Getting a s a -> a
^.Getting (Maybe ChannelId) Message (Maybe ChannelId)
Lens' Message (Maybe ChannelId)
mChannelId, Maybe PostId
pId) of
        (Just ChannelId
c, Just PostId
p) -> ChannelId -> PostId -> MH ()
asyncFetchMessagesSurrounding ChannelId
c PostId
p
        (Maybe ChannelId, Maybe PostId)
o -> LogCategory -> Text -> MH ()
mhLog LogCategory
LogError
             (String -> Text
T.pack (String -> Text) -> String -> Text
forall a b. (a -> b) -> a -> b
$ String
"postListSelectUp" String -> String -> String
forall a. Semigroup a => a -> a -> a
<>
              String
" unable to get channel or post ID: " String -> String -> String
forall a. Semigroup a => a -> a -> a
<> (Maybe ChannelId, Maybe PostId) -> String
forall a. Show a => a -> String
show (Maybe ChannelId, Maybe PostId)
o)

-- | Move the selection down in the PostListOverlay, which corresponds
-- to finding a chronologically /old/ message.
postListSelectDown :: MH ()
postListSelectDown :: MH ()
postListSelectDown = do
  Maybe PostId
selId <- Getting (Maybe PostId) ChatState (Maybe PostId)
-> MH (Maybe PostId)
forall s (m :: * -> *) a. MonadState s m => Getting a s a -> m a
use ((TeamState -> Const (Maybe PostId) TeamState)
-> ChatState -> Const (Maybe PostId) ChatState
Lens' ChatState TeamState
csCurrentTeam((TeamState -> Const (Maybe PostId) TeamState)
 -> ChatState -> Const (Maybe PostId) ChatState)
-> ((Maybe PostId -> Const (Maybe PostId) (Maybe PostId))
    -> TeamState -> Const (Maybe PostId) TeamState)
-> Getting (Maybe PostId) ChatState (Maybe PostId)
forall b c a. (b -> c) -> (a -> b) -> a -> c
.(PostListOverlayState -> Const (Maybe PostId) PostListOverlayState)
-> TeamState -> Const (Maybe PostId) TeamState
Lens' TeamState PostListOverlayState
tsPostListOverlay((PostListOverlayState
  -> Const (Maybe PostId) PostListOverlayState)
 -> TeamState -> Const (Maybe PostId) TeamState)
-> ((Maybe PostId -> Const (Maybe PostId) (Maybe PostId))
    -> PostListOverlayState
    -> Const (Maybe PostId) PostListOverlayState)
-> (Maybe PostId -> Const (Maybe PostId) (Maybe PostId))
-> TeamState
-> Const (Maybe PostId) TeamState
forall b c a. (b -> c) -> (a -> b) -> a -> c
.(Maybe PostId -> Const (Maybe PostId) (Maybe PostId))
-> PostListOverlayState
-> Const (Maybe PostId) PostListOverlayState
Lens' PostListOverlayState (Maybe PostId)
postListSelected)
  Messages
posts <- Getting Messages ChatState Messages -> MH Messages
forall s (m :: * -> *) a. MonadState s m => Getting a s a -> m a
use ((TeamState -> Const Messages TeamState)
-> ChatState -> Const Messages ChatState
Lens' ChatState TeamState
csCurrentTeam((TeamState -> Const Messages TeamState)
 -> ChatState -> Const Messages ChatState)
-> ((Messages -> Const Messages Messages)
    -> TeamState -> Const Messages TeamState)
-> Getting Messages ChatState Messages
forall b c a. (b -> c) -> (a -> b) -> a -> c
.(PostListOverlayState -> Const Messages PostListOverlayState)
-> TeamState -> Const Messages TeamState
Lens' TeamState PostListOverlayState
tsPostListOverlay((PostListOverlayState -> Const Messages PostListOverlayState)
 -> TeamState -> Const Messages TeamState)
-> ((Messages -> Const Messages Messages)
    -> PostListOverlayState -> Const Messages PostListOverlayState)
-> (Messages -> Const Messages Messages)
-> TeamState
-> Const Messages TeamState
forall b c a. (b -> c) -> (a -> b) -> a -> c
.(Messages -> Const Messages Messages)
-> PostListOverlayState -> Const Messages PostListOverlayState
Lens' PostListOverlayState Messages
postListPosts)
  let prevMsg :: Maybe Message
prevMsg = Maybe MessageId -> Messages -> Maybe Message
getPrevMessage (PostId -> MessageId
MessagePostId (PostId -> MessageId) -> Maybe PostId -> Maybe MessageId
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe PostId
selId) Messages
posts
  case Maybe Message
prevMsg of
    Maybe Message
Nothing -> () -> MH ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
    Just Message
m -> do
      let pId :: Maybe PostId
pId = Message
mMessage
-> Getting (Maybe MessageId) Message (Maybe MessageId)
-> Maybe MessageId
forall s a. s -> Getting a s a -> a
^.Getting (Maybe MessageId) Message (Maybe MessageId)
Lens' Message (Maybe MessageId)
mMessageId Maybe MessageId -> (MessageId -> Maybe PostId) -> Maybe PostId
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= MessageId -> Maybe PostId
messageIdPostId
      (TeamState -> Identity TeamState)
-> ChatState -> Identity ChatState
Lens' ChatState TeamState
csCurrentTeam((TeamState -> Identity TeamState)
 -> ChatState -> Identity ChatState)
-> ((Maybe PostId -> Identity (Maybe PostId))
    -> TeamState -> Identity TeamState)
-> (Maybe PostId -> Identity (Maybe PostId))
-> ChatState
-> Identity ChatState
forall b c a. (b -> c) -> (a -> b) -> a -> c
.(PostListOverlayState -> Identity PostListOverlayState)
-> TeamState -> Identity TeamState
Lens' TeamState PostListOverlayState
tsPostListOverlay((PostListOverlayState -> Identity PostListOverlayState)
 -> TeamState -> Identity TeamState)
-> ((Maybe PostId -> Identity (Maybe PostId))
    -> PostListOverlayState -> Identity PostListOverlayState)
-> (Maybe PostId -> Identity (Maybe PostId))
-> TeamState
-> Identity TeamState
forall b c a. (b -> c) -> (a -> b) -> a -> c
.(Maybe PostId -> Identity (Maybe PostId))
-> PostListOverlayState -> Identity PostListOverlayState
Lens' PostListOverlayState (Maybe PostId)
postListSelected ((Maybe PostId -> Identity (Maybe PostId))
 -> ChatState -> Identity ChatState)
-> Maybe PostId -> MH ()
forall s (m :: * -> *) a b.
MonadState s m =>
ASetter s s a b -> b -> m ()
.= Maybe PostId
pId
      case (Message
mMessage
-> Getting (Maybe ChannelId) Message (Maybe ChannelId)
-> Maybe ChannelId
forall s a. s -> Getting a s a -> a
^.Getting (Maybe ChannelId) Message (Maybe ChannelId)
Lens' Message (Maybe ChannelId)
mChannelId, Maybe PostId
pId) of
        (Just ChannelId
c, Just PostId
p) -> ChannelId -> PostId -> MH ()
asyncFetchMessagesSurrounding ChannelId
c PostId
p
        (Maybe ChannelId, Maybe PostId)
o -> LogCategory -> Text -> MH ()
mhLog LogCategory
LogError
             (String -> Text
T.pack (String -> Text) -> String -> Text
forall a b. (a -> b) -> a -> b
$ String
"postListSelectDown" String -> String -> String
forall a. Semigroup a => a -> a -> a
<>
              String
" unable to get channel or post ID: " String -> String -> String
forall a. Semigroup a => a -> a -> a
<> (Maybe ChannelId, Maybe PostId) -> String
forall a. Show a => a -> String
show (Maybe ChannelId, Maybe PostId)
o)

-- | Unflag the post currently selected in the PostListOverlay, if any
postListUnflagSelected :: MH ()
postListUnflagSelected :: MH ()
postListUnflagSelected = do
  Maybe PostId
msgId <- Getting (Maybe PostId) ChatState (Maybe PostId)
-> MH (Maybe PostId)
forall s (m :: * -> *) a. MonadState s m => Getting a s a -> m a
use ((TeamState -> Const (Maybe PostId) TeamState)
-> ChatState -> Const (Maybe PostId) ChatState
Lens' ChatState TeamState
csCurrentTeam((TeamState -> Const (Maybe PostId) TeamState)
 -> ChatState -> Const (Maybe PostId) ChatState)
-> ((Maybe PostId -> Const (Maybe PostId) (Maybe PostId))
    -> TeamState -> Const (Maybe PostId) TeamState)
-> Getting (Maybe PostId) ChatState (Maybe PostId)
forall b c a. (b -> c) -> (a -> b) -> a -> c
.(PostListOverlayState -> Const (Maybe PostId) PostListOverlayState)
-> TeamState -> Const (Maybe PostId) TeamState
Lens' TeamState PostListOverlayState
tsPostListOverlay((PostListOverlayState
  -> Const (Maybe PostId) PostListOverlayState)
 -> TeamState -> Const (Maybe PostId) TeamState)
-> ((Maybe PostId -> Const (Maybe PostId) (Maybe PostId))
    -> PostListOverlayState
    -> Const (Maybe PostId) PostListOverlayState)
-> (Maybe PostId -> Const (Maybe PostId) (Maybe PostId))
-> TeamState
-> Const (Maybe PostId) TeamState
forall b c a. (b -> c) -> (a -> b) -> a -> c
.(Maybe PostId -> Const (Maybe PostId) (Maybe PostId))
-> PostListOverlayState
-> Const (Maybe PostId) PostListOverlayState
Lens' PostListOverlayState (Maybe PostId)
postListSelected)
  case Maybe PostId
msgId of
    Maybe PostId
Nothing  -> () -> MH ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
    Just PostId
pId -> PostId -> Bool -> MH ()
flagMessage PostId
pId Bool
False


-- | Jumps to the specified message in the message's main channel
-- display and changes to MessageSelectState.
postListJumpToCurrent :: MH ()
postListJumpToCurrent :: MH ()
postListJumpToCurrent = do
  Maybe PostId
msgId <- Getting (Maybe PostId) ChatState (Maybe PostId)
-> MH (Maybe PostId)
forall s (m :: * -> *) a. MonadState s m => Getting a s a -> m a
use ((TeamState -> Const (Maybe PostId) TeamState)
-> ChatState -> Const (Maybe PostId) ChatState
Lens' ChatState TeamState
csCurrentTeam((TeamState -> Const (Maybe PostId) TeamState)
 -> ChatState -> Const (Maybe PostId) ChatState)
-> ((Maybe PostId -> Const (Maybe PostId) (Maybe PostId))
    -> TeamState -> Const (Maybe PostId) TeamState)
-> Getting (Maybe PostId) ChatState (Maybe PostId)
forall b c a. (b -> c) -> (a -> b) -> a -> c
.(PostListOverlayState -> Const (Maybe PostId) PostListOverlayState)
-> TeamState -> Const (Maybe PostId) TeamState
Lens' TeamState PostListOverlayState
tsPostListOverlay((PostListOverlayState
  -> Const (Maybe PostId) PostListOverlayState)
 -> TeamState -> Const (Maybe PostId) TeamState)
-> ((Maybe PostId -> Const (Maybe PostId) (Maybe PostId))
    -> PostListOverlayState
    -> Const (Maybe PostId) PostListOverlayState)
-> (Maybe PostId -> Const (Maybe PostId) (Maybe PostId))
-> TeamState
-> Const (Maybe PostId) TeamState
forall b c a. (b -> c) -> (a -> b) -> a -> c
.(Maybe PostId -> Const (Maybe PostId) (Maybe PostId))
-> PostListOverlayState
-> Const (Maybe PostId) PostListOverlayState
Lens' PostListOverlayState (Maybe PostId)
postListSelected)
  case Maybe PostId
msgId of
    Maybe PostId
Nothing  -> () -> MH ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
    Just PostId
pId -> PostId -> MH ()
jumpToPost PostId
pId