module Hix.Managed.StageResult where

import qualified Data.Map.Strict as Map
import Distribution.Pretty (Pretty)

import Hix.Class.Map (nRestrictKeys)
import Hix.Managed.Data.Mutable (MutableDep)
import qualified Hix.Managed.Data.Mutation
import Hix.Managed.Data.Mutation (failedMutation)
import qualified Hix.Managed.Data.MutationState
import Hix.Managed.Data.MutationState (MutationState (MutationState))
import qualified Hix.Managed.Data.StageResult
import Hix.Managed.Data.StageResult (
  StageFailure (FailedMutations),
  StageResult (StageResult),
  StageSummary (StageFailure, StageNoAction, StageSuccess),
  )
import qualified Hix.Managed.Data.StageState
import Hix.Managed.Data.StageState (BuildSuccess, StageState (StageState))

stageResultWith ::
  Pretty a =>
  (Map MutableDep BuildSuccess -> MutationState -> MutationState) ->
  (Map MutableDep BuildSuccess -> Natural -> Text) ->
  (Natural -> Text) ->
  StageState a s ->
  StageResult
stageResultWith :: forall a s.
Pretty a =>
(Map MutableDep BuildSuccess -> MutationState -> MutationState)
-> (Map MutableDep BuildSuccess -> Natural -> Text)
-> (Natural -> Text)
-> StageState a s
-> StageResult
stageResultWith Map MutableDep BuildSuccess -> MutationState -> MutationState
finalize Map MutableDep BuildSuccess -> Natural -> Text
successMessage Natural -> Text
failureMessage StageState {Map MutableDep BuildSuccess
success :: Map MutableDep BuildSuccess
success :: forall a s. StageState a s -> Map MutableDep BuildSuccess
success, [DepMutation a]
failed :: [DepMutation a]
failed :: forall a s. StageState a s -> [DepMutation a]
failed, MutationState
state :: MutationState
state :: forall a s. StageState a s -> MutationState
state, Natural
iterations :: Natural
iterations :: forall a s. StageState a s -> Natural
iterations} =
  StageResult {state :: Maybe MutationState
state = MutationState -> Maybe MutationState
forall a. a -> Maybe a
Just (Map MutableDep BuildSuccess -> MutationState -> MutationState
finalize Map MutableDep BuildSuccess
success MutationState
state), StageSummary
summary :: StageSummary
summary :: StageSummary
summary}
  where
    summary :: StageSummary
summary =
      case [DepMutation a] -> Maybe (NonEmpty (DepMutation a))
forall a. [a] -> Maybe (NonEmpty a)
nonEmpty ((DepMutation a -> MutableDep) -> [DepMutation a] -> [DepMutation a]
forall b a. Ord b => (a -> b) -> [a] -> [a]
sortOn (.package) [DepMutation a]
failed) of
        Just NonEmpty (DepMutation a)
failedNe -> StageFailure -> StageSummary
StageFailure (Text -> NonEmpty FailedMutation -> StageFailure
FailedMutations (Natural -> Text
failureMessage Natural
iterations) (DepMutation a -> FailedMutation
forall a. Pretty a => DepMutation a -> FailedMutation
failedMutation (DepMutation a -> FailedMutation)
-> NonEmpty (DepMutation a) -> NonEmpty FailedMutation
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> NonEmpty (DepMutation a)
failedNe))
        Maybe (NonEmpty (DepMutation a))
Nothing | [] <- Map MutableDep BuildSuccess
success -> Maybe Text -> StageSummary
StageNoAction (Text -> Maybe Text
forall a. a -> Maybe a
Just Text
"All dependencies are up to date.")
                | Bool
otherwise -> Text -> StageSummary
StageSuccess (Map MutableDep BuildSuccess -> Natural -> Text
successMessage Map MutableDep BuildSuccess
success Natural
iterations)

stageResult ::
  Pretty a =>
  (Map MutableDep BuildSuccess -> Natural -> Text) ->
  (Natural -> Text) ->
  StageState a s ->
  StageResult
stageResult :: forall a s.
Pretty a =>
(Map MutableDep BuildSuccess -> Natural -> Text)
-> (Natural -> Text) -> StageState a s -> StageResult
stageResult =
  (Map MutableDep BuildSuccess -> MutationState -> MutationState)
-> (Map MutableDep BuildSuccess -> Natural -> Text)
-> (Natural -> Text)
-> StageState a s
-> StageResult
forall a s.
Pretty a =>
(Map MutableDep BuildSuccess -> MutationState -> MutationState)
-> (Map MutableDep BuildSuccess -> Natural -> Text)
-> (Natural -> Text)
-> StageState a s
-> StageResult
stageResultWith ((MutationState -> MutationState)
-> Map MutableDep BuildSuccess -> MutationState -> MutationState
forall a b. a -> b -> a
const MutationState -> MutationState
forall a. a -> a
id)

stageResultInit ::
  Pretty a =>
  (Map MutableDep BuildSuccess -> Natural -> Text) ->
  (Natural -> Text) ->
  StageState a s ->
  StageResult
stageResultInit :: forall a s.
Pretty a =>
(Map MutableDep BuildSuccess -> Natural -> Text)
-> (Natural -> Text) -> StageState a s -> StageResult
stageResultInit =
  (Map MutableDep BuildSuccess -> MutationState -> MutationState)
-> (Map MutableDep BuildSuccess -> Natural -> Text)
-> (Natural -> Text)
-> StageState a s
-> StageResult
forall a s.
Pretty a =>
(Map MutableDep BuildSuccess -> MutationState -> MutationState)
-> (Map MutableDep BuildSuccess -> Natural -> Text)
-> (Natural -> Text)
-> StageState a s
-> StageResult
stageResultWith \ Map MutableDep BuildSuccess
success MutationState {Overrides
MutableBounds
MutableVersions
bounds :: MutableBounds
versions :: MutableVersions
overrides :: Overrides
initial :: MutableVersions
initial :: MutationState -> MutableVersions
overrides :: MutationState -> Overrides
versions :: MutationState -> MutableVersions
bounds :: MutationState -> MutableBounds
..} ->
    MutationState {initial :: MutableVersions
initial = Set MutableDep -> MutableVersions -> MutableVersions
forall map k v sort. NMap map k v sort => Set k -> map -> map
nRestrictKeys (Map MutableDep BuildSuccess -> Set MutableDep
forall k a. Map k a -> Set k
Map.keysSet Map MutableDep BuildSuccess
success) MutableVersions
versions, Overrides
MutableBounds
MutableVersions
bounds :: MutableBounds
versions :: MutableVersions
overrides :: Overrides
overrides :: Overrides
versions :: MutableVersions
bounds :: MutableBounds
..}