using MAX.Core.DependencyInjection;
using MAX.Framework.Commons;
using Microsoft.Extensions.Configuration;
using MySqlX.XDevAPI;
using OpenSearch.Client;
using OpenSearch.Net;
using Store.Modules.CloudProduct.Dtos;
using Store.Modules.CloudProduct.Entities;

namespace Store.Modules.CloudProduct.Services
{
	public interface IOpenSearchServer: ISingletonDependency
	{
		Task AddOneRecordAsync(ProductSearchInfo goods);
		Task BulkIndexGoodsAsync(IEnumerable<ProductSearchInfo> docs);
		Task<bool> ClearIndexAsync();
		Task<long> CountDocumentsAsync();
		Task<bool> CreateIndexAsync();
		Task DeleteDocumentsAsync(IEnumerable<long> ids);
		Task DeleteIndexAsync();
		Task<OpenSearchStatusDto> GetStatusAsync();
		Task<long> RebuildIndexAsync(IEnumerable<ProductEntity> goodsList);
		Task<(long Total, List<ProductSearchInfo> list)> SearchByTitleAsync(ProductSearchRequest request, GoodsSearchSortBy sortBy = GoodsSearchSortBy.Relevance);
	}

	internal class OpenSearchServer : IOpenSearchServer
	{
		private readonly string nodeUrl;
		private IOpenSearchClient _client = null!;
		private readonly string IndexName = "";

		// 查询类操作（search/count/status/ping）统一超时
		private static readonly TimeSpan QueryTimeout = TimeSpan.FromSeconds(5);
		// 批量写入/建索引/删除索引等管理类操作超时（数据量大时需要更长，可挪到配置文件）
		private static readonly TimeSpan AdminTimeout = TimeSpan.FromSeconds(30);

		public OpenSearchServer(IConfiguration configuration)
		{
			var config = configuration.GetSection("Search");
			nodeUrl = config.GetValue<string>("Url") ?? "";
			IndexName = config.GetValue<string>("IndexName") ?? "";
			_client = CreateClient();
		}

		private IOpenSearchClient CreateClient()
		{
			var pool = new SingleNodeConnectionPool(new Uri(nodeUrl));
			var settings = new ConnectionSettings(pool)
				.DefaultIndex(IndexName)
				.DefaultMappingFor<ProductSearchInfo>(m => m.IndexName(IndexName))
				.RequestTimeout(QueryTimeout)
				.MaxRetryTimeout(QueryTimeout)
				.PrettyJson()
				.DisableDirectStreaming(); // 便于调试打印请求/响应报文

			return new OpenSearchClient(settings);
		}

		/// <summary>
		/// ============ 1. 创建索引 ============
		/// </summary>
		public async Task<bool> CreateIndexAsync()
		{
			var existsResponse = await _client.Indices.ExistsAsync(IndexName, d => d
				.RequestConfiguration(r => r.RequestTimeout(AdminTimeout)));
			if (existsResponse.Exists)
			{
				if (await IsIndexMappingHealthyAsync())
				{
					Console.WriteLine($"索引 [{IndexName}] 已存在且映射正确，无需重复创建。");
					return true;
				}

				Console.WriteLine($"索引 [{IndexName}] 的映射不完整（可能由清空索引等操作造成），正在重建...");
				var deleteResponse = await _client.Indices.DeleteAsync(IndexName, d => d
					.RequestConfiguration(r => r.RequestTimeout(AdminTimeout)));
				if (!deleteResponse.IsValid)
				{
					throw new AppException("删除损坏索引失败: " + deleteResponse.DebugInformation);
				}
			}

			// 优先尝试使用 IK 中文分词（需集群安装 analysis-ik 插件）
			var createResponse = await TryCreateIndexAsync(useIk: true);

			if (!createResponse.IsValid)
			{
				Console.WriteLine("IK 分词插件不可用，已回退到 standard 分析器，中文分词将失效，请检查集群是否安装 analysis-ik 插件。");
				createResponse = await TryCreateIndexAsync(useIk: false);
			}

			if (createResponse.IsValid)
			{
				Console.WriteLine($"索引 [{IndexName}] 创建成功。");
				return true;
			}
			else
			{
				throw new AppException("索引创建失败: " + createResponse.DebugInformation);
			}
		}

		/// <summary>
		/// 校验索引映射是否健康：title 字段必须使用 IK 分析器
		/// </summary>
		private async Task<bool> IsIndexMappingHealthyAsync()
		{
			try
			{
				var getResponse = await _client.Indices.GetAsync(IndexName, d => d
					.RequestConfiguration(r => r.RequestTimeout(QueryTimeout)));
				if (!getResponse.IsValid || !getResponse.Indices.TryGetValue(IndexName, out var indexState))
				{
					return false;
				}

				var mapping = indexState.Mappings;
				if (mapping?.Properties == null
					|| !mapping.Properties.TryGetValue(new PropertyName("title"), out var property)
					|| property is not ITextProperty textProperty)
				{
					return false;
				}

				return textProperty.Analyzer == "ik_max_word" && textProperty.SearchAnalyzer == "ik_smart";
			}
			catch
			{
				return false;
			}
		}

		private async Task<CreateIndexResponse> TryCreateIndexAsync(bool useIk)
		{
			var indexAnalyzer = useIk ? "ik_max_word" : "standard";
			var searchAnalyzer = useIk ? "ik_smart" : "standard";

			return await _client.Indices.CreateAsync(IndexName, c => c
				.Settings(s => s
					.NumberOfShards(1)
					.NumberOfReplicas(0)
				)
				.Map<ProductSearchInfo>(m => m
					.Properties(p => p
						.Number(n => n.Name(x => x.Id).Type(NumberType.Long))
						.Text(t => t
							.Name(x => x.Title)
							.Analyzer(indexAnalyzer)
							.SearchAnalyzer(searchAnalyzer)
						)
						.Number(n => n.Name(x => x.CatId1).Type(NumberType.Integer))
						.Number(n => n.Name(x => x.CatId2).Type(NumberType.Integer))
						.Number(n => n.Name(x => x.CatId3).Type(NumberType.Integer))
						.Number(n => n.Name(x => x.CatId4).Type(NumberType.Integer))
						.Number(n => n.Name(x => x.MinPrice).Type(NumberType.Long))
						.Number(n => n.Name(x => x.SoldQuantity).Type(NumberType.Integer))
					)
				)
				.RequestConfiguration(r => r.RequestTimeout(AdminTimeout))
			);
		}

		/// <summary>
		/// ============ 2. 删除索引 ============
		/// </summary>
		public async Task DeleteIndexAsync()
		{
			var response = await _client.Indices.DeleteAsync(IndexName, d => d
				.RequestConfiguration(r => r.RequestTimeout(AdminTimeout)));
			if (!response.IsValid)
			{
				throw new AppException("删除失败: " + response.DebugInformation);
			}
		}

		/// <summary>
		/// ============ 3.1 批量写入商品搜索文档（存在则覆盖） ============
		/// </summary>
		public async Task BulkIndexGoodsAsync(IEnumerable<ProductSearchInfo> docs)
		{
			if (docs == null) throw new ArgumentNullException(nameof(docs));

			var list = docs.ToList();
			if (list.Count == 0) return;

			// 确保索引已按 IK 分词映射创建，否则中文分词无效
			await CreateIndexAsync();

			var bulkResponse = await _client.BulkAsync(b => b
				.Index(IndexName)
				.IndexMany(list, (descriptor, doc) => descriptor.Id(doc.Id))
				.RequestConfiguration(r => r.RequestTimeout(AdminTimeout))
			);

			if (!bulkResponse.IsValid)
			{
				throw new AppException("写入 OpenSearch 失败: " + bulkResponse.DebugInformation);
			}

			// 刷新索引，保证数据立即可搜索（仅用于演示，生产环境不建议频繁 Refresh）
			await _client.Indices.RefreshAsync(IndexName, d => d
				.RequestConfiguration(r => r.RequestTimeout(AdminTimeout)));
		}

		/// <summary>
		/// ============ 3.2 根据数据库商品重建搜索索引 ============
		/// </summary>
		public async Task<long> RebuildIndexAsync(IEnumerable<ProductEntity> goodsList)
		{
			if (goodsList == null) throw new ArgumentNullException(nameof(goodsList));

			var docs = goodsList
				.Where(x => x != null && x.GoodsId > 0)
				.Select(x => new ProductSearchInfo
				{
					Id = x.GoodsId,
					Title = x.Title ?? string.Empty,
					CatId1 = x.CatId1,
					CatId2 = x.CatId2,
					CatId3 = x.CatId3,
					CatId4 = x.CatId4,
					MinPrice = x.MinPrice,
					SoldQuantity = x.SoldQuantity
				})
				.ToList();

			if (docs.Count == 0) return 0;

			await BulkIndexGoodsAsync(docs);
			return docs.Count;
		}

		/// <summary>
		/// ============ 3.3 按主键批量删除 OpenSearch 文档（软/硬删除共用） ============
		/// </summary>
		public async Task DeleteDocumentsAsync(IEnumerable<long> ids)
		{
			var list = ids?.Distinct().ToList() ?? new List<long>();
			if (list.Count == 0) return;

			var exists = await _client.Indices.ExistsAsync(IndexName, d => d
				.RequestConfiguration(r => r.RequestTimeout(QueryTimeout)));
			if (!exists.Exists)
			{
				return;
			}

			var response = await _client.BulkAsync(b =>
			{
				foreach (var id in list)
				{
					b.Delete<ProductSearchInfo>(d => d.Index(IndexName).Id(id));
				}
				b.RequestConfiguration(r => r.RequestTimeout(AdminTimeout));
				return b;
			});

			if (!response.IsValid)
			{
				throw new AppException("删除 OpenSearch 文档失败: " + response.DebugInformation);
			}

			await _client.Indices.RefreshAsync(IndexName, d => d
				.RequestConfiguration(r => r.RequestTimeout(AdminTimeout)));
		}

		/// <summary>
		/// ============ 4. 手动新增一条 ============
		/// </summary>
		public async Task AddOneRecordAsync(ProductSearchInfo goods)
		{
			if (goods == null) throw new ArgumentNullException(nameof(goods));
			var response = await _client.IndexAsync(goods, i => i
				.Index(IndexName)
				.Id(goods.Id)
				.RequestConfiguration(r => r.RequestTimeout(QueryTimeout))
			);

			if (response.IsValid)
			{
				await _client.Indices.RefreshAsync(IndexName, d => d
					.RequestConfiguration(r => r.RequestTimeout(QueryTimeout)));
			}
			else
			{
				throw new AppException("新增失败: " + response.DebugInformation);
			}
		}

		/// <summary>
		/// ============ 5. 分词搜索（分页 + 类目/价格过滤 + 排序） ============
		/// </summary>
		/// <param name="keyword">搜索关键词</param>
		/// <param name="catId1">一级类目，不传则不限制</param>
		/// <param name="catId2">二级类目，不传则不限制</param>
		/// <param name="catId3">三级类目，不传则不限制</param>
		/// <param name="catId4">四级类目，不传则不限制</param>
		/// <param name="minPrice">最低价（含），不传则不限制</param>
		/// <param name="maxPrice">最高价（含），不传则不限制</param>
		/// <param name="sortBy">排序方式</param>
		/// <param name="pageIndex">页码，从 1 开始</param>
		/// <param name="pageSize">每页条数</param>
		public async Task<(long Total, List<ProductSearchInfo> list)> SearchByTitleAsync(ProductSearchRequest request,
			GoodsSearchSortBy sortBy = GoodsSearchSortBy.Relevance)
		{
			string keyword = request.Title;
			int? catId1 = request.CatId1;
			int? catId2 = request.CatId2;
			int? catId3 = request.CatId3;
			int? catId4 = request.CatId4;
			long? minPrice = request.MinPrice;
			long? maxPrice = request.MaxPrice;
			int? minsold = request.MinSoldQuantity;
			int? maxsold = request.MaxSoldQuantity;
			int? platform = request.Platform;
			int pageIndex = request.PageIndex;
			int pageSize = request.PageSize;


			//if (string.IsNullOrWhiteSpace(keyword))
			//{
			//	throw new AppException("关键词不能为空。");
			//}

			if (pageIndex < 1) pageIndex = 1;
			if (pageSize < 1) pageSize = 20;
			if (pageSize > 2000) pageSize = 2000; // 避免深分页/单页过大拖垮性能，按需调整上限

			var from = (pageIndex - 1) * pageSize;

			ISearchResponse<ProductSearchInfo> searchResponse;
			try
			{
				searchResponse = await _client.SearchAsync<ProductSearchInfo>(s => s
					.Index(IndexName)
					.Query(q => q
						.Bool(b =>
						{
							if (string.IsNullOrWhiteSpace(keyword) == false)
							{
								b.Must(m => m.Match(mm => mm.Field(f => f.Title).Query(keyword)));
							}

							var filters = new List<Func<QueryContainerDescriptor<ProductSearchInfo>, QueryContainer>>();
							if (platform.HasValue && platform!.Value > 0) filters.Add(f => f.Term(t => t.Field(x => x.Platform).Value(platform.Value)));

							if (catId1.HasValue) filters.Add(f => f.Term(t => t.Field(x => x.CatId1).Value(catId1.Value)));
							if (catId2.HasValue) filters.Add(f => f.Term(t => t.Field(x => x.CatId2).Value(catId2.Value)));
							if (catId3.HasValue) filters.Add(f => f.Term(t => t.Field(x => x.CatId3).Value(catId3.Value)));
							if (catId4.HasValue) filters.Add(f => f.Term(t => t.Field(x => x.CatId4).Value(catId4.Value)));

							if (minPrice.HasValue || maxPrice.HasValue)
							{
								filters.Add(f => f.Range(r =>
								{
									var range = r.Field(x => x.MinPrice);
									if (minPrice.HasValue) range = range.GreaterThanOrEquals(minPrice.Value);
									if (maxPrice.HasValue) range = range.LessThanOrEquals(maxPrice.Value);
									return range;
								}));
							}

							if (minsold.HasValue || maxsold.HasValue)
							{
								filters.Add(f => f.Range(r =>
								{
									var range = r.Field(x => x.SoldQuantity);
									if (minsold.HasValue) range = range.GreaterThanOrEquals(minsold.Value);
									if (maxsold.HasValue) range = range.LessThanOrEquals(maxsold.Value);
									return range;
								}));
							}



							if (filters.Count > 0) b.Filter(filters.ToArray());
							return b;
						})
					)
					.Sort(sort => sortBy switch
					{
						GoodsSearchSortBy.PriceAsc => sort.Ascending(f => f.MinPrice),
						GoodsSearchSortBy.PriceDesc => sort.Descending(f => f.MinPrice),
						GoodsSearchSortBy.SoldDesc => sort.Descending(f => f.SoldQuantity),
						_ => sort.Descending(SortSpecialField.Score)
					})
					.From(from)
					.Size(pageSize)
					.TrackTotalHits(true) // 命中数超过 10000 时默认不精确统计，需要显式开启
					.RequestConfiguration(r => r.RequestTimeout(QueryTimeout))
				);
			}
			catch (OpenSearchClientException ex) when (ex.Response?.Success == false)
			{
				throw new AppException($"搜索超时或失败（{QueryTimeout.TotalSeconds}秒）: " + ex.Message);
			}

			if (!searchResponse.IsValid)
			{
				throw new AppException("搜索失败: " + searchResponse.DebugInformation);
			}

			//var ids = searchResponse.Documents.Select(d => d.Id).ToList();
			return (searchResponse.Total, searchResponse.Documents.ToList());
		}

		/// <summary>
		/// ============ 6. 统计文档数 ============
		/// </summary>
		public async Task<long> CountDocumentsAsync()
		{
			var countResponse = await _client.CountAsync<ProductSearchInfo>(c => c
				.Index(IndexName)
				.RequestConfiguration(r => r.RequestTimeout(QueryTimeout))
			);
			if (countResponse.IsValid)
			{
				Console.WriteLine($"索引 [{IndexName}] 当前文档总数: {countResponse.Count}");
				return countResponse.Count;
			}
			else
			{
				Console.WriteLine("统计失败: " + countResponse.DebugInformation);
				throw new AppException(countResponse.DebugInformation);
			}
		}

		/// <summary>
		/// ============ 7. 查询 OpenSearch 状态 ============
		/// </summary>
		public async Task<OpenSearchStatusDto> GetStatusAsync()
		{
			var status = new OpenSearchStatusDto
			{
				NodeUrl = nodeUrl,
				IndexName = IndexName,
			};

			try
			{
				var ping = await _client.PingAsync(p => p
					.RequestConfiguration(r => r.RequestTimeout(QueryTimeout)));
				status.Connected = ping.IsValid;
				if (!ping.IsValid)
				{
					status.Message = ping.DebugInformation;
					return status;
				}

				var exists = await _client.Indices.ExistsAsync(IndexName, d => d
					.RequestConfiguration(r => r.RequestTimeout(QueryTimeout)));
				status.IndexExists = exists.Exists;

				if (exists.Exists)
				{
					var count = await _client.CountAsync<ProductSearchInfo>(c => c
						.Index(IndexName)
						.RequestConfiguration(r => r.RequestTimeout(QueryTimeout)));
					status.DocumentCount = count.IsValid ? count.Count : -1;
					if (!count.IsValid)
						status.Message = count.DebugInformation;
				}
			}
			catch (Exception ex)
			{
				status.Connected = false;
				status.Message = ex.Message;
			}

			return status;
		}

		/// <summary>
		/// 清空索引：删除后按统一映射重建，重建期间该索引不可查（由后台定时任务负责回填数据，接受短暂空窗）
		/// </summary>
		public async Task<bool> ClearIndexAsync()
		{
			var existsResponse = await _client.Indices.ExistsAsync(IndexName, d => d
				.RequestConfiguration(r => r.RequestTimeout(QueryTimeout)));
			if (!existsResponse.Exists)
			{
				Console.WriteLine($"索引 {IndexName} 不存在");
				return false;
			}

			var deleteResponse = await _client.Indices.DeleteAsync(IndexName, d => d
				.RequestConfiguration(r => r.RequestTimeout(AdminTimeout)));
			if (!deleteResponse.IsValid)
			{
				Console.WriteLine($"删除索引 {IndexName} 失败: {deleteResponse.DebugInformation}");
				return false;
			}
			Console.WriteLine($"索引 {IndexName} 已删除");

			return await CreateIndexAsync();
		}
	}
}