using System;
using System.Collections.ObjectModel;
using System.Reactive.Linq;
using System.Threading.Tasks;
using Avalonia.ReactiveUI;
using Flawless.Client.Models;
using Flawless.Client.Service;
using Flawless.Client.ViewModels.ModalBox;
using Flawless.Client.Views.ModalBox;
using ReactiveUI;
using ReactiveUI.SourceGenerators;
using Ursa.Controls;

namespace Flawless.Client.ViewModels;

public partial class HomeViewModel : ViewModelBase, IRoutableViewModel
{
    public string? UrlPathSegment { get; } = Guid.NewGuid().ToString();
    
    public IScreen HostScreen { get; }
    
    [Reactive] private RepositoryModel? _selectedRepository;

    [Reactive] private string? _serverFriendlyName;

    public ObservableCollection<RepositoryModel> Repos => RepositoryService.C.Repositories;
    
    public HomeViewModel(IScreen hostScreen)
    {
        HostScreen = hostScreen;
        Api.C.ServerUrl.SubscribeOn(AvaloniaScheduler.Instance)
            .Subscribe(v => ServerFriendlyName = v ?? "Unknown Server");

        RefreshRepositoriesCommand.Execute();
    }

    [ReactiveCommand]
    private async Task RefreshRepositoriesAsync()
    {
        await RepositoryService.C.UpdateRepositoriesFromServerAsync();
        await RepositoryService.C.UpdateRepositoriesDownloadedStatusFromDiskAsync();
    }
    
    [ReactiveCommand]
    private async Task CreateRepositoryAsync()
    {
        var form = new CreateRepositoryDialogViewModel();
        var opt = new OverlayDialogOptions
        {
            FullScreen = false,
            Buttons = DialogButton.OKCancel,
            CanResize = false,
            CanDragMove = false,
            IsCloseButtonVisible = true,
            CanLightDismiss = true,
            Mode = DialogMode.Question
        };

        var mr = await OverlayDialog
            .ShowModal<CreateRepositoryDialogView, CreateRepositoryDialogViewModel>(form, AppDefaultValues.HostId, opt);
        
        if (mr == DialogResult.OK)
        {
            var repo = await RepositoryService.C.CreateRepositoryOnServerAsync(form.RepositoryName, form.Description);
            if (repo == null) return;
            if (!await RepositoryService.C.CreateNewRepositoryOnStorageAsync(repo)) return;
            
            await HostScreen.Router.Navigate.Execute(new RepositoryViewModel(repo, HostScreen));
        }
    }
    
    [ReactiveCommand]
    private async Task OpenRepositoryAsync()
    {
        if (_selectedRepository == null) return;
        if (!await RepositoryService.C.OpenRepositoryOnStorageAsync(_selectedRepository)) return;
        await HostScreen.Router.Navigate.Execute(new RepositoryViewModel(_selectedRepository, HostScreen));
    }
    
    [ReactiveCommand]
    private async Task DownloadRepositoryAsync()
    {
        if (_selectedRepository == null) return;
        if (!await RepositoryService.C.CloneRepositoryFromRemoteAsync(_selectedRepository)) return;
        await HostScreen.Router.Navigate.Execute(new RepositoryViewModel(_selectedRepository, HostScreen));
    }
    
    [ReactiveCommand]
    private async Task DeleteRepositoryAsync()
    {
        if (_selectedRepository == null) return;
        var opt = new OverlayDialogOptions
        {
            FullScreen = false,
            Buttons = DialogButton.YesNo,
            CanResize = false,
            CanDragMove = false,
            IsCloseButtonVisible = true,
            CanLightDismiss = true,
            Mode = DialogMode.Question
        };

        var vm = new SimpleMessageDialogViewModel(
            $"Do you really want to delete a CLONE of repository {_selectedRepository.StandaloneName} ?");
        
        var mr = await OverlayDialog
            .ShowModal<SimpleMessageDialogView, SimpleMessageDialogViewModel>(vm, AppDefaultValues.HostId, opt);
        
        if (mr == DialogResult.Yes)
        {
            if (await RepositoryService.C.DeleteFromDiskAsync(_selectedRepository))
                await RepositoryService.C.UpdateDownloadedStatusFromDiskAsync(_selectedRepository);
        }
    }

    [ReactiveCommand]
    private async Task QuitLoginAsync()
    {
        var opt = new OverlayDialogOptions
        {
            FullScreen = false,
            Buttons = DialogButton.YesNo,
            CanResize = false,
            CanDragMove = false,
            IsCloseButtonVisible = true,
            CanLightDismiss = true,
            Mode = DialogMode.Question
        };

        var vm = new SimpleMessageDialogViewModel("Do you really want to logout?");
        var mr = await OverlayDialog
            .ShowModal<SimpleMessageDialogView, SimpleMessageDialogViewModel>(vm, AppDefaultValues.HostId, opt);
        
        if (mr == DialogResult.Yes) Api.C.ClearGateway();
    }

    [ReactiveCommand]
    private async Task OpenGlobalSettingAsync()
    {
        await HostScreen.Router.Navigate.Execute(new SettingViewModel(HostScreen));
    }
}