module Hix.Managed.StageState where

import qualified Data.Map.Strict as Map
import qualified Data.Set as Set

import qualified Hix.Managed.Data.MutableId
import qualified Hix.Managed.Data.Mutation
import Hix.Managed.Data.Mutation (DepMutation, MutationResult (..))
import Hix.Managed.Data.StageState (BuildSuccess (CandidateBuilt, Unmodified), StageState (..))

updateStageState ::
  StageState a s ->
  DepMutation a ->
  MutationResult s ->
  StageState a s
updateStageState :: forall a s.
StageState a s
-> DepMutation a -> MutationResult s -> StageState a s
updateStageState StageState a s
old DepMutation a
mutation = \case
  MutationSuccess {s
Bool
Set PackageId
MutationState
MutableId
candidate :: MutableId
changed :: Bool
state :: MutationState
revisions :: Set PackageId
ext :: s
ext :: forall s. MutationResult s -> s
revisions :: forall s. MutationResult s -> Set PackageId
state :: forall s. MutationResult s -> MutationState
changed :: forall s. MutationResult s -> Bool
candidate :: forall s. MutationResult s -> MutableId
..} ->
    StageState a s
old {
      success = Map.insert candidate.name buildSuccess old.success,
      state,
      revisions = Set.union revisions old.revisions,
      ext
    }
    where
      buildSuccess :: BuildSuccess
buildSuccess | Bool
changed = MutableId -> BuildSuccess
CandidateBuilt MutableId
candidate
                   | Bool
otherwise = MutableDep -> BuildSuccess
Unmodified DepMutation a
mutation.package
  MutationResult s
MutationKeep ->
    StageState a s
old {success = Map.insert mutation.package (Unmodified mutation.package) old.success}
  MutationResult s
MutationFailed ->
    StageState a s
old {failed = mutation : old.failed}