module Auth where

import Data.Map (Map)
import qualified Data.Map as Map

import Data.Maybe (Maybe)
import qualified Data.Maybe as Maybe

data Database = Database (Map String String)

-- Would use private constructor here
data Name = Name String deriving (Show, Eq, Ord)
data Password = Password String deriving (Show, Eq, Ord)

data User = User Name Password deriving (Show, Eq, Ord)

data Request =
	AuthRequest Name Password
	| OtherRequest
	| UnknownRequest
	deriving (Show)

data Response =
	AuthSuccess
	| AuthFailure
	| OtherResponse
	| ErrorResponse
	deriving (Show)

--Maybe here because we would want validation logic
--but obvious none being called here.
nameFromString :: String -> Maybe Name
--nameFromString _ = None
--nameFromString _ = Just $ Name "bob"
nameFromString name = Just $ Name name

--Ditto
passFromString :: String -> Maybe Password
--passFromString _ = None
--passFromString _ = Just $ Password "bob"
passFromString pass = Just $ Password pass

getPasswordForUsername :: Database -> Name -> Maybe Password
--getPasswordForUsername _ _ = passFromString "foo"
--getPasswordForUsername _ (Name n) = passFromString n
getPasswordForUsername (Database db) (Name n) = do
	passString <- Map.lookup n db
	pass <- passFromString passString
	return pass

myDb = Database $ Map.fromList [("Ben", "xyzzy"), ("Creighton", "password")]

handleAuth :: Request -> Response
--handleAuth (AuthRequest name pass) = ErrorResponse
handleAuth (AuthRequest name pass) = Maybe.fromMaybe AuthFailure $ do
	actualPass <- getPasswordForUsername myDb name
	return $ if ((compare pass actualPass) == EQ) then AuthSuccess else AuthFailure
handleAuth _ = ErrorResponse