module Data.SpirV.Enum.MemorySemantics where

import Data.Bits (Bits)
import Data.String (IsString(..))
import Data.Word (Word32)
import Foreign (Storable(..))
import GHC.Read (Read(..))
import Text.ParserCombinators.ReadPrec (pfail)
import qualified GHC.Read as Read
import qualified Text.Read.Lex as Lex

newtype MemorySemantics = MemorySemantics Word32
  deriving (Eq, Ord, Storable, Bits)

pattern Acquire :: MemorySemantics
pattern Acquire = MemorySemantics 0x2

pattern Release :: MemorySemantics
pattern Release = MemorySemantics 0x4

pattern AcquireRelease :: MemorySemantics
pattern AcquireRelease = MemorySemantics 0x8

pattern SequentiallyConsistent :: MemorySemantics
pattern SequentiallyConsistent = MemorySemantics 0x10

pattern UniformMemory :: MemorySemantics
pattern UniformMemory = MemorySemantics 0x40

pattern SubgroupMemory :: MemorySemantics
pattern SubgroupMemory = MemorySemantics 0x80

pattern WorkgroupMemory :: MemorySemantics
pattern WorkgroupMemory = MemorySemantics 0x100

pattern CrossWorkgroupMemory :: MemorySemantics
pattern CrossWorkgroupMemory = MemorySemantics 0x200

pattern AtomicCounterMemory :: MemorySemantics
pattern AtomicCounterMemory = MemorySemantics 0x400

pattern ImageMemory :: MemorySemantics
pattern ImageMemory = MemorySemantics 0x800

pattern OutputMemory :: MemorySemantics
pattern OutputMemory = MemorySemantics 0x1000

pattern OutputMemoryKHR :: MemorySemantics
pattern OutputMemoryKHR = MemorySemantics 0x1000

pattern MakeAvailable :: MemorySemantics
pattern MakeAvailable = MemorySemantics 0x2000

pattern MakeAvailableKHR :: MemorySemantics
pattern MakeAvailableKHR = MemorySemantics 0x2000

pattern MakeVisible :: MemorySemantics
pattern MakeVisible = MemorySemantics 0x4000

pattern MakeVisibleKHR :: MemorySemantics
pattern MakeVisibleKHR = MemorySemantics 0x4000

pattern Volatile :: MemorySemantics
pattern Volatile = MemorySemantics 0x8000

toName :: IsString a => MemorySemantics -> a
toName x = case x of
  Acquire -> "Acquire"
  Release -> "Release"
  AcquireRelease -> "AcquireRelease"
  SequentiallyConsistent -> "SequentiallyConsistent"
  UniformMemory -> "UniformMemory"
  SubgroupMemory -> "SubgroupMemory"
  WorkgroupMemory -> "WorkgroupMemory"
  CrossWorkgroupMemory -> "CrossWorkgroupMemory"
  AtomicCounterMemory -> "AtomicCounterMemory"
  ImageMemory -> "ImageMemory"
  OutputMemory -> "OutputMemory"
  OutputMemoryKHR -> "OutputMemoryKHR"
  MakeAvailable -> "MakeAvailable"
  MakeAvailableKHR -> "MakeAvailableKHR"
  MakeVisible -> "MakeVisible"
  MakeVisibleKHR -> "MakeVisibleKHR"
  Volatile -> "Volatile"
  unknown -> fromString $ "MemorySemantics " ++ show unknown

instance Show MemorySemantics where
  show = toName

fromName :: (IsString a, Eq a) => a -> Maybe MemorySemantics
fromName x = case x of
  "Acquire" -> Just Acquire
  "Release" -> Just Release
  "AcquireRelease" -> Just AcquireRelease
  "SequentiallyConsistent" -> Just SequentiallyConsistent
  "UniformMemory" -> Just UniformMemory
  "SubgroupMemory" -> Just SubgroupMemory
  "WorkgroupMemory" -> Just WorkgroupMemory
  "CrossWorkgroupMemory" -> Just CrossWorkgroupMemory
  "AtomicCounterMemory" -> Just AtomicCounterMemory
  "ImageMemory" -> Just ImageMemory
  "OutputMemory" -> Just OutputMemory
  "OutputMemoryKHR" -> Just OutputMemoryKHR
  "MakeAvailable" -> Just MakeAvailable
  "MakeAvailableKHR" -> Just MakeAvailableKHR
  "MakeVisible" -> Just MakeVisible
  "MakeVisibleKHR" -> Just MakeVisibleKHR
  "Volatile" -> Just Volatile
  _unknown -> Nothing

instance Read MemorySemantics where
  readPrec = Read.parens do
    Lex.Ident s <- Read.lexP
    maybe pfail pure $ fromName s