using System.Collections.Generic;
using System.Linq;
using System.Web;
using Examine;
using Examine.Providers;
using Intracto.Extensions.Models.Custom;
using Intracto.Extensions.Models.Generated;
using Newtonsoft.Json;
using Umbraco.Core;
using Umbraco.Core.Composing;
using Umbraco.Core.Logging;
using Umbraco.Core.Models.PublishedContent;
using Umbraco.Examine;
using Umbraco.Web;

namespace Intracto.Extensions.Indexes.Products
{
    public class ProductsIndexComponent : IComponent
    {
        private readonly IExamineManager _examineManager;
        private readonly ProductsIndexCreator _productsIndexCreator;
        private readonly IndexRebuilder _indexRebuilder;
        private readonly ILogger _logger;
        private readonly IUmbracoContextFactory _umbracoContextFactory;

        public ProductsIndexComponent(IExamineManager examineManager, ILogger logger, ProductsIndexCreator productsIndexCreator, IndexRebuilder indexRebuilder, IUmbracoContextFactory umbracoContextFactory)
        {
            _logger = logger;
            _examineManager = examineManager;
            _productsIndexCreator = productsIndexCreator;
            _indexRebuilder = indexRebuilder;
            _umbracoContextFactory = umbracoContextFactory;
        }

        public void Initialize()
        {
            foreach (var data in _productsIndexCreator.Create())
            {
                _examineManager.AddIndex(data);
            }

            _examineManager.TryGetIndex(PioneerConstants.Examine.CustomIndexes.ProductsIndex, out IIndex faqIndex);

            if (!(faqIndex is BaseIndexProvider indexProvider))
                throw new InvalidOperationException("Could not cast");

            indexProvider.TransformingIndexValues += IndexProviderTransformingIndexValues;

            //Rebuild index on initialize
            _indexRebuilder.RebuildIndex(PioneerConstants.Examine.CustomIndexes.ProductsIndex);
        }

        private void IndexProviderTransformingIndexValues(object sender, IndexingItemEventArgs e)
        {
            if (e.ValueSet.Category == IndexTypes.Content)
            {
                try
                {
                    using (var umbraco = _umbracoContextFactory.EnsureUmbracoContext())
                    {
                        var product = umbraco.UmbracoContext.Content.GetById(int.Parse(e.ValueSet.Id));

                        e.ValueSet.Add("productGroupId", product.Parent.Id);

                        if (product != null)
                        {
                            //Add nodeUrl & isContentAvailable
                            foreach (var languageVariant in product.Cultures)
                            {
                                var culture = languageVariant.Value.Culture;
                               
                                //Filters
                                var filtersTaxonomy = product.Value<IEnumerable<IPublishedContent>>(Product.GetModelPropertyType(x => x.Filters).Alias, culture);

                                if (filtersTaxonomy?.Any() == true)
                                {
                                    e.ValueSet.Add($"productFiltersTaxonomy_{culture}", string.Join(" ", filtersTaxonomy.Select(x => x.Name.Replace(" ", "-"))));
                                }
                            }
                        }
                    }
                }
                catch (Exception ex)
                {
                    _logger.Error<ProductsIndexComponent>(ex, "Error combining fields for {ValueSetId}", e.ValueSet.Id);
                }
            }
        }

        public void Terminate(){ }
    }
}```

In our code we're trying to use 'productsFiltersTaxonomy' as faceted filter with values such as 'Touch-Screen', 'Accessories-&-Parts' but those words are being split up into two words: 'Touch', 'Screen', 'Accessories', 'Parts', ...



Any idea what we're doing wrong?

var query = searcher.CreateQuery(); // gets a query from a BoboFacetSearcher

query = query.Facet("CategoryId").And();

query = query.GroupedOr(new[]{"Type"}, "type1", "type2", "type3").And();

var executor = query.All().OrderBy(new SortableField("Type"));

var results = executor.Execute(10);

var executor = query.All();
executor.OrderBy(new SortableField("Type"));

var results = executor.Execute(10);

var facetCriteria = facetSearcher.CreateQuery(IndexTypes.Content, BooleanOperation.And);
var facetQuery = facetCriteria.NodeTypeAlias("blogDetailsPage");//considering blog pages only in the search
facetQuery.And().Facet("categories");
var facetResults = facetQuery.Execute().GetFacet("categories");

var results = _productSearcher.CreateQuery(IndexTypes.Content, BooleanOperation.And)
                                  .Facet($"productFiltersTaxonomy_{_currentCulture}", convertedValue).MinHits(1)
                                  .And()
                                  .Field($"__Published_{_currentCulture}", "y")
                                  .And()
                                  .Field($"productGroupId", productGroupId.ToString())
                                  .Execute();