module Main where

import Prelude

import Control.Alt ((<|>))
import Control.Monad.Eff.Console (logShow)
import Data.Generic.Rep (class Generic, Constructor(..), Field(..), Product(..), Rec(..), from)
import Data.Maybe (Maybe(..), isJust)
import Data.Symbol (class IsSymbol, SProxy(..), reflectSymbol)

getFieldMaybe :: forall a rep r. Generic a rep => GetFieldMaybe rep => String -> a -> (forall a. Maybe a -> r) -> Maybe r
getFieldMaybe fName a f = getFieldMaybe' (from a) fName f

class GetFieldMaybe rep where
    getFieldMaybe' :: forall r. rep -> String -> (forall a. Maybe a -> r) -> Maybe r

instance gfmCtor :: GetFieldMaybe rep => GetFieldMaybe (Constructor name rep) where
    getFieldMaybe' (Constructor rep) = getFieldMaybe' rep

instance gfmRecord :: GetFieldMaybe fields => GetFieldMaybe (Rec fields) where
    getFieldMaybe' (Rec fields) = getFieldMaybe' fields

instance gfmField :: IsSymbol name => GetFieldMaybe (Field name (Maybe fieldType)) where
    getFieldMaybe' (Field val) fName f =
        if fName == reflectSymbol (SProxy :: SProxy name)
            then Just $ f val
            else Nothing

instance gfmProduct :: (GetFieldMaybe fieldsLeft, GetFieldMaybe fieldsRight) => GetFieldMaybe (Product fieldsLeft fieldsRight) where
    getFieldMaybe' (Product left right) fName f = getFieldMaybe' left fName f <|> getFieldMaybe' right fName f


data TheRecord = TheRecord { a :: Maybe Int, b :: Maybe String }
derive instance gRecord :: Generic TheRecord _

main = do
    let rec = TheRecord { a: Just 42, b: Nothing }
    logShow $ getFieldMaybe "a" rec isJust      -- Just true
    logShow $ getFieldMaybe "b" rec isJust      -- Just false
    logShow $ getFieldMaybe "foo" rec isJust    -- Nothing