module Hix.Managed.UpdateState where

import Hix.Class.Map (nAdjust, nAmend, nInsert)
import Hix.Data.Overrides (Overrides)
import qualified Hix.Managed.Data.EnvContext
import Hix.Managed.Data.EnvContext (EnvContext)
import qualified Hix.Managed.Data.EnvState
import Hix.Managed.Data.EnvState (EnvState (EnvState))
import Hix.Managed.Data.Mutable (mutUpdateTargets)
import qualified Hix.Managed.Data.MutationState
import Hix.Managed.Data.MutationState (MutationState)
import qualified Hix.Managed.Data.ProjectState
import Hix.Managed.Data.ProjectState (ProjectState (ProjectState))
import Hix.Managed.Diff (applyBoundsChange, applyVersionChange, updateBoundsChanges, updateVersionChanges)

-- | Insert the transformed 'EnvState', which contains only the bounds for the current target set and the overrides
-- for the current env.
--
-- All data is stored as diffs in 'EnvState' (except for overrides), which are applied to the initial state.
--
-- Since the env is intended to be exclusively used with its associated target set, we simply overwrite the existing one
-- completely.
--
-- Bounds are supposed to be universally valid, since they qualify the source rather than a build configuration, so they
-- have to be updated in each of the env's target packages.
--
-- @initial@ is the set of bounds that is preserved from the first run for each dependency.
-- The 'EnvState' only contains updates for them if an update for @versions@ contains @DiffAdded@, which is handled
-- in 'envStateWithMutations'.
projectStateWithEnv ::
  EnvContext ->
  EnvState ->
  ProjectState ->
  ProjectState
projectStateWithEnv :: EnvContext -> EnvState -> ProjectState -> ProjectState
projectStateWithEnv EnvContext
context EnvState
new ProjectState
old =
  ProjectState {
    bounds :: Packages MutableBounds
bounds = Targets
-> (BoundsChange -> VersionBounds -> VersionBounds)
-> MutableDeps BoundsChange
-> Packages MutableBounds
-> Packages MutableBounds
forall map1 v1 s1 map2 v2 s2.
(NMap map1 MutableDep v1 s1, NMap map2 MutableDep v2 s2) =>
Targets
-> (v1 -> v2 -> v2) -> map1 -> Packages map2 -> Packages map2
mutUpdateTargets EnvContext
context.targets BoundsChange -> VersionBounds -> VersionBounds
applyBoundsChange EnvState
new.bounds ProjectState
old.bounds,
    versions :: Envs MutableVersions
versions = EnvName
-> Envs MutableVersions
-> (MutableVersions -> MutableVersions)
-> Envs MutableVersions
forall map k v sort.
NMap map k v sort =>
k -> map -> (v -> v) -> map
nAdjust EnvContext
context.env ProjectState
old.versions ((VersionChange -> Maybe Version -> Maybe Version)
-> MutableDeps VersionChange -> MutableVersions -> MutableVersions
forall map1 map2 k v1 v2 s1 s2.
(NMap map1 k v1 s1, NMap map2 k v2 s2) =>
(v1 -> v2 -> v2) -> map1 -> map2 -> map2
nAmend VersionChange -> Maybe Version -> Maybe Version
applyVersionChange EnvState
new.versions),
    overrides :: Envs Overrides
overrides = EnvName -> Overrides -> Envs Overrides -> Envs Overrides
forall map k v sort. NMap map k v sort => k -> v -> map -> map
nInsert EnvContext
context.env EnvState
new.overrides ProjectState
old.overrides,
    initial :: Envs MutableVersions
initial = EnvName
-> Envs MutableVersions
-> (MutableVersions -> MutableVersions)
-> Envs MutableVersions
forall map k v sort.
NMap map k v sort =>
k -> map -> (v -> v) -> map
nAdjust EnvContext
context.env ProjectState
old.initial ((VersionChange -> Maybe Version -> Maybe Version)
-> MutableDeps VersionChange -> MutableVersions -> MutableVersions
forall map1 map2 k v1 v2 s1 s2.
(NMap map1 k v1 s1, NMap map2 k v2 s2) =>
(v1 -> v2 -> v2) -> map1 -> map2 -> map2
nAmend VersionChange -> Maybe Version -> Maybe Version
applyVersionChange EnvState
new.initial),
    resolving :: Bool
resolving = ProjectState
old.resolving
  }

envStateForBuild ::
  EnvContext ->
  Overrides ->
  ProjectState
envStateForBuild :: EnvContext -> Overrides -> ProjectState
envStateForBuild EnvContext
context Overrides
overrides =
  ProjectState {
    bounds :: Packages MutableBounds
bounds = Packages MutableBounds
forall a. Monoid a => a
mempty,
    versions :: Envs MutableVersions
versions = Envs MutableVersions
forall a. Monoid a => a
mempty,
    overrides :: Envs Overrides
overrides = [(EnvContext
context.env, Overrides
overrides)],
    initial :: Envs MutableVersions
initial = [],
    resolving :: Bool
resolving = Bool
True
  }

envStateWithMutations ::
  MutationState ->
  EnvState ->
  EnvState
envStateWithMutations :: MutationState -> EnvState -> EnvState
envStateWithMutations MutationState
new EnvState {MutableDeps BoundsChange
bounds :: MutableDeps BoundsChange
bounds :: EnvState -> MutableDeps BoundsChange
bounds, MutableDeps VersionChange
versions :: MutableDeps VersionChange
versions :: EnvState -> MutableDeps VersionChange
versions, MutableDeps VersionChange
initial :: MutableDeps VersionChange
initial :: EnvState -> MutableDeps VersionChange
initial} =
  EnvState {
    bounds :: MutableDeps BoundsChange
bounds = MutableBounds
-> MutableDeps BoundsChange -> MutableDeps BoundsChange
forall vmap s1 map s2.
(NMap vmap MutableDep VersionBounds s1,
 NMap map MutableDep BoundsChange s2) =>
vmap -> map -> map
updateBoundsChanges MutationState
new.bounds MutableDeps BoundsChange
bounds,
    versions :: MutableDeps VersionChange
versions = MutableVersions
-> MutableDeps VersionChange -> MutableDeps VersionChange
forall vmap s1 map s2.
(NMap vmap MutableDep (Maybe Version) s1,
 NMap map MutableDep VersionChange s2) =>
vmap -> map -> map
updateVersionChanges MutationState
new.versions MutableDeps VersionChange
versions,
    overrides :: Overrides
overrides = MutationState
new.overrides,
    initial :: MutableDeps VersionChange
initial = MutableVersions
-> MutableDeps VersionChange -> MutableDeps VersionChange
forall vmap s1 map s2.
(NMap vmap MutableDep (Maybe Version) s1,
 NMap map MutableDep VersionChange s2) =>
vmap -> map -> map
updateVersionChanges MutationState
new.initial MutableDeps VersionChange
initial
  }