{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE RecordWildCards #-}
{-# LANGUAGE NoImplicitPrelude #-}

module Neuron.Zettelkasten.Type where

import Neuron.Zettelkasten.ID
import qualified Neuron.Zettelkasten.Meta as Z
import Relude hiding (show)
import Text.MMark (MMark)
import Text.Show (Show (show))

data Zettel
  = Zettel
      { Zettel -> ZettelID
zettelID :: ZettelID,
        Zettel -> Text
zettelTitle :: Text,
        Zettel -> MMark
zettelContent :: MMark
      }

instance Eq Zettel where
  == :: Zettel -> Zettel -> Bool
(==) = ZettelID -> ZettelID -> Bool
forall a. Eq a => a -> a -> Bool
(==) (ZettelID -> ZettelID -> Bool)
-> (Zettel -> ZettelID) -> Zettel -> Zettel -> Bool
forall b c a. (b -> b -> c) -> (a -> b) -> a -> a -> c
`on` Zettel -> ZettelID
zettelID

instance Ord Zettel where
  compare :: Zettel -> Zettel -> Ordering
compare = ZettelID -> ZettelID -> Ordering
forall a. Ord a => a -> a -> Ordering
compare (ZettelID -> ZettelID -> Ordering)
-> (Zettel -> ZettelID) -> Zettel -> Zettel -> Ordering
forall b c a. (b -> b -> c) -> (a -> b) -> a -> a -> c
`on` Zettel -> ZettelID
zettelID

instance Show Zettel where
  show :: Zettel -> String
show Zettel {..} = "Zettel:" String -> ShowS
forall a. Semigroup a => a -> a -> a
<> ZettelID -> String
forall a. Show a => a -> String
show ZettelID
zettelID

hasTag :: Text -> Zettel -> Bool
hasTag :: Text -> Zettel -> Bool
hasTag t :: Text
t =
  Maybe Text -> Bool
forall a. Maybe a -> Bool
isJust (Maybe Text -> Bool) -> (Zettel -> Maybe Text) -> Zettel -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ((Text -> Bool) -> [Text] -> Maybe Text
forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Maybe a
find (Text -> Text -> Bool
forall a. Eq a => a -> a -> Bool
== Text
t) ([Text] -> Maybe Text)
-> (MMark -> Maybe [Text]) -> MMark -> Maybe Text
forall (m :: * -> *) b c a.
Monad m =>
(b -> m c) -> (a -> m b) -> a -> m c
<=< Meta -> Maybe [Text]
Z.tags (Meta -> Maybe [Text])
-> (MMark -> Maybe Meta) -> MMark -> Maybe [Text]
forall (m :: * -> *) b c a.
Monad m =>
(b -> m c) -> (a -> m b) -> a -> m c
<=< MMark -> Maybe Meta
Z.getMeta) (MMark -> Maybe Text) -> (Zettel -> MMark) -> Zettel -> Maybe Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Zettel -> MMark
zettelContent