module Language.Eberban.Core
( Dictionary (..)
, Entry (..)
, EntryGenerator
, dictFindEntry
) where

import System.Random (StdGen)
import qualified Data.Text as T
import qualified Data.Map as M

-- * Lexicon
data Dictionary = Dictionary
    { Dictionary -> Text
dictIdentifier :: T.Text
    , Dictionary -> Map Text Entry
dictEntries :: M.Map T.Text Entry
    } deriving (Int -> Dictionary -> ShowS
[Dictionary] -> ShowS
Dictionary -> String
(Int -> Dictionary -> ShowS)
-> (Dictionary -> String)
-> ([Dictionary] -> ShowS)
-> Show Dictionary
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Dictionary -> ShowS
showsPrec :: Int -> Dictionary -> ShowS
$cshow :: Dictionary -> String
show :: Dictionary -> String
$cshowList :: [Dictionary] -> ShowS
showList :: [Dictionary] -> ShowS
Show)

data Entry = Entry
    { Entry -> Text
entryText :: T.Text
    , Entry -> Text
entryFamily :: T.Text
    , Entry -> Maybe Text
entrySignature :: Maybe T.Text
    , Entry -> Text
entryEnglishShort :: T.Text
    , Entry -> Text
entryEnglishLong :: T.Text
    , Entry -> Maybe Text
entryLojbanSimilar :: Maybe T.Text
    } deriving (Int -> Entry -> ShowS
[Entry] -> ShowS
Entry -> String
(Int -> Entry -> ShowS)
-> (Entry -> String) -> ([Entry] -> ShowS) -> Show Entry
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Entry -> ShowS
showsPrec :: Int -> Entry -> ShowS
$cshow :: Entry -> String
show :: Entry -> String
$cshowList :: [Entry] -> ShowS
showList :: [Entry] -> ShowS
Show)

instance Eq Entry where
    Entry
x == :: Entry -> Entry -> Bool
== Entry
y = (Entry -> Text
entryText Entry
x) Text -> Text -> Bool
forall a. Eq a => a -> a -> Bool
== (Entry -> Text
entryText Entry
y)

type EntryGenerator = StdGen -> (Entry, StdGen)

-- * Helper functions

dictFindEntry :: Dictionary -> T.Text -> Maybe Entry
dictFindEntry :: Dictionary -> Text -> Maybe Entry
dictFindEntry Dictionary
dictionary Text
key = (Dictionary -> Map Text Entry
dictEntries Dictionary
dictionary) Map Text Entry -> Text -> Maybe Entry
forall k a. Ord k => Map k a -> k -> Maybe a
M.!? Text
key