using HandyControl.Tools.Extension;
using System.Collections.ObjectModel;
using YY.Admin.Core;
using YY.Admin.Core.Entity;
using YY.Admin.Core.Services;

namespace YY.Admin.ViewModels.RawMaterialEntry;

public class RawMaterialEntryMaterialPickerDialogViewModel : BaseViewModel, IDialogResultable<bool>
{
    private readonly IMixerMaterialService _mixerMaterialService;

    private string? _searchCode;
    public string? SearchCode
    {
        get => _searchCode;
        set => SetProperty(ref _searchCode, value);
    }

    private string? _searchName;
    public string? SearchName
    {
        get => _searchName;
        set => SetProperty(ref _searchName, value);
    }

    public ObservableCollection<MesMixerMaterial> Materials { get; } = new();

    private MesMixerMaterial? _selectedMaterial;
    public MesMixerMaterial? SelectedMaterial
    {
        get => _selectedMaterial;
        set
        {
            SetProperty(ref _selectedMaterial, value);
            ConfirmCommand.RaiseCanExecuteChanged();
            RaisePropertyChanged(nameof(SelectedMaterialDisplay));
            RaisePropertyChanged(nameof(HasSelectedMaterial));
        }
    }

    public string SelectedMaterialDisplay => _selectedMaterial != null
        ? $"[{_selectedMaterial.MaterialCode}]  {_selectedMaterial.MaterialName}"
        : "选中密炼物料后点击「确认选择」";

    public bool HasSelectedMaterial => _selectedMaterial != null;

    private bool _result;
    public bool Result
    {
        get => _result;
        set => SetProperty(ref _result, value);
    }

    public Action? CloseAction { get; set; }

    public DelegateCommand SearchCommand { get; }
    public DelegateCommand ConfirmCommand { get; }
    public DelegateCommand CancelCommand { get; }

    public RawMaterialEntryMaterialPickerDialogViewModel(
        IMixerMaterialService mixerMaterialService,
        IContainerExtension container,
        IRegionManager regionManager) : base(container, regionManager)
    {
        _mixerMaterialService = mixerMaterialService;
        SearchCommand = new DelegateCommand(async () => await LoadAsync());
        ConfirmCommand = new DelegateCommand(Confirm, () => SelectedMaterial != null);
        CancelCommand = new DelegateCommand(() => CloseAction?.Invoke());
        _ = LoadAsync();
    }

    public void Initialize(string? materialCode, string? materialName)
    {
        if (!string.IsNullOrWhiteSpace(materialCode))
        {
            SearchCode = materialCode.Trim();
        }

        if (!string.IsNullOrWhiteSpace(materialName))
        {
            SearchName = materialName.Trim();
        }
    }

    private async Task LoadAsync()
    {
        try
        {
            IsLoading = true;
            var result = await _mixerMaterialService.PageAsync(
                1,
                500,
                materialCode: SearchCode?.Trim(),
                materialName: SearchName?.Trim());

            Materials.Clear();
            foreach (var item in result.Records)
            {
                Materials.Add(item);
            }

            if (!string.IsNullOrWhiteSpace(SearchCode))
            {
                SelectedMaterial = Materials.FirstOrDefault(x =>
                    string.Equals(x.MaterialCode, SearchCode, StringComparison.OrdinalIgnoreCase));
            }
        }
        catch
        {
            Materials.Clear();
        }
        finally
        {
            IsLoading = false;
        }
    }

    private void Confirm()
    {
        if (SelectedMaterial == null)
        {
            return;
        }

        Result = true;
        CloseAction?.Invoke();
    }
}