using ModpackUpdater.Apps.Manager.Api.Model;
using NGitLab;
using NGitLab.Models;

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

internal class GitLabRepoWorkspace(GitLabRepoWorkspaceConfig config) : IWorkspace
{
    private string? rawInstallInfos;
    private string? rawUpdateInfos;

    public WorkspaceConfig Config => ConfigX;
    public GitLabRepoWorkspaceConfig ConfigX { get; } = config;
    public IGitLabClient Gitlab { get; } = new GitLabClient(config.InstanceUrl, config.ApiToken);
    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.RepoName = (await Gitlab.Projects.GetByIdAsync((int)ConfigX.RepoId, new())).Name;

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

    public async Task<bool> Save()
    {
        var failed = true;
        
        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)
    {
        var repoId = new ProjectId(ConfigX.RepoId);
        var repo = Gitlab.GetRepository(repoId);
        var data = await repo.Files.GetAsync(path, ConfigX.RepoBranche);
        return data.DecodedContent;
    }

    private Task<bool> SaveContent(string path, string content)
    {
        var repoId = new ProjectId(ConfigX.RepoId);
        var repo = Gitlab.GetRepository(repoId);
        var update = new FileUpsert
        {
            Branch = ConfigX.RepoBranche,
            CommitMessage = "update " + Path.GetFileName(path),
            RawContent = content,
            Path = path,
        };

        if (repo.Files.FileExists(path, ConfigX.RepoBranche))
            repo.Files.Update(update);
        else
            repo.Files.Create(update);

        return Task.FromResult(true);
    }
}