module MyCrowdFunding where

import qualified Language.PlutusTx            as PlutusTx
import qualified Ledger.Interval              as Interval
import           Ledger.Slot                  (SlotRange)
import qualified Ledger.Slot                  as Slot
import qualified Language.PlutusTx.Prelude    as P
import           Ledger
import qualified Ledger.Ada.TH                as Ada
import           Ledger.Ada                   (Ada)
import           Ledger.Validation
import           Playground.Contract
import           Wallet                       as Wallet


data Campaign = Campaign
  { campaignDeadline           :: Slot
  , campaignTarget             :: Ada
  , campaignCollectionDeadline :: Slot
  , campaignOwner              :: PubKey
} deriving (Generic, ToJSON, FromJSON, ToSchema)

PlutusTx.makeLift ''Campaign

data CampaignAction = Collect | Refund
  deriving (Generic, ToJSON, FromJSON, ToSchema)

PlutusTx.makeLift ''CampaignAction





myValidatorScript :: Campaign -> ValidatorScript
myValidatorScript campaign = ValidatorScript $ Ledger.applyScript validator (Ledger.lifted campaign)
    where
        validator = $$(Ledger.compileScript [||
            \Campaign{..} (contributor :: PubKey) (action :: CampaignAction) (ptx :: PendingTx) ->
                case action of
                    Collect -> ()
                    Refund -> ()
            ||])


contractAddress :: Campaign -> Address
contractAddress campaign = Ledger.scriptAddress $ myValidatorScript campaign


contribute :: MonadWallet m => Campaign -> Ada -> m ()
contribute campaign value = do
    _ <- if value <= 0
    then throwOtherError "Must contribute a positive value"
    else pure ()

    ownPK <- ownPubKey

    let dataScript = DataScript $ Ledger.lifted ownPK
        range      = Wallet.defaultSlotRange
        amount     = $$(Ada.toValue) value
        address    = contractAddress campaign

    tx <- payToScript range address amount dataScript
    logMsg "Submitted contribution"

    register (refundTrigger address) $ refundHandler campaign (Ledger.hashTx tx)
    logMsg "Registered refund trigger"


collectFundsTrigger :: Campaign->EventTrigger
collectFundsTrigger campaign = hasFunds `andT` collectionTime
  where
        hasFunds = fundsAtAddressT (contractAddress campaign) $ Wallet.intervalFrom ($$(Ada.toValue) 1)
        collectionTime = slotRangeT $ Wallet.interval 10 15


collectFundsHandler :: MonadWallet m => Campaign->EventHandler m
collectFundsHandler campaign = EventHandler $ \_ -> do
    logMsg "Collecting funds"


    let redeemerScript = RedeemerScript $ Ledger.lifted Collect
        range = Wallet.interval 10 15
        validatorScript = myValidatorScript campaign

    collectFromScript range validatorScript redeemerScript


scheduleCollection :: MonadWallet m => Campaign->m ()
scheduleCollection campaign = do
      register (collectFundsTrigger campaign) (collectFundsHandler campaign)


refundTrigger :: Address -> EventTrigger
refundTrigger address = hasFunds `andT` isRefundTime
  where
    hasFunds = fundsAtAddressT address $ Wallet.intervalFrom ($$(Ada.toValue) 1)
    isRefundTime = slotRangeT $ Wallet.intervalFrom 15


refundHandler :: MonadWallet m => Campaign -> TxId -> EventHandler m
refundHandler campaign txid = EventHandler $ \_ -> do
    logMsg "Claiming refund"

    let redeemerScript  = RedeemerScript $ Ledger.lifted Refund
        range           = Wallet.intervalFrom 15
        validatorScript = myValidatorScript campaign

    collectFromScriptTxn range validatorScript redeemerScript txid


$(mkFunctions ['contribute, 'scheduleCollection])