-- SPDX-FileCopyrightText: 2021 Oxhead Alpha
-- SPDX-License-Identifier: LicenseRef-MIT-OA

{-# LANGUAGE EmptyDataDeriving #-}

-- | Re-exports typed Value, CValue, some core types, some helpers and
-- defines aliases for constructors of typed values.
--
module Lorentz.Value
  ( M.Value
  , M.IsoValue (..)
  , M.WellTypedToT

    -- * Primitive types
  , Integer
  , Natural
  , MText
  , Bool (..)
  , ByteString
  , Address
  , EpAddress (..)
  , Mutez
  , Never
  , Timestamp
  , ChainId
  , KeyHash
  , PublicKey
  , Signature
  , Bls12381Fr
  , Bls12381G1
  , Bls12381G2
  , Set
  , Map
  , M.BigMapId (..)
  , M.BigMap
  , M.mkBigMap
  , M.Operation
  , Maybe (..)
  , List
  , ReadTicket (..)
  , ContractRef (..)
  , TAddress (..)
  , FutureContract (..)
  , M.Ticket (..)
  , Chest
  , ChestKey
  , OpenChest

  , M.EpName
  , pattern M.DefEpName
  , M.EntrypointCall
  , M.SomeEntrypointCall

    -- * Constructors
  , tz
  , toMutez
  , zeroMutez
  , oneMutez
  , mt
  , timestampFromSeconds
  , timestampFromUTCTime
  , timestampQuote

    -- * Conversions
  , M.coerceContractRef
  , callingAddress
  , callingDefAddress
  , ToAddress (..)
  , ToTAddress (..)
  , ToContractRef (..)
  , FromContractRef (..)
  , convertContractRef

    -- * Misc
  , Show
  , Default (..)
  , Label (..)
  , PrintAsValue (..)

  -- * Re-exports
  , module ReExports
  ) where

import Data.Default (Default(..))
import Prelude hiding (Rational)

import Fmt (Buildable(..))

import Lorentz.Address
import Lorentz.Constraints.Scopes
import Morley.AsRPC (HasRPCRepr(..))
import Morley.Michelson.Text
import Morley.Michelson.Typed qualified as M
import Morley.Michelson.Typed.Haskell.Compatibility as ReExports
import Morley.Tezos.Core
  (ChainId, Mutez, Timestamp, oneMutez, timestampFromSeconds, timestampFromUTCTime, timestampQuote,
  toMutez, tz, zeroMutez)
import Morley.Tezos.Crypto
  (Bls12381Fr, Bls12381G1, Bls12381G2, Chest, ChestKey, KeyHash, PublicKey, Signature)
import Morley.Util.CustomGeneric as ReExports
import Morley.Util.Label (Label(..))

import Lorentz.Annotation

type List = []

data Never
  deriving stock ((forall x. Never -> Rep Never x)
-> (forall x. Rep Never x -> Never) -> Generic Never
forall x. Rep Never x -> Never
forall x. Never -> Rep Never x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. Never -> Rep Never x
from :: forall x. Never -> Rep Never x
$cto :: forall x. Rep Never x -> Never
to :: forall x. Rep Never x -> Never
Generic, Int -> Never -> ShowS
[Never] -> ShowS
Never -> String
(Int -> Never -> ShowS)
-> (Never -> String) -> ([Never] -> ShowS) -> Show Never
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Never -> ShowS
showsPrec :: Int -> Never -> ShowS
$cshow :: Never -> String
show :: Never -> String
$cshowList :: [Never] -> ShowS
showList :: [Never] -> ShowS
Show, Never -> Never -> Bool
(Never -> Never -> Bool) -> (Never -> Never -> Bool) -> Eq Never
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Never -> Never -> Bool
== :: Never -> Never -> Bool
$c/= :: Never -> Never -> Bool
/= :: Never -> Never -> Bool
Eq, Eq Never
Eq Never
-> (Never -> Never -> Ordering)
-> (Never -> Never -> Bool)
-> (Never -> Never -> Bool)
-> (Never -> Never -> Bool)
-> (Never -> Never -> Bool)
-> (Never -> Never -> Never)
-> (Never -> Never -> Never)
-> Ord Never
Never -> Never -> Bool
Never -> Never -> Ordering
Never -> Never -> Never
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Never -> Never -> Ordering
compare :: Never -> Never -> Ordering
$c< :: Never -> Never -> Bool
< :: Never -> Never -> Bool
$c<= :: Never -> Never -> Bool
<= :: Never -> Never -> Bool
$c> :: Never -> Never -> Bool
> :: Never -> Never -> Bool
$c>= :: Never -> Never -> Bool
>= :: Never -> Never -> Bool
$cmax :: Never -> Never -> Never
max :: Never -> Never -> Never
$cmin :: Never -> Never -> Never
min :: Never -> Never -> Never
Ord)
  deriving anyclass (WellTypedToT Never
WellTypedToT Never
-> (Never -> Value (ToT Never))
-> (Value (ToT Never) -> Never)
-> IsoValue Never
Value (ToT Never) -> Never
Never -> Value (ToT Never)
forall a.
WellTypedToT a
-> (a -> Value (ToT a)) -> (Value (ToT a) -> a) -> IsoValue a
$ctoVal :: Never -> Value (ToT Never)
toVal :: Never -> Value (ToT Never)
$cfromVal :: Value (ToT Never) -> Never
fromVal :: Value (ToT Never) -> Never
M.IsoValue, Never -> ()
(Never -> ()) -> NFData Never
forall a. (a -> ()) -> NFData a
$crnf :: Never -> ()
rnf :: Never -> ()
NFData)

instance Buildable Never where
  build :: Never -> Doc
build = Never -> Doc
\case

instance HasAnnotation Never where
  getAnnotation :: FollowEntrypointFlag -> Notes (ToT Never)
getAnnotation FollowEntrypointFlag
_ = Notes (ToT Never)
Notes 'TNever
forall (t :: T). SingI t => Notes t
M.starNotes

instance HasRPCRepr Never where
  type AsRPC Never = Never

instance M.TypeHasDoc Never where
  typeDocMdDescription :: Doc
typeDocMdDescription = Doc
"An uninhabited type."

-- | Value returned by @READ_TICKET@ instruction.
data ReadTicket a = ReadTicket
  { forall a. ReadTicket a -> Address
rtTicketer :: Address
  , forall a. ReadTicket a -> a
rtData :: a
  , forall a. ReadTicket a -> Natural
rtAmount :: Natural
  } deriving stock (Int -> ReadTicket a -> ShowS
[ReadTicket a] -> ShowS
ReadTicket a -> String
(Int -> ReadTicket a -> ShowS)
-> (ReadTicket a -> String)
-> ([ReadTicket a] -> ShowS)
-> Show (ReadTicket a)
forall a. Show a => Int -> ReadTicket a -> ShowS
forall a. Show a => [ReadTicket a] -> ShowS
forall a. Show a => ReadTicket a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: forall a. Show a => Int -> ReadTicket a -> ShowS
showsPrec :: Int -> ReadTicket a -> ShowS
$cshow :: forall a. Show a => ReadTicket a -> String
show :: ReadTicket a -> String
$cshowList :: forall a. Show a => [ReadTicket a] -> ShowS
showList :: [ReadTicket a] -> ShowS
Show, ReadTicket a -> ReadTicket a -> Bool
(ReadTicket a -> ReadTicket a -> Bool)
-> (ReadTicket a -> ReadTicket a -> Bool) -> Eq (ReadTicket a)
forall a. Eq a => ReadTicket a -> ReadTicket a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall a. Eq a => ReadTicket a -> ReadTicket a -> Bool
== :: ReadTicket a -> ReadTicket a -> Bool
$c/= :: forall a. Eq a => ReadTicket a -> ReadTicket a -> Bool
/= :: ReadTicket a -> ReadTicket a -> Bool
Eq, Eq (ReadTicket a)
Eq (ReadTicket a)
-> (ReadTicket a -> ReadTicket a -> Ordering)
-> (ReadTicket a -> ReadTicket a -> Bool)
-> (ReadTicket a -> ReadTicket a -> Bool)
-> (ReadTicket a -> ReadTicket a -> Bool)
-> (ReadTicket a -> ReadTicket a -> Bool)
-> (ReadTicket a -> ReadTicket a -> ReadTicket a)
-> (ReadTicket a -> ReadTicket a -> ReadTicket a)
-> Ord (ReadTicket a)
ReadTicket a -> ReadTicket a -> Bool
ReadTicket a -> ReadTicket a -> Ordering
ReadTicket a -> ReadTicket a -> ReadTicket a
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall {a}. Ord a => Eq (ReadTicket a)
forall a. Ord a => ReadTicket a -> ReadTicket a -> Bool
forall a. Ord a => ReadTicket a -> ReadTicket a -> Ordering
forall a. Ord a => ReadTicket a -> ReadTicket a -> ReadTicket a
$ccompare :: forall a. Ord a => ReadTicket a -> ReadTicket a -> Ordering
compare :: ReadTicket a -> ReadTicket a -> Ordering
$c< :: forall a. Ord a => ReadTicket a -> ReadTicket a -> Bool
< :: ReadTicket a -> ReadTicket a -> Bool
$c<= :: forall a. Ord a => ReadTicket a -> ReadTicket a -> Bool
<= :: ReadTicket a -> ReadTicket a -> Bool
$c> :: forall a. Ord a => ReadTicket a -> ReadTicket a -> Bool
> :: ReadTicket a -> ReadTicket a -> Bool
$c>= :: forall a. Ord a => ReadTicket a -> ReadTicket a -> Bool
>= :: ReadTicket a -> ReadTicket a -> Bool
$cmax :: forall a. Ord a => ReadTicket a -> ReadTicket a -> ReadTicket a
max :: ReadTicket a -> ReadTicket a -> ReadTicket a
$cmin :: forall a. Ord a => ReadTicket a -> ReadTicket a -> ReadTicket a
min :: ReadTicket a -> ReadTicket a -> ReadTicket a
Ord)

customGeneric "ReadTicket" rightComb

deriving anyclass instance M.IsoValue a => M.IsoValue (ReadTicket a)

-- | Provides 'Buildable' instance that prints Lorentz value via Michelson's
-- 'M.Value'.
--
-- Result won't be very pretty, but this avoids requiring 'Show' or
-- 'Buildable' instances.
newtype PrintAsValue a = PrintAsValue a

instance NiceUntypedValue a => Buildable (PrintAsValue a) where
  build :: PrintAsValue a -> Doc
build (PrintAsValue a
a) = Value (ToT a) -> Doc
forall a. Buildable a => a -> Doc
build (a -> Value (ToT a)
forall a. IsoValue a => a -> Value (ToT a)
M.toVal a
a)

data OpenChest = ChestContent ByteString | ChestOpenFailed Bool
  deriving stock ((forall x. OpenChest -> Rep OpenChest x)
-> (forall x. Rep OpenChest x -> OpenChest) -> Generic OpenChest
forall x. Rep OpenChest x -> OpenChest
forall x. OpenChest -> Rep OpenChest x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. OpenChest -> Rep OpenChest x
from :: forall x. OpenChest -> Rep OpenChest x
$cto :: forall x. Rep OpenChest x -> OpenChest
to :: forall x. Rep OpenChest x -> OpenChest
Generic, Int -> OpenChest -> ShowS
[OpenChest] -> ShowS
OpenChest -> String
(Int -> OpenChest -> ShowS)
-> (OpenChest -> String)
-> ([OpenChest] -> ShowS)
-> Show OpenChest
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> OpenChest -> ShowS
showsPrec :: Int -> OpenChest -> ShowS
$cshow :: OpenChest -> String
show :: OpenChest -> String
$cshowList :: [OpenChest] -> ShowS
showList :: [OpenChest] -> ShowS
Show, OpenChest -> OpenChest -> Bool
(OpenChest -> OpenChest -> Bool)
-> (OpenChest -> OpenChest -> Bool) -> Eq OpenChest
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: OpenChest -> OpenChest -> Bool
== :: OpenChest -> OpenChest -> Bool
$c/= :: OpenChest -> OpenChest -> Bool
/= :: OpenChest -> OpenChest -> Bool
Eq)
  deriving anyclass (WellTypedToT OpenChest
WellTypedToT OpenChest
-> (OpenChest -> Value (ToT OpenChest))
-> (Value (ToT OpenChest) -> OpenChest)
-> IsoValue OpenChest
Value (ToT OpenChest) -> OpenChest
OpenChest -> Value (ToT OpenChest)
forall a.
WellTypedToT a
-> (a -> Value (ToT a)) -> (Value (ToT a) -> a) -> IsoValue a
$ctoVal :: OpenChest -> Value (ToT OpenChest)
toVal :: OpenChest -> Value (ToT OpenChest)
$cfromVal :: Value (ToT OpenChest) -> OpenChest
fromVal :: Value (ToT OpenChest) -> OpenChest
M.IsoValue, Maybe AnnOptions
FollowEntrypointFlag -> Notes (ToT OpenChest)
(FollowEntrypointFlag -> Notes (ToT OpenChest))
-> Maybe AnnOptions -> HasAnnotation OpenChest
forall a.
(FollowEntrypointFlag -> Notes (ToT a))
-> Maybe AnnOptions -> HasAnnotation a
$cgetAnnotation :: FollowEntrypointFlag -> Notes (ToT OpenChest)
getAnnotation :: FollowEntrypointFlag -> Notes (ToT OpenChest)
$cannOptions :: Maybe AnnOptions
annOptions :: Maybe AnnOptions
HasAnnotation)

instance M.TypeHasDoc OpenChest where
  typeDocMdDescription :: Doc
typeDocMdDescription = Doc
"Result of opening a chest"