module Hix.Managed.Cabal.Print where

import qualified Distribution.Client.SolverInstallPlan as SolverInstallPlan
import Distribution.Client.SolverInstallPlan (ResolverPackage (..), SolverInstallPlan, SolverPlanPackage)
import Distribution.InstalledPackageInfo (InstalledPackageInfo (InstalledPackageInfo, sourcePackageId))
import Distribution.Solver.Types.InstSolverPackage (InstSolverPackage (InstSolverPackage, instSolverPkgIPI))
import Distribution.Solver.Types.SolverPackage (SolverPackage (..))
import Distribution.Solver.Types.SourcePackage (SourcePackage (..))
import Exon (exon)

import Hix.Data.Monad (M)
import qualified Hix.Data.PackageId as PackageId
import Hix.Data.PackageId (PackageId)
import qualified Hix.Log as Log
import Hix.Pretty (showP)

resolverPackageId :: ResolverPackage a -> PackageId
resolverPackageId :: forall a. ResolverPackage a -> PackageId
resolverPackageId = \case
  PreExisting InstSolverPackage {instSolverPkgIPI :: InstSolverPackage -> InstalledPackageInfo
instSolverPkgIPI = InstalledPackageInfo {PackageId
sourcePackageId :: InstalledPackageInfo -> PackageId
sourcePackageId :: PackageId
sourcePackageId}} ->
    PackageId -> PackageId
PackageId.fromCabal PackageId
sourcePackageId
  Configured SolverPackage {solverPkgSource :: forall loc. SolverPackage loc -> SourcePackage loc
solverPkgSource = SourcePackage {PackageId
srcpkgPackageId :: PackageId
srcpkgPackageId :: forall loc. SourcePackage loc -> PackageId
srcpkgPackageId}} ->
    PackageId -> PackageId
PackageId.fromCabal PackageId
srcpkgPackageId

showPackage :: SolverPlanPackage -> String
showPackage :: SolverPlanPackage -> String
showPackage SolverPlanPackage
pkg =
  [exon|#{desc}: #{showP (resolverPackageId pkg)}|]
  where
    desc :: String
desc = case SolverPlanPackage
pkg of
      PreExisting {} -> String
"existing"
      Configured {} -> String
"configured"

printPlan :: SolverInstallPlan -> M ()
printPlan :: SolverInstallPlan -> M ()
printPlan SolverInstallPlan
plan = do
  Text -> M ()
Log.info Text
"Plan:"
  [SolverPlanPackage] -> (SolverPlanPackage -> M ()) -> M ()
forall (t :: * -> *) (f :: * -> *) a b.
(Foldable t, Applicative f) =>
t a -> (a -> f b) -> f ()
for_ (SolverInstallPlan -> [SolverPlanPackage]
SolverInstallPlan.toList SolverInstallPlan
plan) \ SolverPlanPackage
pkg ->
    Text -> M ()
Log.infoCont [exon|📦 #{toText (showPackage pkg)}|]