#region imports
using Installer.Models;
using ReactiveUI;
using System;
using System.Diagnostics;
using System.IO;
using System.IO.Compression;
using System.Linq;
using System.Net;
using System.Net.Http;
using System.Net.Http.Json;
using System.Runtime.InteropServices;
using System.Threading.Tasks;
#endregion

namespace Installer.ViewModels;

public partial class MainWindowViewModel : ViewModelBase
{
    #region Private Properties
    private static HttpClient _client;
    private readonly string _url = "https://api.github.com/repos/mekasu0124/Todo/releases/latest";
    #endregion

    #region Observable Properties
    public ulong _value;
    public string _currentInformation;
    public string _userOs;
    public string _osDownloadUrl;
    public bool _isUpdating;
    public bool _canRun;
    public bool _isUpdateFinished;
    public record VersionData(string DownloadName, string DownloadUrl, ulong DownloadSize);
    #endregion

    #region Getter and Setters
    private ulong Value
    {
        get => _value;
        set => this.RaiseAndSetIfChanged(ref _value, value);
    }

    private string CurrentInformation
    {
        get => _currentInformation;
        set => this.RaiseAndSetIfChanged(ref _currentInformation, value);
    }

    private string UserOs
    {
        get => _userOs;
        set => this.RaiseAndSetIfChanged(ref _userOs, value);
    }

    private string OsDownloadUrl
    {
        get => _osDownloadUrl;
        set => this.RaiseAndSetIfChanged(ref _osDownloadUrl, value);
    }

    private bool IsUpdating
    {
        get => _isUpdating;
        set => this.RaiseAndSetIfChanged(ref _isUpdating, value);
    }

    private bool CanRun
    {
        get => _canRun;
        set => this.RaiseAndSetIfChanged(ref _canRun, value);
    }

    private bool IsUpdateFinished
    {
        get => _isUpdateFinished;
        set => this.RaiseAndSetIfChanged(ref _isUpdateFinished, value);
    }
    #endregion

    public async void BeginUpdate()
    {
        var data = await GetDownloadUrl();

        if (data is { } d)
        {
            bool check = await DownloadAndExtract(d);

            if (check)
            {
                AlertUserProcessFinished();
            }
        }
    }

    SupportedOperatingSystem GetSupportedOs()
    {
        if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
            return SupportedOperatingSystem.Windows;
        if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux))
            return SupportedOperatingSystem.Linux;
        if (RuntimeInformation.IsOSPlatform(OSPlatform.OSX))
            return SupportedOperatingSystem.Mac;
        throw new PlatformNotSupportedException();
    }

    async Task<VersionData?> GetDownloadUrl()
    {
        _client.DefaultRequestHeaders.UserAgent.TryParseAdd("request");

        try
        {
            var data = await _client.GetFromJsonAsync<ReleaseResponseDTO>(_url);
            var releases = data.Assets;
            var os = GetSupportedOs();
            var osReleaseData = releases.FirstOrDefault(x =>
            {
                var name = x.DownloadName;
                return os switch
                {
                    SupportedOperatingSystem.Windows => name.Contains("Windows"),
                    SupportedOperatingSystem.Linux => name.Contains("Linux"),
                    SupportedOperatingSystem.Mac => name.Contains("Mac"),
                    _ => false
                };
            });

            if (osReleaseData != null)
                return new VersionData(
                    osReleaseData.DownloadName,
                    osReleaseData.DownloadUrl,
                    osReleaseData.DownloadSize);

            CurrentInformation = "Failed to obtain download URL for given OS.";
            return null;
        }
        catch (HttpRequestException ex)
        {
            CurrentInformation = ex.Message;
            return new VersionData("Error", ex.Message, 0);
        }
    }

    async Task<bool> DownloadAndExtract(VersionData versionData)
    {
        try
        {
            var bytes = await _client.GetByteArrayAsync(versionData.DownloadUrl);
            await File.WriteAllBytesAsync(Directory.GetCurrentDirectory(), bytes);

            string zipPath = (Directory.GetCurrentDirectory() + "\\" + versionData.DownloadName);

            string tempPath = Path.Combine(Directory.GetCurrentDirectory(), "tempUnzip");

            try
            {
                string extractToPath = Directory.GetCurrentDirectory();

                ZipFile.ExtractToDirectory(zipPath, tempPath);

                string[] files = Directory.GetFiles(tempPath);

                foreach (string file in files)
                {
                    FileInfo f = new FileInfo(file);

                    if (File.Exists(Path.Combine(extractToPath, f.Name)))
                    {
                        File.Delete(Path.Combine(extractToPath, f.Name));
                        File.Move(f.FullName, Path.Combine(extractToPath, f.Name));
                    }
                    else
                    {
                        File.Move(f.FullName, Path.Combine(extractToPath, f.Name));
                    }
                }
            }
            finally
            {
                Directory.Delete(tempPath);
                Directory.Delete(zipPath);
            }

            IsUpdateFinished = true;
            return true;
        }
        catch (Exception ex)
        {
            CurrentInformation = ex.Message;
            return false;
        }
    }

    public void IncrementProgress(ulong progVal)
    {
        Value += progVal;
    }

    public void AlertUserProcessFinished()
    {
        CurrentInformation = "THe Update Has Finished. Click Launch App To Open Todo App";
        CanRun = true;
    }

    public void LaunchApplication()
    {
        var userOs = GetSupportedOs();

        switch (userOs)
        {
            case SupportedOperatingSystem.Windows:
                var p = new Process();
                p.StartInfo.FileName = "/Executables/win/Todo.exe";
                Environment.Exit(0);
                break;

            case SupportedOperatingSystem.Linux:
                // some code to launch application on linux
                Environment.Exit(0);
                break;

            case SupportedOperatingSystem.Mac:
                // some code to launch application on Mac
                Environment.Exit(0);
                break;
        }
    }
}