module Auszug(
   Date(..),  -- represents date
   toString,  -- :: Date -> String
              -- displays a date
   eher,      -- :: Date -> Date -> Bool
              -- returns True if the first date is before the
              -- other.
   Entry(..), -- represents entries in a bank account
   zwischen,  -- :: Date -> Date -> [Entry] -> [Entry]
              -- finds all entries after the first date
              -- and before the second, or on the first
              -- date.
   namen,     -- :: String -> [Entry] -> [Entry]
              -- finds all entries involving a given name.
   summe,     -- :: [Entry] -> Int
              -- totals all entries.
   ) where



-------------------------------------------------------------------
-- Dates
-------------------------------------------------------------------


-- Months.  
data Month = Januar | Februar | Maerz | April | Mai | Juni | Juli |
   August | September | Oktober | November | Dezember

-- Finds the number of a month - useful for "eher".
monthNumber :: Month -> Int
monthNumber Januar    = 1 
monthNumber Februar   = 2 
monthNumber Maerz     = 3 
monthNumber April     = 4 
monthNumber Mai       = 5
monthNumber Juni      = 6 
monthNumber Juli      = 7
monthNumber August    = 8 
monthNumber September = 9 
monthNumber Oktober   = 10 
monthNumber November  = 11 
monthNumber Dezember  = 12

eherMonth :: Month -> Month -> Bool
eherMonth month1 month2 = (monthNumber month1) < (monthNumber month2)

eqMonth :: Month -> Month -> Bool
eqMonth month1 month2 = (monthNumber month1) == (monthNumber month2)

-- Finds the name of a month - useful for "toString"

monthToString :: Month -> String
monthToString Januar    = "Januar"    
monthToString Februar   = "Februar"   
monthToString Maerz     = "Maerz"  
monthToString April     = "April"     
monthToString Mai       = "Mai"       
monthToString Juni      = "Juni"      
monthToString Juli      = "Juli"     
monthToString August    = "August"    
monthToString September = "September" 
monthToString Oktober   = "Oktober"   
monthToString November  = "November"  
monthToString Dezember  = "Dezember"

-- That could all have been done much quicker as follows, using "deriving":
-- data Month = Januar | Februar | Maerz | April | Mai | Juni | Juli |
--   August | September | Oktober | November | Dezember deriving (Show,Ord,Eq)
-- eherMonth month1 month2 = (month1 < month2)
-- eqMonth month2 month2 = (month1 == month2)
-- monthToString month = show month

-- General Dates

data Date = Date {
   dayNo :: Int,
   month :: Month,
   year :: Int
   }

toString :: Date -> String
toString (Date {dayNo = dayNo,month = month,year = year}) =
   (show dayNo) ++ ". " ++ (monthToString month) ++ " " ++ (show year)

eher :: Date -> Date -> Bool
eher (Date {dayNo = dayNo1,month = month1,year = year1})
     (Date {dayNo = dayNo2,month = month2,year = year2}) =
    ((year1<year2) || 
       ((year1 == year2) &&
           ((eherMonth month1 month2) ||
              ((eqMonth month1 month2) && (dayNo1 < dayNo2))
              )
           )
       )
 
-------------------------------------------------------------------
-- Ausz"uge
-------------------------------------------------------------------

type Betrag = Int
  -- We make Betrag negative for withdrawals ("Entnahmen") and
  -- Ueberweisungen from the account.  This makes the "summe"
  -- function rather easier to write . . .

type Name = String

data Entry = Entry Date Betrag EntryDetails 

data EntryDetails =
   Entnahme | Einzahlung | Ueberweisungvon Name | Ueberweisungzu Name

zwischen :: Date -> Date -> [Entry] -> [Entry]
zwischen from to [] = []
zwischen from to (first:rest) =
   let
      restzwischen = zwischen from to rest
      Entry firstDate _ _ = first
   in
      if (not (eher firstDate from)) && (eher firstDate to)
         then
            first : restzwischen
         else
            restzwischen

namen :: String -> [Entry] -> [Entry]
namen name [] = []
namen name (entry : rest) =
   let
      restnamen = namen name rest
   in
      case entry of
         Entry _ _ (Ueberweisungvon name') ->
            if name' == name then entry : restnamen else restnamen
         Entry _ _ (Ueberweisungzu name') ->
            if name' == name then entry : restnamen else restnamen
         _ -> restnamen

summe :: [Entry] -> Int
summe [] = 0
summe (Entry _ betrag _ : rest) = betrag + summe rest