module Hix.Managed.StageContext where

import qualified Hix.Managed.Data.EnvContext
import Hix.Managed.Data.EnvRequest (EnvRequest (..))
import qualified Hix.Managed.Data.EnvState
import Hix.Managed.Data.EnvState (EnvState (EnvState))
import Hix.Managed.Data.Initial (Initial (Initial))
import qualified Hix.Managed.Data.MutationState
import Hix.Managed.Data.MutationState (MutationState (MutationState))
import Hix.Managed.Data.Query (Query (Query))
import Hix.Managed.Data.StageContext (StageContext (..))
import Hix.Managed.Diff (reifyBoundsChanges, reifyVersionChanges)
import qualified Hix.Managed.Handlers.Build
import Hix.Managed.QueryDep (queryDep)

-- | Initialize the mutation versions from the persisted state, so the solver bounds are populated by the versions
-- determined in previous runs.
--
-- @bounds@ is initialized empty because it is used only for updating based on candidates, since upper bounds differ
-- from the tested versions.
mutationState :: EnvState -> Initial MutationState
mutationState :: EnvState -> Initial MutationState
mutationState EnvState {MutableDeps VersionChange
versions :: MutableDeps VersionChange
versions :: EnvState -> MutableDeps VersionChange
versions, Overrides
overrides :: Overrides
overrides :: EnvState -> Overrides
overrides} =
  MutationState -> Initial MutationState
forall a. a -> Initial a
Initial MutationState {
    bounds :: MutableBounds
bounds = MutableBounds
forall a. Monoid a => a
mempty,
    versions :: MutableVersions
versions = MutableDeps VersionChange -> MutableVersions
reifyVersionChanges MutableDeps VersionChange
versions,
    Overrides
overrides :: Overrides
overrides :: Overrides
overrides,
    initial :: MutableVersions
initial = MutableVersions
forall a. Monoid a => a
mempty
  }

stageContext :: EnvRequest -> EnvState -> StageContext
stageContext :: EnvRequest -> EnvState -> StageContext
stageContext EnvRequest {context :: EnvRequest -> EnvContext
context = EnvContext
env, EnvBuilder
builder :: EnvBuilder
builder :: EnvRequest -> EnvBuilder
builder} EnvState
envState =
  StageContext {
    query :: Query
query = NonEmpty QueryDep -> Query
Query (CabalHandlers
-> Initial MutationState -> MutableBounds -> MutableDep -> QueryDep
queryDep EnvBuilder
builder.cabal Initial MutationState
state MutableBounds
bounds (MutableDep -> QueryDep)
-> NonEmpty MutableDep -> NonEmpty QueryDep
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> EnvContext
env.query),
    initial :: MutableVersions
initial = MutableDeps VersionChange -> MutableVersions
reifyVersionChanges EnvState
envState.initial,
    Initial MutationState
EnvContext
EnvBuilder
env :: EnvContext
builder :: EnvBuilder
state :: Initial MutationState
state :: Initial MutationState
builder :: EnvBuilder
env :: EnvContext
..
  }
  where
    bounds :: MutableBounds
bounds = MutableDeps BoundsChange -> MutableBounds
reifyBoundsChanges EnvState
envState.bounds
    state :: Initial MutationState
state = EnvState -> Initial MutationState
mutationState EnvState
envState