using HandyControl.Controls;
using Prism.Events;
using System.Collections.ObjectModel;
using YY.Admin.Core;
using YY.Admin.Core.Events;
using YY.Admin.Core.Helper;
using YY.Admin.Services.Service.Category;
using YY.Admin.Services.Service.Category.Dto;
using YY.Admin.ViewModels.Control;

namespace YY.Admin.ViewModels.SysManage;

public class CategoryDictionaryManagementViewModel : BaseViewModel
{
    private readonly IJeecgCategorySyncService _categorySyncService;
    private SubscriptionToken? _categoryChangedToken;

    private PaginationDataGridViewModel<JeecgCategoryItemOutput> _paginationDataGridViewModel;
    public PaginationDataGridViewModel<JeecgCategoryItemOutput> PaginationDataGridViewModel
    {
        get => _paginationDataGridViewModel;
        set => SetProperty(ref _paginationDataGridViewModel, value);
    }

    private PageJeecgCategoryItemInput _input;
    public PageJeecgCategoryItemInput Input
    {
        get => _input;
        set => SetProperty(ref _input, value);
    }

    public DelegateCommand SearchCommand { get; }
    public DelegateCommand ResetCommand { get; }
    public ObservableCollection<CategoryTreeNode> TreeNodes { get; } = [];

    private CategoryTreeNode? _selectedTreeNode;
    public CategoryTreeNode? SelectedTreeNode
    {
        get => _selectedTreeNode;
        set => SetProperty(ref _selectedTreeNode, value);
    }

    public CategoryDictionaryManagementViewModel(
        IJeecgCategorySyncService categorySyncService,
        IContainerExtension container,
        IRegionManager regionManager) : base(container, regionManager)
    {
        _categorySyncService = categorySyncService;
        _paginationDataGridViewModel = new PaginationDataGridViewModel<JeecgCategoryItemOutput>(FetchAsync);
        _input = new PageJeecgCategoryItemInput();

        SearchCommand = new DelegateCommand(async () => await SearchAsync());
        ResetCommand = new DelegateCommand(async () => await ResetAsync());

        _categoryChangedToken = _eventAggregator
            .GetEvent<CategoryChangedEvent>()
            .Subscribe(async _ => await OnCategoryChangedAsync(), ThreadOption.UIThread);

        _ = InitializeAsync();
    }

    private async Task InitializeAsync()
    {
        await LoadTreeAsync();
        await UIHelper.WaitForRenderAsync();
        await PaginationDataGridViewModel.LoadDataAsync();
    }

    private async Task<(IEnumerable<JeecgCategoryItemOutput> data, int totalCount)> FetchAsync()
    {
        Input.Page = PaginationDataGridViewModel.PageIndex;
        Input.PageSize = PaginationDataGridViewModel.DataCountPerPage;
        var result = await _categorySyncService.PageAsync(Input);
        return (result.Items, result.Total);
    }

    private async Task SearchAsync()
    {
        PaginationDataGridViewModel.PageIndex = 1;
        await PaginationDataGridViewModel.LoadDataAsync();
    }

    private async Task ResetAsync()
    {
        Input = new PageJeecgCategoryItemInput();
        SelectedTreeNode = null;
        await UIHelper.WaitForRenderAsync();
        await LoadTreeAsync();
        await SearchAsync();
    }

    public async Task OnTreeSelectedAsync(CategoryTreeNode? node)
    {
        SelectedTreeNode = node;
        Input.Pid = node?.Id;
        await SearchAsync();
    }

    private async Task LoadTreeAsync()
    {
        TreeNodes.Clear();
        var tree = await _categorySyncService.LoadTreeAsync();
        foreach (var item in tree)
        {
            TreeNodes.Add(MapTreeNode(item));
        }
    }

    private static CategoryTreeNode MapTreeNode(JeecgCategoryTreeNodeDto dto)
    {
        var node = new CategoryTreeNode
        {
            Id = dto.Id,
            Name = dto.Name ?? dto.Code ?? dto.Id,
            Code = dto.Code
        };
        foreach (var child in dto.Children)
        {
            node.Children.Add(MapTreeNode(child));
        }
        return node;
    }

    private async Task OnCategoryChangedAsync()
    {
        await LoadTreeAsync();
        await PaginationDataGridViewModel.LoadDataAsync();
    }

    protected override void CleanUp()
    {
        base.CleanUp();
        if (_categoryChangedToken != null)
        {
            _eventAggregator.GetEvent<CategoryChangedEvent>().Unsubscribe(_categoryChangedToken);
            _categoryChangedToken = null;
        }
    }

    public class CategoryTreeNode
    {
        public string Id { get; set; } = string.Empty;
        public string? Name { get; set; }
        public string? Code { get; set; }
        public ObservableCollection<CategoryTreeNode> Children { get; set; } = [];
        public string DisplayName => string.IsNullOrWhiteSpace(Code) ? (Name ?? Id) : $"{Name} ({Code})";
    }
}