Installer.iss

; Script generated by the Inno Script Studio Wizard.
; SEE THE DOCUMENTATION FOR DETAILS ON CREATING INNO SETUP SCRIPT FILES!

#define MyAppName "EDDI"
#define MyAppVersion "5.0.6"
#define MyAppPublisher "Elite Dangerous Community Developers (EDCD)"
#define MyAppURL "https://github.com/EDCD/EDDI/"
#define MyAppExeName "EDDI.exe"
#define DotNetDesktopRuntimeMajor "8"
#define DotNetDesktopRuntimeInstallerUrl "https://aka.ms/dotnet/8.0/windowsdesktop-runtime-win-x64.exe"

[Setup]
; NOTE: The value of AppId uniquely identifies this application.
; Do not use the same AppId value in installers for other applications.
; (To generate a new GUID, click Tools | Generate GUID inside the IDE.)
AllowUNCPath=no
ArchitecturesAllowed=x64compatible
ArchitecturesInstallIn64BitMode=x64compatible
AppId={{830C0324-30D8-423C-B5B4-D7EE8D007A79}
AppName={#MyAppName}
AppPublisher={#MyAppPublisher}
AppPublisherURL={#MyAppURL}
AppSupportURL={#MyAppURL}
AppUpdatesURL={#MyAppURL}
AppVerName={#MyAppName} {#MyAppVersion}
AppVersion={#MyAppVersion}
CloseApplications=yes
DefaultDirName={code:GetDefaultInstallDir}
DefaultGroupName={#MyAppName}
DirExistsWarning=no
DisableDirPage=no
DisableWelcomePage=no
LicenseFile="{#SourcePath}\LicenseFile.txt"
OutputBaseFilename={#MyAppName}-{#MyAppVersion}
OutputDir="{#SourcePath}\bin\Installer"
PrivilegesRequired=lowest
PrivilegesRequiredOverridesAllowed=dialog commandline
RestartApplications=no
SolidCompression=yes
SourceDir="{#SourcePath}\bin\Release\Application"
UninstallDisplayIcon={app}\{#MyAppExeName}
UsePreviousAppDir=no
UsePreviousTasks=no
WizardImageFile={#SourcePath}\graphics\logo.bmp
WizardSmallImageFile={#SourcePath}\graphics\logo.bmp

[Languages]
Name: "english"; MessagesFile: "compiler:Default.isl"

[Tasks]
Name: "desktopicon"; Description: "{cm:CreateDesktopIcon}"; GroupDescription: "{cm:AdditionalIcons}"; Flags: unchecked

[Files]
Source: "*.exe"; DestDir: "{app}"; Excludes: "DocumentationGenerator.exe"
Source: "*.exe.config"; DestDir: "{app}"; Flags: skipifsourcedoesntexist

Source: "runtimes\*.*"; DestDir: "{app}\runtimes"; Flags: recursesubdirs createallsubdirs

Source: "*.dll"; DestDir: "{app}"; Excludes: "Tests.dll,DocumentationGenerator.dll"
Source: "*.dll.config"; DestDir: "{app}"; Flags: skipifsourcedoesntexist

Source: "*.resources.dll"; DestDir: "{app}"; Flags: recursesubdirs createallsubdirs
Source: "Cottle\*.*"; DestDir: "{app}\Cottle"; Flags: recursesubdirs createallsubdirs
Source: "Wiki\*.*"; DestDir: "{app}\Wiki"; Flags: recursesubdirs createallsubdirs
Source: "eddi.json"; DestDir: "{app}"
Source: "eddi.*.json"; DestDir: "{app}"
Source: "*.md"; DestDir: "{app}"
Source: "{#SourcePath}\bin\Release\VoiceAttackPluginShim\*"; DestDir: "{code:GetVoiceAttack2EddiDir}"; Flags: recursesubdirs createallsubdirs

; Remove outdated files
[InstallDelete]
; --- Remove old architecture folders entirely ---
Type: filesandordirs; Name: "{app}\x86"
Type: filesandordirs; Name: "{app}\x64"
Type: filesandordirs; Name: "{app}\runtimes"

; --- Remove all old DLLs in the root folder ---
Type: files; Name: "{app}\*.dll"

; --- Remove old PDBs ---
Type: files; Name: "{app}\*.pdb"

; --- Remove old doc files ---
Type: files; Name: "{app}\*.md"
Type: files; Name: "{app}\*.xml"

; --- Remove old default personality files ---
Type: files; Name: "{app}\eddi.json"
Type: files; Name: "{app}\eddi.*.json"

; --- Remove old VoiceAttack profiles ---
Type: files; Name: "{app}\*.vap"

; --- Remove old resource files that may no longer be valid ---
Type: filesandordirs; Name: "{app}\*\*.resources.dll"

; --- Remove old app payload files from the VoiceAttack plugin folder before copying the new plugin ---
Type: files; Name: "{code:GetVoiceAttack2EddiDir}\*.dll"
Type: files; Name: "{code:GetVoiceAttack2EddiDir}\*.pdb"
Type: files; Name: "{code:GetVoiceAttack2EddiDir}\*.deps.json"
Type: files; Name: "{code:GetVoiceAttack2EddiDir}\*.runtimeconfig.json"
Type: files; Name: "{code:GetVoiceAttack2EddiDir}\*.exe"
Type: files; Name: "{code:GetVoiceAttack2EddiDir}\*.exe.config"
Type: filesandordirs; Name: "{code:GetVoiceAttack2EddiDir}\runtimes"
Type: filesandordirs; Name: "{code:GetVoiceAttack2EddiDir}\cs"
Type: filesandordirs; Name: "{code:GetVoiceAttack2EddiDir}\de"
Type: filesandordirs; Name: "{code:GetVoiceAttack2EddiDir}\es"
Type: filesandordirs; Name: "{code:GetVoiceAttack2EddiDir}\fr"
Type: filesandordirs; Name: "{code:GetVoiceAttack2EddiDir}\hu"
Type: filesandordirs; Name: "{code:GetVoiceAttack2EddiDir}\it"
Type: filesandordirs; Name: "{code:GetVoiceAttack2EddiDir}\ja"
Type: filesandordirs; Name: "{code:GetVoiceAttack2EddiDir}\pt-BR"
Type: filesandordirs; Name: "{code:GetVoiceAttack2EddiDir}\pt-PT"
Type: filesandordirs; Name: "{code:GetVoiceAttack2EddiDir}\ru"
Type: filesandordirs; Name: "{code:GetVoiceAttack2EddiDir}\zh-CN"
Type: filesandordirs; Name: "{code:GetVoiceAttack2EddiDir}\Cottle"
Type: filesandordirs; Name: "{code:GetVoiceAttack2EddiDir}\Wiki"
Type: files; Name: "{code:GetVoiceAttack2EddiDir}\*.md"
Type: files; Name: "{code:GetVoiceAttack2EddiDir}\eddi.json"
Type: files; Name: "{code:GetVoiceAttack2EddiDir}\eddi.*.json"

; --- Remove old config files that may no longer be valid ---
Type: files; Name: "{app}\*.dll.config"

; --- Remove old user-specific cached configs that cause runtime mismatches ---
Type: filesandordirs; Name: "{localappdata}\Eddi\Eddi.exe_*"; Check: ShouldModifyCurrentUserAreas
Type: files; Name: "{localappdata}\Eddi\Eddi.exe_*\*\user.config"; Check: ShouldModifyCurrentUserAreas

; --- Remove obsolete legacy files from older EDDI versions ---
Type: files; Name: "{app}\*.exe"
Type: files; Name: "{app}\*.exe.config"
Type: files; Name: "{app}\EDDI.ico"
Type: files; Name: "{userappdata}\EDDI\credentials.json"; Check: ShouldModifyCurrentUserAreas
Type: files; Name: "{userappdata}\EDDI\elite.json"; Check: ShouldModifyCurrentUserAreas
Type: filesandordirs; Name: "{userappdata}\EDDI\galnet"; Check: ShouldModifyCurrentUserAreas

; Keep user data on uninstall. API credentials are user-owned and may be reused
; after repairing or reinstalling EDDI.
[UninstallDelete]

[Icons]
Name: "{group}\{#MyAppName}"; Filename: "{app}\{#MyAppExeName}"
Name: "{group}\{cm:UninstallProgram,{#MyAppName}}"; Filename: "{uninstallexe}"
Name: "{commondesktop}\{#MyAppName}"; Filename: "{app}\{#MyAppExeName}"; Tasks: desktopicon; Check: IsAdminInstallMode
Name: "{userdesktop}\{#MyAppName}"; Filename: "{app}\{#MyAppExeName}"; Tasks: desktopicon; Check: not IsAdminInstallMode

[Run]
; Manual / non-silent installer launch option.
Filename: "{app}\{#MyAppExeName}"; Description: "{cm:LaunchProgram,{#StringChange(MyAppName, '&', '&&')}}"; Flags: nowait postinstall skipifsilent runasoriginaluser

; Silent in-app upgrade launch.
; This always launches the newly installed executable.
Filename: "{app}\{#MyAppExeName}"; Flags: nowait skipifnotsilent runasoriginaluser; Check: ShouldRunAfterInAppUpgrade

[Messages]
SelectDirBrowseLabel=To continue, click Next. If this is not where you want the EDDI application files installed, click Browse. Do not select a VoiceAttack Apps folder.

[Registry]
Root: "HKLM"; Subkey: "Software\Classes\eddi"; ValueType: string; ValueData: "EDDI URL Protocol"; Flags: uninsdeletekey; Check: ShouldWriteMachineRegistry
Root: "HKLM"; Subkey: "Software\Classes\eddi"; ValueType: string; ValueName: "URL Protocol"; Flags: uninsdeletekey; Check: ShouldWriteMachineRegistry
Root: "HKLM"; Subkey: "Software\Classes\eddi\Default Icon"; ValueType: string; ValueData: "{app}\{#MyAppExeName},0"; Flags: uninsdeletekey; Check: ShouldWriteMachineRegistry
Root: "HKLM"; Subkey: "Software\Classes\eddi\shell\open\command"; ValueType: string; ValueData: """{app}\{#MyAppExeName}"" ""%1"""; Flags: uninsdeletekey; Check: ShouldWriteMachineRegistry
Root: "HKLM"; Subkey: "Software\Classes\eddi\shell\open\ddeexec"; ValueType: string; ValueData: "%1"; Flags: uninsdeletekey; Check: ShouldWriteMachineRegistry
Root: "HKCU"; Subkey: "Software\Classes\eddi"; ValueType: string; ValueData: "EDDI URL Protocol"; Flags: uninsdeletekey; Check: ShouldWriteCurrentUserRegistry
Root: "HKCU"; Subkey: "Software\Classes\eddi"; ValueType: string; ValueName: "URL Protocol"; Flags: uninsdeletekey; Check: ShouldWriteCurrentUserRegistry
Root: "HKCU"; Subkey: "Software\Classes\eddi\Default Icon"; ValueType: string; ValueData: "{app}\{#MyAppExeName},0"; Flags: uninsdeletekey; Check: ShouldWriteCurrentUserRegistry
Root: "HKCU"; Subkey: "Software\Classes\eddi\shell\open\command"; ValueType: string; ValueData: """{app}\{#MyAppExeName}"" ""%1"""; Flags: uninsdeletekey; Check: ShouldWriteCurrentUserRegistry
Root: "HKCU"; Subkey: "Software\Classes\eddi\shell\open\ddeexec"; ValueType: string; ValueData: "%1"; Flags: uninsdeletekey; Check: ShouldWriteCurrentUserRegistry
Root: "HKCU"; Subkey: "Software\EDCD\EDDI"; ValueType: string; ValueName: "ExecutablePath"; ValueData: "{app}\{#MyAppExeName}"; Check: ShouldWriteCurrentUserRegistry
Root: "HKCU"; Subkey: "Software\EDCD\EDDI"; ValueType: string; ValueName: "InstallDirectory"; ValueData: "{app}"; Check: ShouldWriteCurrentUserRegistry
Root: "HKCU"; Subkey: "Software\EDCD\EDDI"; ValueType: string; ValueName: "Version"; ValueData: "{#MyAppVersion}"; Check: ShouldWriteCurrentUserRegistry
Root: "HKLM"; Subkey: "Software\EDCD\EDDI"; ValueType: string; ValueName: "ExecutablePath"; ValueData: "{app}\{#MyAppExeName}"; Check: ShouldWriteMachineLocator
Root: "HKLM"; Subkey: "Software\EDCD\EDDI"; ValueType: string; ValueName: "InstallDirectory"; ValueData: "{app}"; Check: ShouldWriteMachineLocator
Root: "HKLM"; Subkey: "Software\EDCD\EDDI"; ValueType: string; ValueName: "Version"; ValueData: "{#MyAppVersion}"; Check: ShouldWriteMachineLocator

[Code]

var
  DotNetDesktopRuntimeNeedsRestart: Boolean;
  LegacySilentMigration: Boolean;
  VoiceAttackAppsPage: TWizardPage;
  ApplicationDirText: TNewStaticText;
  VoiceAttackAppsDirEdit: TNewEdit;
  VoiceAttackPluginDirText: TNewStaticText;
  VoiceAttackAppsBrowseButton: TNewButton;
  SelectedVoiceAttackAppsDir: string;
  CleanupFailureDetails: string;

function NormalizePath(const S: string): string;
begin
  Result := Lowercase(RemoveBackslashUnlessRoot(S));
end;

function SamePath(const A, B: string): Boolean;
begin
  Result := NormalizePath(A) = NormalizePath(B);
end;

function IsUnderPath(const Child, Parent: string): Boolean;
var
  C, P: string;
begin
  C := NormalizePath(Child);
  P := NormalizePath(Parent);
  Result := (C = P) or (Pos(P + '\', C) = 1);
end;

function IsUserProfilePath(const Dir: string): Boolean;
var
  UserProfile: string;
begin
  UserProfile := GetEnv('USERPROFILE');

  Result :=
    IsUnderPath(Dir, ExpandConstant('{localappdata}')) or
    IsUnderPath(Dir, ExpandConstant('{userappdata}')) or
    ((Trim(UserProfile) <> '') and IsUnderPath(Dir, UserProfile));
end;

function IsRequiredDotNetDesktopRuntimeVersionName(const VersionName: string): Boolean;
begin
  Result := Pos('{#DotNetDesktopRuntimeMajor}.', VersionName) = 1;
end;

function IsRequiredDotNetDesktopRuntimeRegisteredAt(RootKey: Integer; const RuntimeKey: string): Boolean;
var
  I: Integer;
  SubkeyNames: TArrayOfString;
  ValueNames: TArrayOfString;
begin
  Result := False;
  if RegGetValueNames(RootKey, RuntimeKey, ValueNames) then
  begin
    for I := 0 to GetArrayLength(ValueNames) - 1 do
    begin
      if IsRequiredDotNetDesktopRuntimeVersionName(ValueNames[I]) then
      begin
        Log(Format('Found required .NET Desktop Runtime major version %s from registry value: %s', ['{#DotNetDesktopRuntimeMajor}', ValueNames[I]]));
        Result := True;
        exit;
      end;
    end;
  end;
  if RegGetSubkeyNames(RootKey, RuntimeKey, SubkeyNames) then
  begin
    for I := 0 to GetArrayLength(SubkeyNames) - 1 do
    begin
      if IsRequiredDotNetDesktopRuntimeVersionName(SubkeyNames[I]) then
      begin
        Log(Format('Found required .NET Desktop Runtime major version %s from registry subkey: %s', ['{#DotNetDesktopRuntimeMajor}', SubkeyNames[I]]));
        Result := True;
        exit;
      end;
    end;
  end;
  Log(Format('.NET Desktop Runtime registry key did not contain major version %s: %s', ['{#DotNetDesktopRuntimeMajor}', RuntimeKey]));
end;

function IsRequiredDotNetDesktopRuntimeInDirectory(const RuntimeDir: string): Boolean;
var
  FindRec: TFindRec;
begin
  Result := False;
  if (Trim(RuntimeDir) = '') or not DirExists(RuntimeDir) then
    exit;

  if FindFirst(AddBackslash(RuntimeDir) + '{#DotNetDesktopRuntimeMajor}.*', FindRec) then
  begin
    try
      repeat
        if DirExists(AddBackslash(RuntimeDir) + FindRec.Name) and IsRequiredDotNetDesktopRuntimeVersionName(FindRec.Name) then
        begin
          Log(Format('Found required .NET Desktop Runtime major version %s in runtime directory: %s', ['{#DotNetDesktopRuntimeMajor}', FindRec.Name]));
          Result := True;
          exit;
        end;
      until not FindNext(FindRec);
    finally
      FindClose(FindRec);
    end;
  end;
end;

function IsRequiredDotNetDesktopRuntimeUnderRoot(const RuntimeRoot: string): Boolean;
begin
  Result :=
    (Trim(RuntimeRoot) <> '') and
    IsRequiredDotNetDesktopRuntimeInDirectory(
      AddBackslash(RuntimeRoot) + 'shared\Microsoft.WindowsDesktop.App');
end;

function IsRequiredDotNetDesktopRuntimeInstalled: Boolean;
begin
  Result :=
    IsRequiredDotNetDesktopRuntimeRegisteredAt(
      HKLM64,
      'SOFTWARE\dotnet\Setup\InstalledVersions\x64\sharedfx\Microsoft.WindowsDesktop.App') or
    IsRequiredDotNetDesktopRuntimeRegisteredAt(
      HKLM32,
      'SOFTWARE\dotnet\Setup\InstalledVersions\x64\sharedfx\Microsoft.WindowsDesktop.App') or
    IsRequiredDotNetDesktopRuntimeInDirectory(
      ExpandConstant('{commonpf64}\dotnet\shared\Microsoft.WindowsDesktop.App')) or
    IsRequiredDotNetDesktopRuntimeUnderRoot(GetEnv('DOTNET_ROOT_X64')) or
    IsRequiredDotNetDesktopRuntimeUnderRoot(GetEnv('DOTNET_ROOT'));

  if Result then
    exit;

  Log(Format('Required .NET Desktop Runtime major version %s was not found.', ['{#DotNetDesktopRuntimeMajor}']));
end;

function WriteDotNetDesktopRuntimeInstallerScript: string;
begin
  Result := ExpandConstant('{tmp}\InstallDotNetDesktopRuntime.ps1');
  SaveStringToFile(
    Result,
    '$ErrorActionPreference = ''Stop''' + #13#10 +
    '$runtimeMajor = ''{#DotNetDesktopRuntimeMajor}''' + #13#10 +
    '$runtimeKey = ''HKLM:\SOFTWARE\dotnet\Setup\InstalledVersions\x64\sharedfx\Microsoft.WindowsDesktop.App''' + #13#10 +
    '$wowRuntimeKey = ''HKLM:\SOFTWARE\WOW6432Node\dotnet\Setup\InstalledVersions\x64\sharedfx\Microsoft.WindowsDesktop.App''' + #13#10 +
    'function Test-RuntimeKey($key) {' + #13#10 +
    '    if (-not (Test-Path $key)) { return $false }' + #13#10 +
    '    $item = Get-ItemProperty $key -ErrorAction SilentlyContinue' + #13#10 +
    '    if ($item -and ($item | Get-Member -MemberType NoteProperty | Where-Object { $_.Name -like "$runtimeMajor.*" } | Select-Object -First 1)) { return $true }' + #13#10 +
    '    if (Get-ChildItem $key -ErrorAction SilentlyContinue | Where-Object { Split-Path -Leaf $_.Name -like "$runtimeMajor.*" } | Select-Object -First 1) { return $true }' + #13#10 +
    '    return $false' + #13#10 +
    '}' + #13#10 +
    'foreach ($key in @($runtimeKey, $wowRuntimeKey)) {' + #13#10 +
    '    if (Test-RuntimeKey $key) { exit 0 }' + #13#10 +
    '}' + #13#10 +
    '$runtimeDirs = @()' + #13#10 +
    'if ($env:ProgramFiles) { $runtimeDirs += Join-Path $env:ProgramFiles ''dotnet\shared\Microsoft.WindowsDesktop.App'' }' + #13#10 +
    'foreach ($root in @($env:DOTNET_ROOT_X64, $env:DOTNET_ROOT)) {' + #13#10 +
    '    if ($root) { $runtimeDirs += Join-Path $root ''shared\Microsoft.WindowsDesktop.App'' }' + #13#10 +
    '}' + #13#10 +
    'foreach ($runtimeDir in $runtimeDirs) {' + #13#10 +
    '    if ($runtimeDir -and (Test-Path $runtimeDir) -and (Get-ChildItem $runtimeDir -Directory -ErrorAction SilentlyContinue | Where-Object { $_.Name -like "$runtimeMajor.*" } | Select-Object -First 1)) { exit 0 }' + #13#10 +
    '}' + #13#10 +
    '$installer = Join-Path $env:TEMP "windowsdesktop-runtime-{#DotNetDesktopRuntimeMajor}-win-x64.exe"' + #13#10 +
    '[Net.ServicePointManager]::SecurityProtocol = [Net.SecurityProtocolType]::Tls12' + #13#10 +
    'Invoke-WebRequest -Uri "{#DotNetDesktopRuntimeInstallerUrl}" -OutFile $installer -UseBasicParsing' + #13#10 +
    '$signature = Get-AuthenticodeSignature -FilePath $installer' + #13#10 +
    'if ($signature.Status -ne ''Valid'' -or $signature.SignerCertificate.Subject -notlike ''*Microsoft Corporation*'') { exit 1603 }' + #13#10 +
    '$process = Start-Process -FilePath $installer -ArgumentList "/install", "/quiet", "/norestart" -Wait -PassThru' + #13#10 +
    'exit $process.ExitCode' + #13#10,
    False);
end;

function InstallRequiredDotNetDesktopRuntime(var ResultCode: Integer): Boolean;
var
  InstallerScript: string;
begin
  InstallerScript := WriteDotNetDesktopRuntimeInstallerScript;
  Log(Format('Installing .NET Desktop Runtime %s from official Microsoft sources.', ['{#DotNetDesktopRuntimeMajor}']));
  if IsAdmin then
  begin
    Result :=
      Exec(
        ExpandConstant('{sys}\WindowsPowerShell\v1.0\powershell.exe'),
        '-NoProfile -ExecutionPolicy Bypass -File "' + InstallerScript + '"',
        '',
        SW_HIDE,
        ewWaitUntilTerminated,
        ResultCode);
  end
  else
  begin
    Log('Requesting elevation to install the machine-wide .NET Desktop Runtime.');
    Result :=
      ShellExec(
        'runas',
        ExpandConstant('{sys}\WindowsPowerShell\v1.0\powershell.exe'),
        '-NoProfile -ExecutionPolicy Bypass -File "' + InstallerScript + '"',
        '',
        SW_HIDE,
        ewWaitUntilTerminated,
        ResultCode);
  end;
  if not Result then
    Log('Failed to start PowerShell for .NET Desktop Runtime installation.')
  else
    Log(Format('.NET Desktop Runtime installer command completed with exit code %d.', [ResultCode]));
end;

function EnsureRequiredDotNetDesktopRuntimeInstalled(var NeedsRestart: Boolean): Boolean;
var
  ResultCode: Integer;
begin
  Result := True;
  if IsRequiredDotNetDesktopRuntimeInstalled then
    exit;
  ResultCode := -1;
  if not InstallRequiredDotNetDesktopRuntime(ResultCode) then
  begin
    Result := False;
    exit;
  end;
  DotNetDesktopRuntimeNeedsRestart := ResultCode = 3010;
  if DotNetDesktopRuntimeNeedsRestart then
    NeedsRestart := True;
  Result := (ResultCode = 0) or ((ResultCode = 3010) and IsRequiredDotNetDesktopRuntimeInstalled);
  if not Result then
    Log(Format('.NET Desktop Runtime installation did not complete successfully. Exit code: %d.', [ResultCode]));
end;

function TryGetVoiceAttack2AppsDir(var Dir: string): Boolean;
var
  VAFolder: string;
begin
  Result := False;

  if RegQueryStringValue(
       HKCU,
       'Software\VoiceAttack.com\VoiceAttack2\LastRun',
       'AppsFolder',
       Dir) and (Trim(Dir) <> '') then
  begin
    Dir := RemoveBackslashUnlessRoot(Dir);
    Result := True;
    exit;
  end;

  if RegQueryStringValue(
       HKCU,
       'Software\VoiceAttack.com\VoiceAttack2\LastRun',
       'VAFolder',
       VAFolder) and (Trim(VAFolder) <> '') then
  begin
    Dir := AddBackslash(RemoveBackslashUnlessRoot(VAFolder)) + 'Apps';
    Result := True;
  end;
end;

function TryGetLegacyVoiceAttackAppsDir(var Dir: string): Boolean;
var
  VAFolder: string;
begin
  Result := False;

  if RegQueryStringValue(
       HKCU,
       'Software\VoiceAttack.com\VoiceAttack\LastRun',
       'AppsFolder',
       Dir) and (Trim(Dir) <> '') then
  begin
    Dir := RemoveBackslashUnlessRoot(Dir);
    Result := True;
    exit;
  end;

  if RegQueryStringValue(
       HKCU,
       'Software\VoiceAttack.com\VoiceAttack\LastRun',
       'VAFolder',
       VAFolder) and (Trim(VAFolder) <> '') then
  begin
    Dir := AddBackslash(RemoveBackslashUnlessRoot(VAFolder)) + 'Apps';
    Result := True;
  end;
end;

function NormalizeVoiceAttackAppsDir(const Dir: string): string;
var
  CleanDir: string;
  ParentDir: string;
begin
  CleanDir := RemoveBackslashUnlessRoot(Dir);
  ParentDir := RemoveBackslashUnlessRoot(ExtractFileDir(CleanDir));

  if (Lowercase(ExtractFileName(CleanDir)) = Lowercase('{#MyAppName}')) and
     (Lowercase(ExtractFileName(ParentDir)) = 'apps') then
  begin
    Result := ParentDir;
    exit;
  end;

  Result := CleanDir;
end;

function GetPerUserVoiceAttackAppsDir: string;
begin
  Result := ExpandConstant('{userappdata}\VoiceAttack2\Apps');
end;

function GetSharedVoiceAttackAppsDir: string;
begin
  Result := ExpandConstant('{autopf}\VoiceAttack2\Apps');
end;

function ShouldUseDetectedVoiceAttackAppsDirAsDefault(const Dir: string): Boolean;
begin
  {
    Avoid defaulting to a VoiceAttack Apps folder that does not match the
    selected install mode. Mixed per-user / shared locations are rejected later
    by validation, but defaults should not create that invalid pairing.
  }
  if IsAdminInstallMode then
    Result := not IsUserProfilePath(Dir)
  else
    Result := IsUserProfilePath(Dir);
end;

function GetDefaultVoiceAttackAppsDir: string;
var
  AppsFolder: string;
begin
  if TryGetVoiceAttack2AppsDir(AppsFolder) and ShouldUseDetectedVoiceAttackAppsDirAsDefault(AppsFolder) then
  begin
    Result := RemoveBackslashUnlessRoot(AppsFolder);
    exit;
  end;

  if TryGetLegacyVoiceAttackAppsDir(AppsFolder) and ShouldUseDetectedVoiceAttackAppsDirAsDefault(AppsFolder) then
  begin
    Result := RemoveBackslashUnlessRoot(AppsFolder);
    exit;
  end;

  if IsAdminInstallMode then
    Result := GetSharedVoiceAttackAppsDir
  else
    Result := GetPerUserVoiceAttackAppsDir;
end;

function GetSelectedVoiceAttackAppsDir: string;
begin
  if Trim(SelectedVoiceAttackAppsDir) <> '' then
  begin
    Result := NormalizeVoiceAttackAppsDir(SelectedVoiceAttackAppsDir);
    if (not IsAdminInstallMode) and (not IsUserProfilePath(Result)) then
      Result := GetPerUserVoiceAttackAppsDir;
    exit;
  end;

  Result := GetDefaultVoiceAttackAppsDir;
end;

function GetVoiceAttack2EddiDir(Param: string): string;
begin
  Result := AddBackslash(GetSelectedVoiceAttackAppsDir) + '{#MyAppName}';
end;

function GetDefaultInstallDir(Param: string): string;
begin
  if not IsAdminInstallMode then
  begin
    Result := ExpandConstant('{localappdata}\EDDI\Application');
    exit;
  end;

  Result := ExpandConstant('{autopf}\EDDI');
end;

function GetDefaultApplicationInstallDir: string;
begin
  Result := GetDefaultInstallDir('');
end;

procedure EnsureSelectedVoiceAttackAppsDirMatchesInstallMode;
begin
  if IsAdminInstallMode and
     ((Trim(SelectedVoiceAttackAppsDir) = '') or
      IsUserProfilePath(NormalizeVoiceAttackAppsDir(SelectedVoiceAttackAppsDir))) then
  begin
    SelectedVoiceAttackAppsDir := GetSharedVoiceAttackAppsDir;
  end;

  if (not IsAdminInstallMode) and
     ((Trim(SelectedVoiceAttackAppsDir) = '') or
      (not IsUserProfilePath(NormalizeVoiceAttackAppsDir(SelectedVoiceAttackAppsDir)))) then
  begin
    SelectedVoiceAttackAppsDir := GetPerUserVoiceAttackAppsDir;
  end;
end;

function ShouldWriteMachineLocator: Boolean;
begin
  Result := IsAdminInstallMode and not IsUserProfilePath(ExpandConstant('{app}'));
end;

function ShouldWriteMachineRegistry: Boolean;
begin
  Result := IsAdminInstallMode;
end;

function ShouldWriteCurrentUserRegistry: Boolean;
begin
  Result := not IsAdminInstallMode;
end;

function ShouldModifyCurrentUserAreas: Boolean;
begin
  Result := not IsAdminInstallMode;
end;

function TryGetPreviousEddiInstallDirFromRoot(RootKey: Integer; var Dir: string): Boolean;
begin
  Dir := '';

  Result := RegQueryStringValue(
    RootKey,
    'Software\Microsoft\Windows\CurrentVersion\Uninstall\{830C0324-30D8-423C-B5B4-D7EE8D007A79}_is1',
    'InstallLocation',
    Dir);

  if Result then
  begin
    Dir := RemoveBackslashUnlessRoot(Dir);
    Result := Trim(Dir) <> '';
  end;
end;

function GetPreviousEddiInstallDir: string;
begin
  Result := '';

  if TryGetPreviousEddiInstallDirFromRoot(HKLM, Result) then
    exit;

  TryGetPreviousEddiInstallDirFromRoot(HKCU, Result);
end;

function GetLegacyEddiDir: string;
var
  LegacyAppsDir: string;
begin
  Result := '';

  if TryGetLegacyVoiceAttackAppsDir(LegacyAppsDir) then
    Result := AddBackslash(RemoveBackslashUnlessRoot(LegacyAppsDir)) + '{#MyAppName}';
end;

function IsLegacyVoiceAttackPath(const Dir: string): Boolean;
var
  LegacyAppsDir: string;
  VoiceAttack2AppsDir: string;
begin
  Result := False;

  if not TryGetLegacyVoiceAttackAppsDir(LegacyAppsDir) then
    exit;

  {
    VoiceAttack supports an in-place v1 -> v2 upgrade. In that case both
    registry hives can legitimately point to the same Apps folder. Do not
    block the selected path as legacy when the v1 and v2 Apps folders match.
  }
  if TryGetVoiceAttack2AppsDir(VoiceAttack2AppsDir) and
     SamePath(LegacyAppsDir, VoiceAttack2AppsDir) then
  begin
    Log(Format(
      'VoiceAttack and VoiceAttack 2 are registered to the same Apps folder: "%s".', [LegacyAppsDir]));
    exit;
  end;

  Result := IsUnderPath(Dir, LegacyAppsDir);
end;

function IsVoiceAttack2Path(const Dir: string): Boolean;
var
  VoiceAttack2AppsDir: string;
begin
  Result := TryGetVoiceAttack2AppsDir(VoiceAttack2AppsDir) and
            IsUnderPath(Dir, VoiceAttack2AppsDir);
end;

function IsAnyVoiceAttackAppsPath(const Dir: string): Boolean;
begin
  Result := IsLegacyVoiceAttackPath(Dir) or IsVoiceAttack2Path(Dir);
end;

function IsKnownVoiceAttackAppsDir(const Dir: string): Boolean;
var
  AppsDir: string;
begin
  Result := False;

  if TryGetVoiceAttack2AppsDir(AppsDir) and SamePath(Dir, AppsDir) then
  begin
    Result := True;
    exit;
  end;

  if TryGetLegacyVoiceAttackAppsDir(AppsDir) and SamePath(Dir, AppsDir) then
  begin
    Result := True;
  end;
end;

function LooksLikeVoiceAttackAppsDir(const Dir: string): Boolean;
begin
  Result := Lowercase(ExtractFileName(NormalizeVoiceAttackAppsDir(Dir))) = 'apps';
end;

function ValidateVoiceAttackAppsDir(const AppsDir: string; ShowMessage: Boolean): Boolean;
begin
  Result := True;

  if Trim(AppsDir) = '' then
  begin
    if ShowMessage then
      MsgBox('Select the VoiceAttack Apps folder where the EDDI plugin should be installed.', mbError, MB_OK);
    Result := False;
    exit;
  end;

  if not IsKnownVoiceAttackAppsDir(AppsDir) and not LooksLikeVoiceAttackAppsDir(AppsDir) then
  begin
    if ShowMessage then
      MsgBox(
        'Select the VoiceAttack Apps folder.' + #13#10#13#10 +
        'The EDDI plugin will be installed under an EDDI subfolder inside of the selected Apps folder.',
        mbError, MB_OK);
    Result := False;
  end;
end;

function SelectedLocationsRequireAdmin(const AppDir, AppsDir: string): Boolean;
begin
  Result := (not IsUserProfilePath(AppDir)) or (not IsUserProfilePath(AppsDir));
end;

function ValidateInstallLocations(const AppDir, AppsDir: string; ShowMessage: Boolean): Boolean;
var
  CleanAppDir: string;
  CleanAppsDir: string;
  ShimDir: string;
begin
  Result := True;
  CleanAppDir := RemoveBackslashUnlessRoot(AppDir);
  CleanAppsDir := NormalizeVoiceAttackAppsDir(AppsDir);
  ShimDir := AddBackslash(CleanAppsDir) + '{#MyAppName}';

  if not ValidateVoiceAttackAppsDir(CleanAppsDir, ShowMessage) then
  begin
    Result := False;
    exit;
  end;

  if IsAnyVoiceAttackAppsPath(CleanAppDir) or IsUnderPath(CleanAppDir, CleanAppsDir) then
  begin
    if ShowMessage then
      MsgBox(
        'The installer will install the EDDI VoiceAttack plugin separately.' + #13#10#13#10 +
        'Please select a folder outside of the VoiceAttack Apps folder path.',
        mbError, MB_OK);
    Result := False;
    exit;
  end;

  if IsUnderPath(CleanAppDir, ShimDir) or IsUnderPath(ShimDir, CleanAppDir) then
  begin
    if ShowMessage then
      MsgBox(
        'The installer will install the EDDI VoiceAttack plugin separately.' + #13#10#13#10 +
        'Please select a folder outside the VoiceAttack Apps folder tree.',
        mbError, MB_OK);
    Result := False;
    exit;
  end;

  if (not IsUserProfilePath(ShimDir)) and IsUserProfilePath(CleanAppDir) then
  begin
    if ShowMessage then
      MsgBox(
        'This install mixes a per-user EDDI application folder with a shared VoiceAttack Apps folder.' + #13#10#13#10 +
        'For a single-user install, select your per-user VoiceAttack Apps folder:' + #13#10 +
        ExpandConstant('{userappdata}\VoiceAttack2\Apps') + #13#10#13#10 +
        'For a shared VoiceAttack Apps folder, restart Setup as administrator and install the EDDI application files to a shared folder such as Program Files.',
        mbError, MB_OK);
    Result := False;
    exit;
  end;

  if IsAdminInstallMode and
     (IsUserProfilePath(CleanAppDir) or IsUserProfilePath(CleanAppsDir)) then
  begin
    if ShowMessage then
      MsgBox(
        'The selected locations include a per-user path, but Setup is running in administrative install mode.' + #13#10#13#10 +
        'EDDI application folder:' + #13#10 +
        CleanAppDir + #13#10#13#10 +
        'VoiceAttack Apps folder:' + #13#10 +
        CleanAppsDir + #13#10#13#10 +
        'Restart Setup without elevation or select shared machine-wide locations.',
        mbError, MB_OK);
    Result := False;
    exit;
  end;

  if SelectedLocationsRequireAdmin(CleanAppDir, CleanAppsDir) and not IsAdminInstallMode then
  begin
    if ShowMessage then
      MsgBox(
        'The selected locations are shared or machine-wide and require administrative install mode.' + #13#10#13#10 +
        'Restart Setup as administrator or select per-user locations.',
        mbError, MB_OK);
    Result := False;
  end;
end;

function GetVoiceAttackShimDirForAppsDir(const AppsDir: string): string;
begin
  Result := AddBackslash(NormalizeVoiceAttackAppsDir(AppsDir)) + '{#MyAppName}';
end;

procedure UpdateVoiceAttackPluginDirDisplay;
begin
  if VoiceAttackPluginDirText <> nil then
    VoiceAttackPluginDirText.Caption := GetVoiceAttackShimDirForAppsDir(VoiceAttackAppsDirEdit.Text);
end;

procedure VoiceAttackAppsDirEditChange(Sender: TObject);
begin
  UpdateVoiceAttackPluginDirDisplay;
end;

procedure VoiceAttackAppsBrowseButtonClick(Sender: TObject);
var
  Dir: string;
begin
  Dir := VoiceAttackAppsDirEdit.Text;
  if BrowseForFolder('Select your VoiceAttack Apps folder.', Dir, True) then
  begin
    VoiceAttackAppsDirEdit.Text := NormalizeVoiceAttackAppsDir(Dir);
    UpdateVoiceAttackPluginDirDisplay;
  end;
end;

procedure InitializeWizard;
var
  LabelTop: Integer;
  AppDirLabel: TNewStaticText;
  AppsDirLabel: TNewStaticText;
  PluginDirLabel: TNewStaticText;
begin
  SelectedVoiceAttackAppsDir := GetDefaultVoiceAttackAppsDir;
  EnsureSelectedVoiceAttackAppsDirMatchesInstallMode;
  if not IsAdminInstallMode then
    WizardForm.DirEdit.Text := GetDefaultApplicationInstallDir;

  VoiceAttackAppsPage := CreateCustomPage(
    wpSelectDir,
    'VoiceAttack Plugin Location',
    'Choose where EDDI installs its VoiceAttack plugin.');

  LabelTop := 0;

  AppDirLabel := TNewStaticText.Create(VoiceAttackAppsPage);
  AppDirLabel.Parent := VoiceAttackAppsPage.Surface;
  AppDirLabel.Left := 0;
  AppDirLabel.Top := LabelTop;
  AppDirLabel.Width := VoiceAttackAppsPage.SurfaceWidth;
  AppDirLabel.Caption := 'EDDI application folder:';

  ApplicationDirText := TNewStaticText.Create(VoiceAttackAppsPage);
  ApplicationDirText.Parent := VoiceAttackAppsPage.Surface;
  ApplicationDirText.Left := 0;
  ApplicationDirText.Top := AppDirLabel.Top + AppDirLabel.Height + ScaleY(4);
  ApplicationDirText.Width := VoiceAttackAppsPage.SurfaceWidth;
  ApplicationDirText.Height := ScaleY(24);
  ApplicationDirText.AutoSize := False;

  AppsDirLabel := TNewStaticText.Create(VoiceAttackAppsPage);
  AppsDirLabel.Parent := VoiceAttackAppsPage.Surface;
  AppsDirLabel.Left := 0;
  AppsDirLabel.Top := ApplicationDirText.Top + ApplicationDirText.Height + ScaleY(16);
  AppsDirLabel.Width := VoiceAttackAppsPage.SurfaceWidth;
  AppsDirLabel.Caption := 'VoiceAttack Apps folder:';

  VoiceAttackAppsDirEdit := TNewEdit.Create(VoiceAttackAppsPage);
  VoiceAttackAppsDirEdit.Parent := VoiceAttackAppsPage.Surface;
  VoiceAttackAppsDirEdit.Left := 0;
  VoiceAttackAppsDirEdit.Top := AppsDirLabel.Top + AppsDirLabel.Height + ScaleY(4);
  VoiceAttackAppsDirEdit.Width := VoiceAttackAppsPage.SurfaceWidth - ScaleX(84);
  VoiceAttackAppsDirEdit.Text := SelectedVoiceAttackAppsDir;
  VoiceAttackAppsDirEdit.OnChange := @VoiceAttackAppsDirEditChange;

  VoiceAttackAppsBrowseButton := TNewButton.Create(VoiceAttackAppsPage);
  VoiceAttackAppsBrowseButton.Parent := VoiceAttackAppsPage.Surface;
  VoiceAttackAppsBrowseButton.Left := VoiceAttackAppsDirEdit.Left + VoiceAttackAppsDirEdit.Width + ScaleX(8);
  VoiceAttackAppsBrowseButton.Top := VoiceAttackAppsDirEdit.Top - ScaleY(1);
  VoiceAttackAppsBrowseButton.Width := ScaleX(76);
  VoiceAttackAppsBrowseButton.Height := VoiceAttackAppsDirEdit.Height + ScaleY(2);
  VoiceAttackAppsBrowseButton.Caption := 'Browse...';
  VoiceAttackAppsBrowseButton.OnClick := @VoiceAttackAppsBrowseButtonClick;

  PluginDirLabel := TNewStaticText.Create(VoiceAttackAppsPage);
  PluginDirLabel.Parent := VoiceAttackAppsPage.Surface;
  PluginDirLabel.Left := 0;
  PluginDirLabel.Top := VoiceAttackAppsDirEdit.Top + VoiceAttackAppsDirEdit.Height + ScaleY(16);
  PluginDirLabel.Width := VoiceAttackAppsPage.SurfaceWidth;
  PluginDirLabel.Caption := 'EDDI VoiceAttack plugin folder (for reference):';

  VoiceAttackPluginDirText := TNewStaticText.Create(VoiceAttackAppsPage);
  VoiceAttackPluginDirText.Parent := VoiceAttackAppsPage.Surface;
  VoiceAttackPluginDirText.Left := 0;
  VoiceAttackPluginDirText.Top := PluginDirLabel.Top + PluginDirLabel.Height + ScaleY(4);
  VoiceAttackPluginDirText.Width := VoiceAttackAppsPage.SurfaceWidth;
  VoiceAttackPluginDirText.Height := ScaleY(24);
  VoiceAttackPluginDirText.AutoSize := False;

  UpdateVoiceAttackPluginDirDisplay;
end;

procedure CurPageChanged(CurPageID: Integer);
begin
  if CurPageID = VoiceAttackAppsPage.ID then
  begin
    EnsureSelectedVoiceAttackAppsDirMatchesInstallMode;
    if not IsAdminInstallMode then
      WizardForm.DirEdit.Text := GetDefaultApplicationInstallDir;
    ApplicationDirText.Caption := RemoveBackslashUnlessRoot(WizardDirValue);
    VoiceAttackAppsDirEdit.Text := GetSelectedVoiceAttackAppsDir;
    UpdateVoiceAttackPluginDirDisplay;
  end;
end;

function ShouldSkipPage(PageID: Integer): Boolean;
begin
  Result := (PageID = wpSelectDir) and not IsAdminInstallMode;
end;

function AppendReadyMemoSection(
  const ExistingMemo: string;
  const Section: string;
  const NewLine: string): string;
begin
  Result := ExistingMemo;
  if Trim(Section) = '' then
    exit;

  if Result <> '' then
    Result := Result + NewLine + NewLine;

  Result := Result + Section;
end;

function UpdateReadyMemo(
  Space: string;
  NewLine: string;
  MemoUserInfoInfo: string;
  MemoDirInfo: string;
  MemoTypeInfo: string;
  MemoComponentsInfo: string;
  MemoGroupInfo: string;
  MemoTasksInfo: string): string;
var
  PluginDirInfo: string;
begin
  EnsureSelectedVoiceAttackAppsDirMatchesInstallMode;

  PluginDirInfo :=
    Space + 'EDDI VoiceAttack plugin folder:' + NewLine +
    Space + Space + GetVoiceAttack2EddiDir('');

  Result := '';
  Result := AppendReadyMemoSection(Result, MemoUserInfoInfo, NewLine);
  Result := AppendReadyMemoSection(Result, MemoDirInfo, NewLine);
  Result := AppendReadyMemoSection(Result, PluginDirInfo, NewLine);
  Result := AppendReadyMemoSection(Result, MemoTypeInfo, NewLine);
  Result := AppendReadyMemoSection(Result, MemoComponentsInfo, NewLine);
  Result := AppendReadyMemoSection(Result, MemoGroupInfo, NewLine);
  Result := AppendReadyMemoSection(Result, MemoTasksInfo, NewLine);
end;

function IsInAppUpgrade: Boolean;
begin
  Result := ExpandConstant('{param:EDDIInAppUpgrade|0}') = '1';
end;

function ShouldRunAfterInAppUpgrade: Boolean;
begin
  Result := (IsInAppUpgrade or LegacySilentMigration) and not DotNetDesktopRuntimeNeedsRestart;
end;

procedure RegisterCloseResource(const Dir: string);
var
  ExePath: string;
begin
  if Trim(Dir) = '' then
    exit;

  ExePath := AddBackslash(RemoveBackslashUnlessRoot(Dir)) + '{#MyAppExeName}';

  if FileExists(ExePath) then
    RegisterExtraCloseApplicationsResource(False, ExePath);
end;

procedure RegisterExtraCloseApplicationsResources;
var
  Dir: string;
begin
  RegisterCloseResource(GetLegacyEddiDir);

  if TryGetPreviousEddiInstallDirFromRoot(HKLM, Dir) then
    RegisterCloseResource(Dir);

  if TryGetPreviousEddiInstallDirFromRoot(HKCU, Dir) then
    RegisterCloseResource(Dir);
end;

procedure RecordCleanupFailure(const Details: string);
begin
  Log(Details);
  { Show the first failure to keep the dialog readable; log every failure. }
  if CleanupFailureDetails = '' then
    CleanupFailureDetails := Details;
end;

function RemoveStaleUninstallEntryIfMatches(RootKey: Integer; const RemovedDir: string): Boolean;
var
  ExistingInstallLocation: string;
  UninstallSubkey: string;
  RootName: string;
begin
  Result := True;
  UninstallSubkey := 'Software\Microsoft\Windows\CurrentVersion\Uninstall\{830C0324-30D8-423C-B5B4-D7EE8D007A79}_is1';

  if RegQueryStringValue(RootKey, UninstallSubkey, 'InstallLocation', ExistingInstallLocation) and
     SamePath(ExistingInstallLocation, RemovedDir) then
  begin
    Log(Format('Removing stale EDDI uninstall entry for removed install at "%s".', [RemovedDir]));
    Result := RegDeleteKeyIncludingSubkeys(RootKey, UninstallSubkey);
    if not Result then
    begin
      if RootKey = HKLM then
        RootName := 'HKEY_LOCAL_MACHINE'
      else
        RootName := 'HKEY_CURRENT_USER';
      RecordCleanupFailure(
        'Could not remove the old EDDI uninstall registry entry:' + #13#10 +
        RootName + '\' + UninstallSubkey + #13#10#13#10 +
        'Previous installation folder: ' + RemovedDir + #13#10#13#10 +
        'Check that your account has permission to modify this registry entry, then run Setup again. ' +
        'Administrator assistance may be required.');
    end;
  end;
end;

function RemoveStaleUninstallEntriesIfMatches(const RemovedDir: string): Boolean;
begin
  Result := True;

  if not RemoveStaleUninstallEntryIfMatches(HKLM, RemovedDir) then
    Result := False;

  if not RemoveStaleUninstallEntryIfMatches(HKCU, RemovedDir) then
    Result := False;
end;

function RemoveDirIfOldEddiInstall(const Dir: string): Boolean;
var
  CleanDir: string;
begin
  Result := True;

  if Trim(Dir) = '' then
    exit;

  CleanDir := RemoveBackslashUnlessRoot(Dir);

  if not DirExists(CleanDir) then
    exit;

  if SamePath(CleanDir, ExpandConstant('{app}')) then
    exit;

  if FileExists(AddBackslash(CleanDir) + '{#MyAppExeName}') then
  begin
    Log(Format('Removing old EDDI install at "%s".', [CleanDir]));
    Result := DelTree(CleanDir, True, True, True);
    if Result then
      Result := RemoveStaleUninstallEntriesIfMatches(CleanDir)
    else
      RecordCleanupFailure(
        'Could not remove the old EDDI application folder:' + #13#10 +
        CleanDir + #13#10#13#10 +
        'Close EDDI and VoiceAttack, including any background processes shown in Task Manager, then run Setup again. ' +
        'If this still fails, check that your account has permission to modify this folder.');
  end;
end;

function RemoveOldEddiInstalls: Boolean;
var
  PreviousDir: string;
begin
  Result := RemoveDirIfOldEddiInstall(GetLegacyEddiDir);

  if TryGetPreviousEddiInstallDirFromRoot(HKLM, PreviousDir) then
  begin
    if not RemoveDirIfOldEddiInstall(PreviousDir) then
      Result := False;
  end;

  if TryGetPreviousEddiInstallDirFromRoot(HKCU, PreviousDir) then
  begin
    if not RemoveDirIfOldEddiInstall(PreviousDir) then
      Result := False;
  end;
end;

function RemoveOldVoiceAttackPluginDir(const ShimDir: string): Boolean;
var
  CleanDir: string;
begin
  Result := True;

  if Trim(ShimDir) = '' then
    exit;

  CleanDir := RemoveBackslashUnlessRoot(ShimDir);

  if not DirExists(CleanDir) then
    exit;

  if SamePath(CleanDir, ExpandConstant('{app}')) then
    exit;

  Log(Format('Removing old EDDI VoiceAttack plugin folder at "%s".', [CleanDir]));
  Result := DelTree(CleanDir, True, True, True);
  if not Result then
    RecordCleanupFailure(
      'Could not remove the old EDDI VoiceAttack plugin folder:' + #13#10 +
      CleanDir + #13#10#13#10 +
      'Close VoiceAttack and EDDI, including any background processes shown in Task Manager, then run Setup again. ' +
      'If this still fails, check that your account has permission to modify this folder.');
end;

function RemoveKnownVoiceAttackPluginDirs: Boolean;
var
  AppsDir: string;
begin
  Result := True;

  if not RemoveOldVoiceAttackPluginDir(GetVoiceAttack2EddiDir('')) then
    Result := False;

  if TryGetVoiceAttack2AppsDir(AppsDir) then
  begin
    if not RemoveOldVoiceAttackPluginDir(GetVoiceAttackShimDirForAppsDir(AppsDir)) then
      Result := False;
  end;

  if TryGetLegacyVoiceAttackAppsDir(AppsDir) then
  begin
    if not RemoveOldVoiceAttackPluginDir(GetVoiceAttackShimDirForAppsDir(AppsDir)) then
      Result := False;
  end;

  if not RemoveOldVoiceAttackPluginDir(GetVoiceAttackShimDirForAppsDir(GetPerUserVoiceAttackAppsDir)) then
    Result := False;
end;

procedure WriteVoiceAttackShimMarker;
var
  ShimDir: string;
begin
  ShimDir := GetVoiceAttack2EddiDir('');
  ForceDirectories(ShimDir);
  SaveStringToFile(
    AddBackslash(RemoveBackslashUnlessRoot(ShimDir)) + 'eddi_app_path.txt',
    ExpandConstant('{app}\{#MyAppExeName}'),
    False);
end;

procedure DeleteShimFileIfExists(const FileName: string);
begin
  if FileExists(FileName) then
  begin
    DeleteFile(FileName);
  end;
end;

procedure RemoveVoiceAttackShimFiles;
var
  ShimDir: string;
begin
  ShimDir := AddBackslash(RemoveBackslashUnlessRoot(GetVoiceAttack2EddiDir('')));

  DeleteShimFileIfExists(ShimDir + 'EddiVoiceAttackAdapter.dll');
  DeleteShimFileIfExists(ShimDir + 'EddiVoiceAttackAdapter.pdb');
  DeleteShimFileIfExists(ShimDir + 'EddiVoiceAttackAdapter.deps.json');
  DeleteShimFileIfExists(ShimDir + 'EddiVoiceAttackAdapter.runtimeconfig.json');
  DeleteShimFileIfExists(ShimDir + 'EDDI.vap');
  DeleteShimFileIfExists(ShimDir + 'eddi_app_path.txt');
  RemoveDir(ShimDir);
end;

procedure RemoveLocatorIfMatches(RootKey: Integer);
var
  ExistingExecutablePath: string;
  ExpectedExecutablePath: string;
begin
  ExpectedExecutablePath := ExpandConstant('{app}\{#MyAppExeName}');
  if RegQueryStringValue(
       RootKey,
       'Software\EDCD\EDDI',
       'ExecutablePath',
       ExistingExecutablePath) and
     SamePath(ExistingExecutablePath, ExpectedExecutablePath) then
  begin
    RegDeleteValue(RootKey, 'Software\EDCD\EDDI', 'ExecutablePath');
    RegDeleteValue(RootKey, 'Software\EDCD\EDDI', 'InstallDirectory');
    RegDeleteValue(RootKey, 'Software\EDCD\EDDI', 'Version');
    RegDeleteKeyIfEmpty(RootKey, 'Software\EDCD\EDDI');
    RegDeleteKeyIfEmpty(RootKey, 'Software\EDCD');
  end;
end;

function NextButtonClick(CurPageID: Integer): Boolean;
var
  ChosenDir: string;
  TargetDir: string;
begin
  Result := True;
  EnsureSelectedVoiceAttackAppsDirMatchesInstallMode;

  if CurPageID = wpSelectDir then
  begin
    ChosenDir := RemoveBackslashUnlessRoot(WizardDirValue);

    if not ValidateInstallLocations(ChosenDir, GetSelectedVoiceAttackAppsDir, False) then
    begin
      if WizardSilent then
      begin
        TargetDir := GetDefaultApplicationInstallDir;

        Log(Format('Silent invalid application directory detected. Replacing selected application directory "%s" with "%s".', [ChosenDir, TargetDir]));

        WizardForm.DirEdit.Text := TargetDir;
        if IsAnyVoiceAttackAppsPath(ChosenDir) then
          LegacySilentMigration := True;
        Result := True;
        exit;
      end;

      Result := ValidateInstallLocations(ChosenDir, GetSelectedVoiceAttackAppsDir, True);
      exit;
    end;
  end;

  if CurPageID = VoiceAttackAppsPage.ID then
  begin
    SelectedVoiceAttackAppsDir := NormalizeVoiceAttackAppsDir(VoiceAttackAppsDirEdit.Text);
    VoiceAttackAppsDirEdit.Text := SelectedVoiceAttackAppsDir;
    UpdateVoiceAttackPluginDirDisplay;
    Result := ValidateInstallLocations(WizardDirValue, SelectedVoiceAttackAppsDir, True);
  end;
end;

function PrepareToInstall(var NeedsRestart: Boolean): string;
var
  AppDir: string;
  AppsDir: string;
begin
  Result := '';
  EnsureSelectedVoiceAttackAppsDirMatchesInstallMode;
  if not IsAdminInstallMode then
    WizardForm.DirEdit.Text := GetDefaultApplicationInstallDir;

  AppDir := RemoveBackslashUnlessRoot(WizardDirValue);
  AppsDir := GetSelectedVoiceAttackAppsDir;

  if not ValidateInstallLocations(AppDir, AppsDir, False) then
  begin
    Result :=
      'The selected EDDI application and VoiceAttack plugin locations are not valid for this install mode. ' +
      'Run Setup as administrator for shared machine-wide locations, or choose per-user locations.';
    exit;
  end;
  if not EnsureRequiredDotNetDesktopRuntimeInstalled(NeedsRestart) then
  begin
    Result :=
      'Setup could not install the required .NET Desktop Runtime {#DotNetDesktopRuntimeMajor}. ' +
      'Install it from Microsoft, then run Setup again: {#DotNetDesktopRuntimeInstallerUrl}';
  end;
end;

procedure CurStepChanged(CurStep: TSetupStep);
var
  RemovedOldEddiInstalls: Boolean;
  RemovedVoiceAttackPlugins: Boolean;
begin
  if CurStep = ssInstall then
  begin
    CleanupFailureDetails := '';
    RemovedOldEddiInstalls := RemoveOldEddiInstalls;
    RemovedVoiceAttackPlugins := RemoveKnownVoiceAttackPluginDirs;

    if not (RemovedOldEddiInstalls and RemovedVoiceAttackPlugins) then
    begin
      MsgBox(
        'Setup cannot continue because cleanup of a previous EDDI installation failed.' + #13#10#13#10 +
        CleanupFailureDetails,
        mbCriticalError, MB_OK);
      Abort;
    end;
  end;

  if CurStep = ssPostInstall then
  begin
    WriteVoiceAttackShimMarker;
  end;
end;

procedure CurUninstallStepChanged(CurUninstallStep: TUninstallStep);
begin
  if CurUninstallStep = usUninstall then
  begin
    RemoveVoiceAttackShimFiles;
    RemoveLocatorIfMatches(HKCU);
    RemoveLocatorIfMatches(HKLM);
  end;
end;