using ModpackUpdater.Apps.Manager.Api.Model;

namespace ModpackUpdater.Apps.Manager.Features.Workspaces.LocalFolder;

internal class LocalFolderWorkspace(LocalFolderWorkspaceConfig config) : IWorkspace
{
    private string? rawInstallInfos;
    private string? rawUpdateInfos;

    public WorkspaceConfig Config => ConfigX;
    public LocalFolderWorkspaceConfig ConfigX { get; } = config;
    public ModpackConfig? ModpackConfig { get; private set; }
    public InstallInfos? InstallInfos { get; private set; }
    public UpdateInfos? UpdateInfos { get; private set; }

    public async Task<bool> Load()
    {
        if (!string.IsNullOrWhiteSpace(Config.ModpackConfigUrl))
            ModpackConfig = ModpackConfig.LoadFromUrl(Config.ModpackConfigUrl);

        rawInstallInfos = await GetContent(ConfigX.FileLocationInstallJson);
        InstallInfos = InstallInfos.Parse(rawInstallInfos);

        rawUpdateInfos = await GetContent(ConfigX.FileLocationUpdateJson);
        UpdateInfos = UpdateInfos.Parse(rawUpdateInfos);

        ConfigX.FolderName = Path.GetFileName(ConfigX.RootFolderPath);

        return InstallInfos != null && UpdateInfos != null;
    }

    public async Task<bool> Save()
    {
        var failed = false;
        
        if (InstallInfos != null)
        {
            var newInstallInfos = InstallInfos.ToString();
            if (newInstallInfos != rawInstallInfos)
            {
                if (await SaveContent(ConfigX.FileLocationInstallJson, newInstallInfos))
                    rawInstallInfos = newInstallInfos;
                else
                    failed = true;
            }
        }

        if (UpdateInfos != null)
        {
            var newUpdateInfos = UpdateInfos.ToString();
            if (newUpdateInfos != rawUpdateInfos)
            {
                if (await SaveContent(ConfigX.FileLocationUpdateJson, newUpdateInfos))
                    rawUpdateInfos = newUpdateInfos;
                else
                    failed = true;
            }
        }

        return !failed;
    }

    private async Task<string?> GetContent(string path)
    {
        if (ConfigX.RootFolderPath == null)
            return null;
        
        var filePath = Path.Combine(ConfigX.RootFolderPath!, path);
        return File.Exists(filePath) ? await File.ReadAllTextAsync(filePath) : null;
    }

    private async Task<bool> SaveContent(string path, string content)
    {
        if (ConfigX.RootFolderPath == null)
            return false;
        
        var filePath = Path.Combine(ConfigX.RootFolderPath!, path);
        if (!File.Exists(filePath))
            return false;
        
        await File.WriteAllTextAsync(filePath, content);
        return true;
    }
}