PaintPower_Engine.cs

using Avalonia.Controls;
using Avalonia.Interactivity;
using Avalonia.Platform.Storage;
using PaintPower.Dialogs;
using PaintPower.Editors;
using PaintPower.FileExplorer;
using PaintPower.Logging;
using PaintPower.Networking;
using PaintPower.ProjectSystem;
using PaintPower.SpriteEditor;
using PaintPower.Time;
using System;
using System.Diagnostics;
using System.IO;
using System.Threading;
using System.Threading.Tasks;
using PaintPower.Accessibility.Translation;
using System.Reflection;
namespace PaintPower;

public class PaintPower_Engine
{
    public static readonly string versionNumber = "1.0.1.0";
    public static readonly string buildTime = new Date().getBuildTimestamp();
    public static readonly string devStatus = "Pre-Alpha";
    public static string MajorVersion = $"{Translator.Map(devStatus)} {versionNumber}";
    public static string version = $"{Translator.Map("Version")}: {MajorVersion} {Translator.Map("build")} {buildTime}";

    public void translateVersion()
    {
        MajorVersion = $"{Translator.Map("Pre-Alpha")} 1.0.1.0";
        version = $"{Translator.Map("Version")}: {MajorVersion} {Translator.Map("build")} {buildTime}";
    }

    private Editor _editorManager;
    private PaintProject _project;
    private EditorBase _editor;
    public Server server;

    public bool isNewProject = true;

    private SpriteEditorView _spriteEditorView;

    public bool saveNeeded = false;

    public static PaintPower_Engine App { get; private set; }
    public static MainWindow window;

    public PaintPower_Engine()
    {
        _project = new PaintProject();
        _editorManager = new Editor(_project.Workspace);
        server = new Server();

        Log.QuickLog(version);

        // After, make a static reference.
        App = this;
    }

    public void setupTranslation()
    {
                // Set-up translation
        Translator.load(null);

        var langs = Translator.GetAvailableLanguages();

        foreach (var pair in langs)
        {
            string fullName = pair.Key;
            string code = pair.Value;

            var item = new MenuItem { Header = fullName };
            item.Click += (_, __) =>
            {
                Translator.load(code);
            };

            window.LanguageDropdown.Items.Add(item);
        }
    }

    public void attachWindow(MainWindow w)
    {
        window = w;
    }

    public void StatusClicked(object sender, EventArgs e)
    {
        if (_project != null && saveNeeded)
        {
            Save();
        }
    }

    public string SetProjectStatus(string status)
    {
        window.ProjectStatus.Text = status;
        window.InvalidateVisual();
        return status;
    }

    private void OnSpriteSelected(PaintSprite sprite)
    {
        // Create the sprite editor panel
        _spriteEditorView = new SpriteEditorView(sprite, _project.Workspace);

        // Replace the center panel with the sprite editor
        window.CenterHost.Content = _spriteEditorView;

        SetProjectStatus($"{Translator.Translate("Editing Sprite:")} {sprite.Name}");
    }

    public void OpenProjectFile()
    {
        var openPicker = window.StorageProvider.OpenFilePickerAsync(new FilePickerOpenOptions
        {
            Title = Translator.Map("Open PaintPower Project"),
            AllowMultiple = false,
            FileTypeFilter = new[] { new FilePickerFileType(Translator.Map("PaintPower Project")) { Patterns = new[] { "*.xPaint" } } }
        }).ContinueWith(async t =>
        {
            var result = await t;
            if (result.Count > 0)
            {
                string path = result[0].Path.LocalPath;
                _project.Load(path);
                _project.ProjectPath = path;
                window.Title = $"{Translator.Map("PaintPower")} - {_project.Metadata.name}";
            }
        });
    }

    public async void newProject()
    {
        if (saveNeeded)
        {
            var dialog = new SaveBeforeContinueDialog();
            var result = await dialog.ShowAsync(MainWindow.window);

            switch (result)
            {
                case "save":
                    await Save();
                    break;

                case "saveas":
                    SaveAs();
                    break;

                case "dontsave":
                    break; // continue without saving

                case null:
                    return; // cancel new project
            }
        }

        // Reset everything
        _project = new PaintProject();
        _editorManager = new Editor(_project.Workspace);
        server = new Server();

        Start();
    }

    public async void Start()
    {

        await Task.Yield();

        CloseEditor();

        _project.CreateNew();

        window.Title = $"{Translator.Map("PaintPower")} - {_project.Metadata.name}";

        SetProjectStatus(Translator.Translate("Not edited yet."));

        window.SpriteManager.Initialize(_project);
        window.SpriteManager.SpriteSelected += OnSpriteSelected;

        // Set up translation
        setupTranslation();
    }

    /*public void OpenEditor(EditorBase editor)
    {
        _editor = editor;
        CenterHost.Content = editor;
    }*/

    public void OpenFile(string path)
    {
        var editor = _editorManager.GetEditorFromFileType(path);

        if (_spriteEditorView != null)
            _spriteEditorView.OpenEditor(editor, path);
    }

    public void CloseEditor()
    {
        window.CenterHost.Content = null;
        _editor = null;
    }

    public bool _isSavingAnimationRunning = false;
    public bool _isUploadAnimationRunning = false;

    public async Task RunSavingAnimation()
    {
        _isSavingAnimationRunning = true;

        string[] frames = new[]
        {
        "Saving Project",
        "Saving Project.",
        "Saving Project..",
        "Saving Project..."
    };

        int index = 0;

        while (_isSavingAnimationRunning)
        {
            SetProjectStatus(Translator.Map(frames[index]));
            index = (index + 1) % frames.Length;
            await Task.Delay(300); // smooth animation
        }
    }

    // Save function. Don't even care about what it returns, but C#
    // Requires it to be a Task in order to await it. C# core.
    async public Task Save()
    {
        if (!saveNeeded && !isNewProject) return;

        try
        {
            var dialog = new DoSaveWindowDialog();
            var result = await dialog.ShowAsync(window);

            if (result == "saveas")
            {
                SaveAs();
                return;
            }

            if (result != "save")
            {
                Log.QuickLog($"Not saving. {result}");
                return;
            }

            // If no path yet -> ask user where to save
            if (string.IsNullOrWhiteSpace(_project.ProjectPath) || isNewProject)
            {
                isNewProject = true; // Keep isNewProject checks

                var res = await _project.SaveNewProject(MainWindow.window);

                if (string.IsNullOrWhiteSpace(res.Path))
                    return; // user cancelled

                _project.ProjectPath = res.Path;
                isNewProject = false;
            }

            Log.QuickLog("Saving Project...");

            // Start animation (non-blocking)
            var animationTask = RunSavingAnimation();

            // Run save off UI thread
            await ProjectSaver.Save(_project, _editor);

            // Stop animation
            _isSavingAnimationRunning = false;
            await animationTask; // wait for animation loop to exit

            // Final status
            Log.QuickLog(SetProjectStatus(Translator.Map("Project Saved!")));
        }
        catch (Exception ex)
        {
            Log.QuickLog($"Error while saving project! {ex}");
        }
    }

    async public void SaveAs()
    {
        var savePicker = await window.StorageProvider.SaveFilePickerAsync(new FilePickerSaveOptions
        {
            Title = $"Save {_project.Metadata.name} As",
            DefaultExtension = "xPaint",
            SuggestedFileName = $"{_project.Metadata.name}.xPaint",
            ShowOverwritePrompt = true
        });

        if (savePicker == null)
            return;

        string newPath = savePicker.Path.LocalPath;

        // Update project path
        _project.ProjectPath = newPath;

        try
        {
            // Start animation
            var animationTask = RunSavingAnimation();

            // Run save off UI thread

            await ProjectSaver.Save(_project, _editor);

            // Stop animation
            _isSavingAnimationRunning = false;
            await animationTask;

            // Update metadata + UI
            _project.Metadata.name = Path.GetFileNameWithoutExtension(newPath);
            window.Title = $"PaintPower - {_project.Metadata.name}";
            SetProjectStatus("Project Saved!");
            Log.QuickLog($"Project saved as {newPath}");
        }
        catch (Exception ex)
        {
            Log.QuickLog($"SaveAs failed: {ex}");
        }
    }

    public async void SaveToServer()
    {
        var doSave = false;
        if (!doSave) return;
        SetProjectStatus("Uploading Project to Server...");
        window.InvalidateVisual();
        ProjectSaver.PublishToServer(_project, _editor, server);
        SetProjectStatus("");
    }
}