{-# LANGUAGE ScopedTypeVariables #-}

module HaskellWorks.CabalCache.AWS.Error
  ( handleAwsError
  ) where

import Control.Monad.Catch              (MonadCatch(..), MonadThrow(throwM))
import Control.Monad.Except             (MonadError)
import HaskellWorks.CabalCache.AppError (AwsError(..))
import HaskellWorks.Prelude

import qualified Amazonka                             as AWS
import qualified Control.Monad.Oops                   as OO
import qualified Network.HTTP.Types                   as HTTP

{- HLINT ignore "Redundant do"        -}
{- HLINT ignore "Reduce duplication"  -}
{- HLINT ignore "Redundant bracket"   -}

handleAwsError :: (MonadCatch m,
 MonadError (OO.Variant e) m,
 OO.CouldBeF e AwsError) =>
 m a -> m a
handleAwsError :: forall (m :: * -> *) (e :: [*]) a.
(MonadCatch m, MonadError (Variant e) m, CouldBeF e AwsError) =>
m a -> m a
handleAwsError m a
f = m a -> (Error -> m a) -> m a
forall e a. (HasCallStack, Exception e) => m a -> (e -> m a) -> m a
forall (m :: * -> *) e a.
(MonadCatch m, HasCallStack, Exception e) =>
m a -> (e -> m a) -> m a
catch m a
f ((Error -> m a) -> m a) -> (Error -> m a) -> m a
forall a b. (a -> b) -> a -> b
$ \(Error
e :: AWS.Error) ->
  case Error
e of
    (AWS.ServiceError (AWS.ServiceError' Abbrev
_ s :: Status
s@(HTTP.Status Int
_ ByteString
_) [Header]
_ ErrorCode
_ Maybe ErrorMessage
_ Maybe RequestId
_)) -> AwsError -> m a
forall x (e :: [*]) (m :: * -> *) a.
(MonadError (Variant e) m, CouldBe e x) =>
x -> m a
OO.throw (AwsError -> m a) -> AwsError -> m a
forall a b. (a -> b) -> a -> b
$ Status -> AwsError
AwsError Status
s
    Error
_                                                                    -> Error -> m a
forall e a. (HasCallStack, Exception e) => e -> m a
forall (m :: * -> *) e a.
(MonadThrow m, HasCallStack, Exception e) =>
e -> m a
throwM Error
e