module Unison.Codebase.Editor.HandleInput.MoveTerm (doMoveTerm, moveTermSteps) where

import Data.Set qualified as Set
import Unison.Cli.Monad (Cli)
import Unison.Cli.Monad qualified as Cli
import Unison.Cli.MonadUtils qualified as Cli
import Unison.Codebase qualified as Codebase
import Unison.Codebase.Branch (Branch0)
import Unison.Codebase.BranchUtil qualified as BranchUtil
import Unison.Codebase.Editor.Output qualified as Output
import Unison.Codebase.Path (Path')
import Unison.Codebase.Path qualified as Path
import Unison.Codebase.ProjectPath qualified as PP
import Unison.HashQualifiedPrime qualified as HQ'
import Unison.Prelude

moveTermSteps ::
  HQ'.HashQualified (Path.Split Path') -> Path.Split Path' -> Cli [(Path.Absolute, Branch0 m -> Branch0 m)]
moveTermSteps :: forall (m :: * -> *).
HashQualified (Split Path')
-> Split Path' -> Cli [(Absolute, Branch0 m -> Branch0 m)]
moveTermSteps HashQualified (Split Path')
src' Split Path'
dest' = do
  src <- (Split Path' -> Cli (Split (ProjectPathG Project ProjectBranch)))
-> HashQualified (Split Path')
-> Cli (HashQualified (Split (ProjectPathG Project ProjectBranch)))
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> HashQualified a -> f (HashQualified b)
traverse Split Path' -> Cli (Split (ProjectPathG Project ProjectBranch))
Cli.resolveSplit' HashQualified (Split Path')
src'
  srcTerms <- Cli.getTermsAt src
  case Set.toList srcTerms of
    [] -> [(Absolute, Branch0 m -> Branch0 m)]
-> Cli [(Absolute, Branch0 m -> Branch0 m)]
forall a. a -> Cli a
forall (f :: * -> *) a. Applicative f => a -> f a
pure []
    Referent
_ : Referent
_ : [Referent]
_ -> do
      hqLength <- Transaction Int -> Cli Int
forall a. Transaction a -> Cli a
Cli.runTransaction Transaction Int
Codebase.hashLength
      Cli.returnEarly (Output.DeleteNameAmbiguous hqLength src' srcTerms Set.empty)
    [Referent
srcTerm] -> do
      dest <- Split Path' -> Cli (Split (ProjectPathG Project ProjectBranch))
Cli.resolveSplit' Split Path'
dest'
      destTerms <- Cli.getTermsAt $ HQ'.NameOnly dest
      when (not (Set.null destTerms)) do
        Cli.returnEarly (Output.TermAlreadyExists dest' destTerms)
      pure
        [ -- Mitchell: throwing away any hash-qualification here seems wrong!
          BranchUtil.makeDeleteTermName (first (view PP.absPath_) $ HQ'.toName src) srcTerm,
          BranchUtil.makeAddTermName (first (view PP.absPath_) dest) srcTerm
        ]

doMoveTerm :: HQ'.HashQualified (Path.Split Path') -> Path.Split Path' -> Text -> Cli ()
doMoveTerm :: HashQualified (Split Path') -> Split Path' -> Text -> Cli ()
doMoveTerm HashQualified (Split Path')
src' Split Path'
dest' Text
description = do
  steps <- HashQualified (Split Path')
-> Split Path' -> Cli [(Absolute, Branch0 IO -> Branch0 IO)]
forall (m :: * -> *).
HashQualified (Split Path')
-> Split Path' -> Cli [(Absolute, Branch0 m -> Branch0 m)]
moveTermSteps HashQualified (Split Path')
src' Split Path'
dest'
  when (null steps) do
    Cli.returnEarly (Output.TermNotFound src')
  pb <- Cli.getCurrentProjectBranch
  Cli.stepManyAt pb description steps
  Cli.respond Output.Success