@using Telerik.DataSource
@using System.Text.Json

<p>Define a search with any structure, but it must contain at least one <code>string</code> expression:</p>

<TelerikFilter Value="@FilterValue" OnUpdate="@(() => {})">
    <FilterFields>
        <FilterField Name="@nameof(Product.Name)" Type="@typeof(string)" />
        <FilterField Name="@nameof(Product.Description)" Type="@typeof(string)" />
        <FilterField Name="@nameof(Product.Group)" Type="@typeof(string)" />
        <FilterField Name="@nameof(Product.Price)" Type="@typeof(decimal)" />
        <FilterField Name="@nameof(Product.Quantity)" Type="@typeof(int)" />
        <FilterField Name="@nameof(Product.Released)" Type="@typeof(DateTime)" />
        <FilterField Name="@nameof(Product.Discontinued)" Type="@typeof(bool)" />
    </FilterFields>
</TelerikFilter>

<br />

<TelerikButton OnClick="@SetSearchFilter">Apply Search</TelerikButton>

<TelerikButton OnClick="@(() => ShouldRenderGrid = !ShouldRenderGrid)">Toggle Grid to call <code>OnStateInit</code></TelerikButton>

<br />
<br />

@if (ShouldRenderGrid)
{
    <TelerikGrid @ref="@GridRef"
                Data="@GridData"
                TItem="@Product"
                FilterMode="GridFilterMode.FilterRow"
                Pageable="true"
                Sortable="true"
                OnStateInit="@OnGridStateInit">
        <GridToolBar>
            <GridToolBarSearchBoxTool />
        </GridToolBar>
        <GridColumns>
            <GridColumn Field="@nameof(Product.Name)" />
            <GridColumn Field="@nameof(Product.Description)" />
            <GridColumn Field="@nameof(Product.Group)" />
            <GridColumn Field="@nameof(Product.Price)" DisplayFormat="{0:c2}" />
            <GridColumn Field="@nameof(Product.Quantity)" DisplayFormat="{0:n0}" />
            <GridColumn Field="@nameof(Product.Released)" DisplayFormat="{0:d}" />
            <GridColumn Field="@nameof(Product.Discontinued)" />
        </GridColumns>
    </TelerikGrid>
}

@code {
    private TelerikGrid<Product>? GridRef;
    private List<Product> GridData { get; set; } = new();

    private bool ShouldRenderGrid { get; set; } = true;

    private CompositeFilterDescriptor FilterValue { get; set; } = new();

    private async Task SetSearchFilter()
    {
        GridState<Product> gridState = GridRef!.GetState();

        ApplyFilterValueToGridState(gridState);

        await GridRef.SetStateAsync(gridState);
    }

    private void OnGridStateInit(GridStateEventArgs<Product> args)
    {
        if (FilterValue.FilterDescriptors.Count == 0)
        {
            return;
        }

        GridState<Product> gridState = args.GridState;

        ApplyFilterValueToGridState(gridState);
    }

    private void ApplyFilterValueToGridState(GridState<Product> gridState)
    {
        // Clone FilterValue to insert a dummy expression only for the Grid SearchState
        string searchFilterJson = JsonSerializer.Serialize(FilterValue);
        CompositeFilterDescriptor searchFilterObject = JsonSerializer.Deserialize<CompositeFilterDescriptor>(searchFilterJson)!;
        RestoreMemberTypeRecursively(searchFilterObject);

        IFilterDescriptor? firstFilterDesctiptor = searchFilterObject.FilterDescriptors.FirstOrDefault();

        if (firstFilterDesctiptor is null)
        {
            gridState.SearchFilter = null;
        }
        else if (firstFilterDesctiptor is FilterDescriptor fd && fd.MemberType == typeof(string))
        {
            gridState.SearchFilter = searchFilterObject;
        }
        else
        {
            string searchValue = FindSearchStringValueRecursively(searchFilterObject.FilterDescriptors);

            if (!string.IsNullOrEmpty(searchValue))
            {
                searchFilterObject.FilterDescriptors.Insert(0, new FilterDescriptor()
                {
                    Member = nameof(Product.Name),
                    Operator = FilterOperator.Contains,
                    Value = searchValue
                });

                gridState.SearchFilter = searchFilterObject;
            }
            else
            {
                gridState.SearchFilter = null;
            }
        }
    }

    private string FindSearchStringValueRecursively(FilterDescriptorCollection fdc)
    {
        foreach (IFilterDescriptor ifd in fdc)
        {
            if (ifd is FilterDescriptor fd)
            {
                if (fd.MemberType == typeof(string))
                {
                    return fd.Value.ToString() ?? string.Empty;
                }
                else
                {
                    continue;
                }
            }
            else
            {
                return FindSearchStringValueRecursively(((CompositeFilterDescriptor)ifd).FilterDescriptors);
            }
        }

        return string.Empty;
    }

    private void RestoreMemberTypeRecursively(CompositeFilterDescriptor cfd)
    {
        var itemType = typeof(Product);

        foreach (IFilterDescriptor ifd in cfd.FilterDescriptors)
        {
            if (ifd is FilterDescriptor fd)
            {
                fd.MemberType = itemType.GetProperty(fd.Member)!.PropertyType;
            }
            else if (ifd is CompositeFilterDescriptor childCfd)
            {
                RestoreMemberTypeRecursively(childCfd);
            }
        }
    }

    protected override void OnInitialized()
    {
        var rnd = Random.Shared;

        for (int i = 1; i <= 27; i++)
        {
            GridData.Add(new Product()
            {
                Id = i,
                Name = $"Name {i} {(char)rnd.Next(65, 91)}{(char)rnd.Next(65, 91)}",
                Group = $"Group {i % 3 + 1}",
                Price = rnd.Next(1, 100) * 1.23m,
                Quantity = rnd.Next(0, 10000),
                Released = DateTime.Today.AddDays(-rnd.Next(60, 1000)),
                Discontinued = i % 4 == 0
            });
        }
    }

    public class Product
    {
        public int Id { get; set; }
        public string Name { get; set; } = string.Empty;
        public string Description { get; set; } = string.Empty;
        public string Group { get; set; } = string.Empty;
        public decimal Price { get; set; }
        public int Quantity { get; set; }
        public DateTime Released { get; set; }
        public bool Discontinued { get; set; }
    }
}