{-# LANGUAGE DeriveGeneric #-}
{-|
Module      : Instana.SDK.Internal.Context
Description : The Instana context holds everything that the SDK needs in terms of state.
-}
module Instana.SDK.Internal.Context
  ( AgentConnection(..)
  , InternalContext(..)
  , ConnectionState(..)
  , isAgentConnectionEstablished
  , mkAgentReadyState
  , readAgentUuid
  , readExtraHeaders
  , readSecretsMatcher
  , readPid
  , whenConnected
  ) where


import           Control.Concurrent                                         (ThreadId)
import           Control.Concurrent.STM                                     (STM)
import qualified Control.Concurrent.STM                                     as STM
import qualified Data.ByteString.Char8                                      as BSC8
import           Data.CaseInsensitive                                       (CI)
import qualified Data.CaseInsensitive                                       as CI
import           Data.Map.Strict                                            (Map)
import           Data.Maybe                                                 as Maybe
import           Data.Sequence                                              (Seq)
import           Data.Text                                                  (Text)
import qualified Foreign.C.Types                                            as CTypes
import           GHC.Generics
import           Network.HTTP.Client                                        as HttpClient
import qualified System.Metrics                                             as Metrics

import           Instana.SDK.Internal.AgentConnection.Json.AnnounceResponse (AnnounceResponse)
import qualified Instana.SDK.Internal.AgentConnection.Json.AnnounceResponse as AnnounceResponse
import           Instana.SDK.Internal.Command                               (Command)
import           Instana.SDK.Internal.Config                                (FinalConfig)
import           Instana.SDK.Internal.Metrics.Sample                        (TimedSample)
import           Instana.SDK.Internal.Secrets                               (SecretsMatcher)
import qualified Instana.SDK.Internal.Secrets                               as SecretsMatcher
import           Instana.SDK.Internal.SpanStack                             (SpanStack)
import           Instana.SDK.Internal.WireSpan                              (QueuedSpan)


-- |The current state of the connection to the agent.
data ConnectionState =
    -- |Connection handshake has not been started yet.
    Unconnected
    -- |Phase agent host lookup has been initiated.
  | AgentHostLookup
    -- |Agent host lookup is complete, the process has not been announced yet.
  | Unannounced (String, Int)
    -- |Announce was successful, waiting for the agent to signal readyness.
  | Announced (String, Int)
    -- |Agent has signaled that it is ready to accept data.
  | AgentReady Ready
  deriving (Eq, Show, Generic)


-- |Data to hold after agent ready event.
data Ready =
  Ready
    { connection :: AgentConnection
    , metrics    :: Metrics.Store
    } deriving (Generic)


instance Eq Ready where
  r1 == r2 =
    connection r1 == connection r2


instance Show Ready where
  show r =
     show $ connection r


-- |Meta data about the connection to the agent.
data AgentConnection =
  AgentConnection
    {
      -- |the host of the agent we are connected to
      agentHost      :: String
      -- |the port of the agent we are connected to
    , agentPort      :: Int
      -- |the PID of the monitored process
    , pid            :: String
      -- |the agent's UUID
    , agentUuid      :: Text
      -- |the configured secrets matcher
    , secretsMatcher :: SecretsMatcher
      -- |the configured list of HTTP headers to capture (or an empty list)
    , extraHeaders   :: [CI BSC8.ByteString]
    }
  deriving (Eq, Show, Generic)


-- |Creates a "ready" connection state from an AnnounceResponse.
mkAgentReadyState ::
  (String, Int)
  -> AnnounceResponse
  -> Metrics.Store
  -> ConnectionState
mkAgentReadyState (host_, port_) announceResponse metricsStore =
  let
    maybeTracingConfig = AnnounceResponse.tracing announceResponse
    maybeExtraHeaders = AnnounceResponse.extraHttpHeaders <$> maybeTracingConfig
    maybeLegacyExtraHeaders = AnnounceResponse.extraHeaders announceResponse
    extraHeadersList =
      (Maybe.fromMaybe [] $
        Maybe.fromMaybe
          -- Fall back to legacy extraHeaders if tracing.extra-http-headers is
          -- not present.
          maybeLegacyExtraHeaders
          -- Prefer the tracing.extra-http-headers over the legacy
          -- extraHeaders attribute.
          maybeExtraHeaders)
    agentConnection = AgentConnection
      { agentHost      = host_
      , agentPort      = port_
      , pid            = show $ AnnounceResponse.pid announceResponse
      , agentUuid      = AnnounceResponse.agentUuid announceResponse
      , secretsMatcher = AnnounceResponse.secrets announceResponse
      , extraHeaders   = fmap (CI.mk . BSC8.pack) extraHeadersList
      }
  in
  AgentReady $
    Ready
      { connection = agentConnection
      , metrics    = metricsStore
      }


{-| A container for all the things the Instana SDK needs to do its work.
-}
data InternalContext = InternalContext
  { config                :: FinalConfig
  , sdkStartTime          :: Int
  , httpManager           :: HttpClient.Manager
  , commandQueue          :: STM.TQueue Command
  , spanQueue             :: STM.TVar (Seq QueuedSpan)
  , connectionState       :: STM.TVar ConnectionState
  , fileDescriptor        :: STM.TVar (Maybe CTypes.CInt)
  , currentSpans          :: STM.TVar (Map ThreadId SpanStack)
  , previousMetricsSample :: STM.TVar TimedSample
  }


instance Show InternalContext where
  -- hide everything except for config when serializing context to string
  show context = show (config context)


isAgentConnectionEstablishedSTM :: InternalContext -> STM Bool
isAgentConnectionEstablishedSTM context = do
  state <- STM.readTVar $ connectionState context
  return $
    case state of
      AgentReady _ -> True
      _            -> False


-- |Checks if the connection to the agent has been established.
isAgentConnectionEstablished :: InternalContext -> IO Bool
isAgentConnectionEstablished context =
  STM.atomically $ isAgentConnectionEstablishedSTM context


readAgentUuidSTM :: InternalContext -> STM (Maybe Text)
readAgentUuidSTM context = do
  state <- STM.readTVar $ connectionState context
  return $ mapConnectionState agentUuid state


-- |accessor for the agent UUID
readAgentUuid :: InternalContext -> IO (Maybe Text)
readAgentUuid context =
  STM.atomically $ readAgentUuidSTM context


readPidSTM :: InternalContext -> STM (Maybe String)
readPidSTM context = do
  state <- STM.readTVar $ connectionState context
  return $ mapConnectionState pid state


-- |accessor for the PID of the monitored process
readPid :: InternalContext -> IO (Maybe String)
readPid context =
  STM.atomically $ readPidSTM context


readSecretsMatcherSTM :: InternalContext -> STM SecretsMatcher
readSecretsMatcherSTM context = do
  state <- STM.readTVar $ connectionState context
  let
    secretsMacherMaybe = mapConnectionState secretsMatcher state
  return $
    Maybe.fromMaybe SecretsMatcher.defaultSecretsMatcher secretsMacherMaybe


-- |accessor for the secrets matching config
readSecretsMatcher :: InternalContext -> IO SecretsMatcher
readSecretsMatcher context =
  STM.atomically $ readSecretsMatcherSTM context


readExtraHeadersSTM :: InternalContext -> STM [CI BSC8.ByteString]
readExtraHeadersSTM context = do
  state <- STM.readTVar $ connectionState context
  let
    extraHeadersMaybe = mapConnectionState extraHeaders state
  return $
    Maybe.fromMaybe [] extraHeadersMaybe


-- |accessor for the extra http headers config
readExtraHeaders :: InternalContext -> IO [CI BSC8.ByteString]
readExtraHeaders context =
  STM.atomically $ readExtraHeadersSTM context


mapConnectionState :: (AgentConnection -> a) -> ConnectionState -> Maybe a
mapConnectionState fn state =
  case state of
    AgentReady (Ready agentConnection _) ->
      Just $ fn agentConnection
    _ ->
      Nothing


-- |Executes an IO action only when the connection to the agent has been
-- established. The action receives the agent host/port, PID, the agent UUID and
-- the internal metrics store as parameters (basically everything that is only
-- available with an established agent connection).
whenConnected ::
  InternalContext
  -> (AgentConnection -> Metrics.Store -> IO ())
  -> IO ()
whenConnected context action = do
  state <- STM.atomically $ STM.readTVar $ connectionState context
  whenConnectedState
    state
    (\(Ready agentConnection metricsStore) ->
      action agentConnection metricsStore
    )


whenConnectedState :: ConnectionState -> (Ready -> IO ()) -> IO ()
whenConnectedState state action = do
  case state of
    Unconnected ->
      return ()
    AgentHostLookup ->
      return ()
    Unannounced _ ->
      return ()
    Announced _ ->
      return ()
    AgentReady ready -> do
      action ready