WorkFlowCheck/src/WorkFlowCheck.MAUI/Pages/CheckList/CheckListPage.xaml.cs

using CommunityToolkit.Maui.Alerts;
using CommunityToolkit.Maui.Core;
using System.Diagnostics;
using System.Globalization;
using System.Threading.Tasks;
using System.Windows.Input;
using WorkFlowCheck.Common.DTO;
using WorkFlowCheck.Common.Enums;
using WorkFlowCheck.MAUI.Pages.NFC;
using WorkFlowCheck.MAUI.Services.Interfaces;

namespace WorkFlowCheck.MAUI.Pages.CheckList;

public partial class CheckListPage : ContentPage
{
    private readonly ICheckListService _checkListService;
    private readonly IUserService _userService;
    private readonly ISyncService _syncService;
    private bool _isLoading;
    private UserDTO _currentUser;

    public ICommand NewCommand { get; set; }
    public ICommand ContinueCommand { get; set; }
    public ICommand UnblockCommand { get; set; }
    public ICommand BlockCommand { get; set; }
    public bool IsLoading
    {
        get => _isLoading;
        set
        {
            _isLoading = value;
            OnPropertyChanged(nameof(IsLoading));
        }
    }


    public CheckListPage()
    {
        InitializeComponent();
        _checkListService = MauiProgram.ServiceProvider.GetRequiredService<ICheckListService>();
        _userService = MauiProgram.ServiceProvider.GetRequiredService<IUserService>();
        _syncService = MauiProgram.ServiceProvider.GetRequiredService<ISyncService>();
        NewCommand = new Command<CheckListTemplateHeaderDTO>(OnNewItem);
        ContinueCommand = new Command<CheckListHeaderDTO>(OnContinueItem);
        UnblockCommand = new Command<CheckListHeaderDTO>(OnUnblockItem);
        BlockCommand = new Command<CheckListHeaderDTO>(OnBlockItem);

    }
    private void SetInfo()
    {
        _currentUser = _userService.GetCurrentUser();
        DeviceId.Text = _userService.DeviceId;
        UserInfo.Text = $"{_currentUser?.LastName} {_currentUser?.FirstName}";
    }
    protected override bool OnBackButtonPressed()
    {
        Shell.Current.GoToAsync("//MainPage");
        return true;
    }
    protected override async void OnAppearing()
    {
        base.OnAppearing();
        SetInfo();
        BindingContext = this;
        await LoadCheckListTemplate();
        await LoadCheckList();
    }
    private async void OnNewItem(CheckListTemplateHeaderDTO checkListTemplateHeaderDTO)
    {
        bool answer = await DisplayAlert("Megerõsítés", "Biztosan indítasz egy új ellenõrzést?", "Igen", "Mégsem");
        if (!answer) return;

        IsLoading = true;
        var response = await _checkListService.StartNew(
            new CheckListHeaderNewDTO()
            {
                UserId = _userService.GetCurrentUser().Id,
                CheckListTemplateHeaderId = checkListTemplateHeaderDTO.Id
            });
        IsLoading = false;

        if (response != null && response.IsSuccess)
        {
            await Task.Run(async () =>
            {
                await _syncService.SyncCheckListHeader_Down((percentage, infostring) =>
                {
                    // Direkt UI frissítés
                    MainThread.BeginInvokeOnMainThread(() =>
                    {
                        //progressBar.Progress = percentage / 100;
                        //progressLabel.Text = $"{infostring}: {percentage:0.00}%";
                    });
                });
            });
            await LoadCheckList();
            var visualOptions = new SnackbarOptions
            {
                ActionButtonTextColor = Colors.White,
                CornerRadius = new CornerRadius(10),
                Font = Microsoft.Maui.Font.SystemFontOfSize(16),
                BackgroundColor = Microsoft.Maui.Graphics.Color.Parse("Green"),
                TextColor = Colors.White

            };
            var snackbar = Snackbar.Make(
                                            $"Új ellenõrzés indult! {response.Data.DocumentNumber}",
                                            duration: TimeSpan.FromSeconds(10),
                                            action: () => Console.WriteLine("Snackbar dismissed"),
                                            actionButtonText: "OK",
                                            visualOptions: visualOptions
                                        );

            await snackbar.Show();
        }
    }
    private async void OnContinueItem(CheckListHeaderDTO checkListHeaderDTO)
    {
        var checkPointCode = await NFCWaiter.ShowModalAsync();
        if (!string.IsNullOrEmpty(checkPointCode))
        {
            if (Navigation.ModalStack.Count > 0)
            {
                await Navigation.PopModalAsync();
            }

            await Navigation.PushAsync(new CheckListWorkPage(checkListHeaderDTO.Id, checkPointCode));
        }
    }
    private async void OnUnblockItem(CheckListHeaderDTO checkListHeaderDTO)
    {
        bool answer = await DisplayAlert("Megerõsítés", "Biztosan feloldod a blokkolást?", "Igen", "Mégsem");
        if (answer)
        {
            await _checkListService.UnBlockCheckListHeader(checkListHeaderDTO);
            await LoadCheckList();
        }

    }
    private async void OnBlockItem(CheckListHeaderDTO checkListHeaderDTO)
    {
        bool answer = await DisplayAlert("Megerõsítés", "Biztosan blokkolod a folyamatot?", "Igen", "Mégsem");
        if (answer)
        {
            await _checkListService.BlockCheckListHeader(checkListHeaderDTO);
            await LoadCheckList();
        }
    }
    private async Task LoadCheckListTemplate()
    {
        IsLoading = true;

        CheckListTemplate.ItemsSource = await _checkListService.GetCheckListTemplates(_currentUser.Id);
        IsLoading = false;
    }
    private async Task LoadCheckList()
    {
        IsLoading = true;

        var checkListHeaderDTOs = await _checkListService.GetCheckLists(_currentUser.Id);
        var isAdmin = false;
        var userDTO = _userService.GetCurrentUser();
        foreach (var roleDTO in userDTO.RoleDTO)
        {
            if (roleDTO.IsAdmin)
            {
                isAdmin = true;
                CheckList.ItemsSource = checkListHeaderDTOs;
                break;
            }
        }

        if (!isAdmin)
        {
            var result = checkListHeaderDTOs
                          .Where(w => w.UserId == userDTO.Id && w.CheckStatus != CheckStatus.Blocked).ToList();
            CheckList.ItemsSource = result;
        }

        IsLoading = false;
    }

}

public class BlockedConverter : IValueConverter
{
    public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
    {
        if (value is CheckStatus status)
        {
            return status == CheckStatus.InProgress;
        }
        return false;
    }

    public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
    {
        throw new NotImplementedException();
    }
}
public class UnBlockedConverter : IValueConverter
{
    public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
    {
        if (value is CheckStatus status)
        {
            if (status == CheckStatus.Blocked)
            {
                return true;
            }
            return false;
        }
        return false;
    }

    public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
    {
        throw new NotImplementedException();
    }
}
public class ContinueConverter : IValueConverter
{
    public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
    {
        if (value is CheckStatus status)
        {
            if (status == CheckStatus.InProgress || status == CheckStatus.Open)
            {
                return true;
            }
            return false;
        }
        return false;
    }

    public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
    {
        throw new NotImplementedException();
    }
}