/--
Resolve a path to an absolute path.
- Absolute input is used as-is.
- Relative input is resolved from `basePath` when provided, otherwise from current directory.
- Uses `realPath` when possible; falls back to normalized absolute syntax when the path does not exist.
-/
def resolveAbsolutePath (basePath : Option String) (path : String) : IO String := do
  let candidate : System.FilePath ←
    if path.startsWith "/" then
      pure (System.FilePath.mk path)
    else
      match basePath with
      | some base => pure <| System.FilePath.mk (base ++ "/" ++ path)
      | none =>
          let cwd ← IO.currentDir
          pure <| System.FilePath.mk (cwd.toString ++ "/" ++ path)
  try
    let resolved ← IO.FS.realPath candidate
    pure resolved.toString
  catch _ =>
    pure candidate.normalize.toString

  | [path] =>

  | [path] => do

    let absPath := if path.startsWith "/" then path
                   else match ws.rootPath with
                        | some root => root ++ "/" ++ path
                        | none => path

    let absPath ← ViE.resolveAbsolutePath ws.rootPath path

  let resolvePath (p : String) : String :=
    if p.startsWith "/" then p
    else
      match state.getCurrentWorkspace.rootPath with
      | some root => root ++ "/" ++ p
      | none => p

  | "open" :: rest =>

  | "open" :: rest => do

      let absPath := resolvePath path

      let absPath ← ViE.resolveAbsolutePath state.getCurrentWorkspace.rootPath path

  | ["new", name, path] =>

  | ["new", name, path] => do

    else
    let absPath := resolvePath path

    else do
      let absPath ← ViE.resolveAbsolutePath state.getCurrentWorkspace.rootPath path

import ViE.Workspace

    let filePath := System.FilePath.mk path

    let absPath ← ViE.resolveAbsolutePath none path
    let filePath := System.FilePath.mk absPath

        pure (some path, none)

        pure (some absPath, none)

          | none => "."
        pure (some parentDir, some path)

          | none => "/"
        pure (some parentDir, some absPath)

      -- Path doesn't exist, treat as new file
      pure (none, some path)

      -- Path doesn't exist yet: still anchor workspace resolution at its parent.
      let parentDir := match filePath.parent with
        | some p => p.toString
        | none => "/"
      pure (some parentDir, some absPath)

  IO.println "Starting Workspace Relative Path Resolution Test..."
  let stamp ← IO.monoMsNow
  let relBase := s!"/tmp/vie-ws-rel-{stamp}"
  IO.FS.createDirAll (System.FilePath.mk relBase)
  let sRel0 := s11.updateCurrentWorkspace fun ws =>
    { ws with rootPath := some relBase, name := "RelBase" }
  let sRel1 ← ViE.Command.cmdCd ["child"] sRel0
  assertEqual "cd relative resolves from workspace root" (some s!"{relBase}/child") sRel1.getCurrentWorkspace.rootPath
  let sRel2 ← ViE.Command.cmdWs ["open", "nested"] sRel0
  assertEqual "ws open relative resolves from workspace root" (some s!"{relBase}/nested") sRel2.getCurrentWorkspace.rootPath
  assertEqual "ws open relative uses basename from absolute path" "nested" sRel2.getCurrentWorkspace.name
  let sRel3 ← ViE.Command.cmdWs ["new", "RelChild", "child2"] sRel0
  assertEqual "ws new relative resolves from workspace root" (some s!"{relBase}/child2") sRel3.getCurrentWorkspace.rootPath

  let absBase ← ViE.resolveAbsolutePath none base

  let absDirOnly ← ViE.resolveAbsolutePath none dirOnly

  assertEqual "Directory arg sets workspace" (some dirOnly) wsDirOnly

  assertEqual "Directory arg sets workspace" (some absDirOnly) wsDirOnly

  let absFileNested ← ViE.resolveAbsolutePath none fileNested
  let nestedParent := match (System.FilePath.mk absFileNested).parent with
    | some p => p.toString
    | none => "/"

  assertEqual "File arg sets workspace to parent dir" (some s!"{base}/dir0/dir1/dir2") wsFileNested
  assertEqual "File arg keeps filename" (some fileNested) fileFileNested

  assertEqual "File arg sets workspace to parent dir" (some nestedParent) wsFileNested
  assertEqual "File arg keeps filename" (some absFileNested) fileFileNested

  let absFileTop ← ViE.resolveAbsolutePath none fileTop

  assertEqual "Top-level file sets workspace to base" (some base) wsFileTop
  assertEqual "Top-level file keeps filename" (some fileTop) fileFileTop

  assertEqual "Top-level file sets workspace to base" (some absBase) wsFileTop
  assertEqual "Top-level file keeps filename" (some absFileTop) fileFileTop
  let newNested := s!"{base}/newdir/newfile.txt"
  let absNewNested ← ViE.resolveAbsolutePath none newNested
  let newNestedParent := match (System.FilePath.mk absNewNested).parent with
    | some p => p.toString
    | none => "/"
  let (wsNewNested, fileNewNested) ← ViE.resolveStartupTarget (some newNested)
  assertEqual "Nonexistent file sets workspace to parent dir" (some newNestedParent) wsNewNested
  assertEqual "Nonexistent file keeps absolute filename" (some absNewNested) fileNewNested

  let absTest ← ViE.resolveAbsolutePath none "Test"

    { ws with rootPath := some "Test", name := "Test" }
  let s14 ← ViE.Feature.openExplorer s13 "Test"
  assertEqual "Explorer opens workspace root without duplication" (some "explorer://Test") s14.getActiveBuffer.filename

    { ws with rootPath := some absTest, name := "Test" }
  let s14 ← ViE.Feature.openExplorer s13 "."
  assertEqual "Explorer opens absolute workspace root from dot" (some s!"explorer://{absTest}") s14.getActiveBuffer.filename
  let s15 ← ViE.Feature.openExplorer s13 "test_paths"
  assertEqual "Explorer resolves relative path from absolute workspace root" (some s!"explorer://{absTest}/test_paths") s15.getActiveBuffer.filename