using System;

using System.Collections.Generic;

using System.Diagnostics;

using System.IO;

using System.Runtime.Versioning;

using Avalonia;

using Avalonia.Controls;

using Avalonia.Platform;

namespace SourceGit.Native

{

[SupportedOSPlatform("linux")]

internal class Linux : OS.IBackend

{

public void SetupApp(AppBuilder builder)

{

builder.With(new X11PlatformOptions() { EnableIme = true });

}

public void SetupWindow(Window window)

{

if (OS.UseSystemWindowFrame)

{

window.ExtendClientAreaChromeHints = ExtendClientAreaChromeHints.Default;

window.ExtendClientAreaToDecorationsHint = false;

}

else

{

window.ExtendClientAreaChromeHints = ExtendClientAreaChromeHints.NoChrome;

window.ExtendClientAreaToDecorationsHint = true;

window.Classes.Add("custom_window_frame");

}

}

public void HideSelf()

{

// Do Nothing. Never used.

}

public void HideOtherApplications()

{

// Do Nothing. Never used.

}

public void ShowAllApplications()

{

// Do Nothing. Never used.

}

public string GetDataDir()

{

// AppImage supports portable mode

var appImage = Environment.GetEnvironmentVariable("APPIMAGE");

if (!string.IsNullOrEmpty(appImage) && File.Exists(appImage))

{

var portableDir = Path.Combine(Path.GetDirectoryName(appImage)!, "data");

if (Directory.Exists(portableDir))

return portableDir;

}

// Runtime data dir: ~/.sourcegit

var home = Environment.GetFolderPath(Environment.SpecialFolder.UserProfile);

var dataDir = Path.Combine(home, ".sourcegit");

if (Directory.Exists(dataDir))

return dataDir;

// Migrate old data: ~/.config/SourceGit

var oldDataDir = Path.Combine(home, ".config", "SourceGit");

if (Directory.Exists(oldDataDir))

{

try

{

Directory.Move(oldDataDir, dataDir);

}

catch

{

// Ignore errors

}

}

return dataDir;

}

public string FindGitExecutable()

{

return FindExecutable("git");

}

public string FindTerminal(Models.ShellOrTerminal shell)

{

if (shell.Type.Equals("custom", StringComparison.Ordinal))

return string.Empty;

return FindExecutable(shell.Exec);

}

public List<Models.ExternalTool> FindExternalTools()

{

var localAppDataDir = Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData);

var finder = new Models.ExternalToolsFinder();

finder.VSCode(() => FindExecutable("code"));

finder.VSCodeInsiders(() => FindExecutable("code-insiders"));

finder.VSCodium(() => FindExecutable("codium"));

finder.Cursor(() => FindExecutable("cursor"));

finder.FindJetBrainsFromToolbox(() => Path.Combine(localAppDataDir, "JetBrains/Toolbox"));

finder.SublimeText(() => FindExecutable("subl"));

finder.Zed(() =>

{

var exec = FindExecutable("zeditor");

return string.IsNullOrEmpty(exec) ? FindExecutable("zed") : exec;

});

return finder.Tools;

}

public void OpenBrowser(string url)

{

var browser = Environment.GetEnvironmentVariable("BROWSER");

if (string.IsNullOrEmpty(browser))

browser = "xdg-open";

Process.Start(browser, url.Quoted());

}

public void OpenInFileManager(string path)

{

if (Directory.Exists(path))

{

Process.Start("xdg-open", path.Quoted());

}

else

{

var dir = Path.GetDirectoryName(path);

if (Directory.Exists(dir))

Process.Start("xdg-open", dir.Quoted());

}

}

public void OpenTerminal(string workdir, string args)

{

var home = Environment.GetFolderPath(Environment.SpecialFolder.UserProfile);

var cwd = string.IsNullOrEmpty(workdir) ? home : workdir;

var startInfo = new ProcessStartInfo();

startInfo.WorkingDirectory = cwd;

startInfo.FileName = OS.ShellOrTerminal;

startInfo.Arguments = args;

try

{

Process.Start(startInfo);

}

catch (Exception e)

{

Models.Notification.Send(workdir, $"Failed to start '{OS.ShellOrTerminal}'. Reason: {e.Message}", true);

}

}

public void OpenWithDefaultEditor(string file)

{

var proc = Process.Start("xdg-open", file.Quoted());

if (proc != null)

{

proc.WaitForExit();

if (proc.ExitCode != 0)

Models.Notification.Send("", $"Failed to open: {file}", true);

proc.Close();

}

}

private string FindExecutable(string filename)

{

var pathVariable = Environment.GetEnvironmentVariable("PATH") ?? string.Empty;

var paths = pathVariable.Split(Path.PathSeparator, StringSplitOptions.RemoveEmptyEntries);

foreach (var path in paths)

{

var test = Path.Combine(path, filename);

if (File.Exists(test))

return test;

}

var local = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.UserProfile), ".local", "bin", filename);

return File.Exists(local) ? local : string.Empty;

}

}

}