module Persistence.PaymentCategory
  ( list
  , listByCategory
  , save
  ) where

import qualified Data.Maybe             as Maybe
import           Data.Text              (Text)
import           Data.Time.Clock        (getCurrentTime)
import           Database.SQLite.Simple (FromRow (fromRow), Only (Only))
import qualified Database.SQLite.Simple as SQLite

import           Common.Model           (CategoryId, PaymentCategory (..))
import qualified Common.Util.Text       as T

import           Model.Query            (Query (Query))

newtype Row = Row PaymentCategory

instance FromRow Row where
  fromRow = Row <$> (PaymentCategory <$>
    SQLite.field <*>
    SQLite.field <*>
    SQLite.field <*>
    SQLite.field <*>
    SQLite.field)

list :: Query [PaymentCategory]
list =
  Query (\conn -> do
    map (\(Row pc) -> pc) <$>
      SQLite.query_ conn "SELECT * from payment_category"
  )

listByCategory :: CategoryId -> Query [PaymentCategory]
listByCategory cat =
  Query (\conn -> do
    map (\(Row pc) -> pc) <$>
      SQLite.query conn "SELECT * FROM payment_category WHERE category = ?" (Only cat)
  )

save :: Text -> CategoryId -> Query PaymentCategory
save newName categoryId =
  Query (\conn -> do
    now <- getCurrentTime
    paymentCategory <- fmap (\(Row pc) -> pc) . Maybe.listToMaybe <$>
      (SQLite.query
        conn
        "SELECT * FROM payment_category WHERE name = ?"
        (Only formattedNewName))
    case paymentCategory of
      Just pc ->
        do
          SQLite.execute
            conn
            "UPDATE payment_category SET category = ?, edited_at = ? WHERE name = ?"
            (categoryId, now, formattedNewName)
          return $ PaymentCategory
            (_paymentCategory_id pc)
            formattedNewName
            categoryId
            (_paymentCategory_createdAt pc)
            (Just now)
      Nothing ->
        do
          SQLite.execute
            conn
            "INSERT INTO payment_category (name, category, created_at) VALUES (?, ?, ?)"
            (formattedNewName, categoryId, now)
          paymentCategoryId <- SQLite.lastInsertRowId conn
          return $ PaymentCategory
            paymentCategoryId
            formattedNewName
            categoryId
            now
            Nothing
  )
  where
    formattedNewName = T.formatSearch newName