using Hotline.Application.FlowEngine;
using Hotline.Application.Knowledge;
using Hotline.FlowEngine.WorkflowModules;
using Hotline.KnowledgeBase;
using Hotline.KnowledgeBase.Notifies;
using Hotline.Orders;
using Hotline.Permissions;
using Hotline.Repository.SqlSugar.Extensions;
using Hotline.Repository.SqlSugar.Ts;
using Hotline.Settings;
using Hotline.Settings.Hotspots;
using Hotline.Share.Dtos;
using Hotline.Share.Dtos.FlowEngine;
using Hotline.Share.Dtos.Knowledge;
using Hotline.Share.Dtos.Order;
using Hotline.Share.Enums.KnowledgeBase;
using Hotline.Users;
using MapsterMapper;
using MediatR;
using Microsoft.AspNetCore.Mvc;
using SqlSugar;
using XF.Domain.Authentications;
using XF.Domain.Exceptions;
using XF.Domain.Repository;
using XF.Utility.EnumExtensions;

namespace Hotline.Api.Controllers
{
	public class KnowledgeController : BaseController
	{

		#region 注入
		private readonly IKnowledgeRepository _knowledgeRepository;
		private readonly ISessionContext _sessionContext;
		private readonly IKnowledgeDomainService _knowledgeDomainService;
		private readonly IMapper _mapper;
		private readonly IKnowApplication _knowApplication;
		private readonly IMediator _mediator;
		private readonly IWorkflowApplication _workflowApplication;
		private readonly IKnowledgeWorkFlowRepository _knowledgeWorkFlowRepository;
		private readonly IRepository<User> _userRepository;
		private readonly IRepository<KnowledgeType> _knowledgeTypeRepository;
		private readonly IRepository<Hotspot> _hotspotTypeRepository;
		private readonly IRepositoryTextSearch<KnowledgeTs> _repositoryts;
		private readonly IRepository<KnowledgeWord> _knowledgeWrodRepository;
		private readonly IRepository<KnowledgeQuestions> _knowledgeQuestionsRepository;
		private readonly IRepository<KnowledgeCorrection> _knowledgeCorrectionRepository;
		private readonly IRepository<KnowledgeCollect> _knowledgeCollectRepository;
		private readonly ISystemDomainService _systemDomainService;


		public KnowledgeController(
		   IKnowledgeRepository knowledgeRepository,
		   ISessionContext sessionContext,
		   IKnowledgeDomainService knowledgeDomainService,
		   IMapper mapper,
		   IKnowApplication knowApplication,
		   IMediator mediator,
		   IWorkflowApplication workflowApplication,
		   IKnowledgeWorkFlowRepository knowledgeWorkFlowRepository,
		   IRepository<User> userRepository,
		   IRepository<KnowledgeType> knowledgeTypeRepository,
		   IRepository<Hotspot> hotspotTypeRepository,
		   IRepositoryTextSearch<KnowledgeTs> repositoryts,
		   IRepository<KnowledgeWord> knowledgeWrodRepository,
		   IRepository<KnowledgeQuestions> knowledgeQuestionsRepository,
		   IRepository<KnowledgeCorrection> knowledgeCorrectionRepository,
		   IRepository<KnowledgeCollect> knowledgeCollectRepository,
		   ISystemDomainService systemDomainService
		   )
		{
			_knowledgeRepository = knowledgeRepository;
			_sessionContext = sessionContext;
			_knowledgeDomainService = knowledgeDomainService;
			_mapper = mapper;
			_knowApplication = knowApplication;
			_mediator = mediator;
			_workflowApplication = workflowApplication;
			_knowledgeWorkFlowRepository = knowledgeWorkFlowRepository;
			_userRepository = userRepository;
			_knowledgeTypeRepository = knowledgeTypeRepository;
			_hotspotTypeRepository = hotspotTypeRepository;
			_repositoryts = repositoryts;
			_knowledgeWrodRepository = knowledgeWrodRepository;
			_knowledgeQuestionsRepository = knowledgeQuestionsRepository;
			_knowledgeCorrectionRepository = knowledgeCorrectionRepository;
			_knowledgeCollectRepository = knowledgeCollectRepository;
			_systemDomainService = systemDomainService;
		}

		#endregion

		#region 知识管理

		/// <summary>
		/// 知识库-新增
		/// </summary>
		/// <param name="dto"></param>
		/// <returns></returns>
		[Permission(EPermission.AddKnowledge)]
		[HttpPost("add")]
		public async Task<string> AddKnowledge([FromBody] AddStartFlowDto dto)
		{
			var addDto = _mapper.Map<AddKnowledgeDto>(dto.Data);
			var kn = _mapper.Map<Knowledge>(dto.Data);
			//Code为空，从新生成Code
			if (string.IsNullOrEmpty(kn.Code))
				kn.Code = Convert.ToInt64((DateTime.Now - new DateTime(1970, 1, 1, 0, 0, 0, 0)).TotalSeconds).ToString();

			kn.Status = EKnowledgeStatus.Drafts;
			var id = await _knowledgeRepository.AddAsync(kn, HttpContext.RequestAborted);
			if (addDto.Tags.Any()) await _repositoryts.AddVectorAsync(id, DateTime.Now, addDto.Tags, HttpContext.RequestAborted);
			if (dto.Workflow != null &&  !string.IsNullOrEmpty(id))
			{
				var startDto = _mapper.Map<StartWorkflowDto>(dto.Workflow);
				startDto.DefinitionModuleCode = WorkflowModuleConsts.KnowledgeAdd;
				startDto.Title = "知识库新增";
				await StartFlow(id, WorkflowModuleConsts.KnowledgeAdd, EKnowledgeApplyType.Add, startDto);
				var knowledge = await _knowledgeRepository.GetAsync(id);
				knowledge.Status = EKnowledgeStatus.Auditing;
				await _knowledgeRepository.UpdateAsync(knowledge, HttpContext.RequestAborted);
			}
			return id;
		}


		/// <summary>
		/// 知识库-知识下架
		/// </summary>
		/// <param name="Id"></param>
		/// <returns></returns>
		[Permission(EPermission.KnowledgeOffShelf)]
		[HttpPut("offshelf")]
		public async Task KnowledgeOffShelf(string Id)
		{
			var know = await _knowledgeRepository.GetAsync(Id, HttpContext.RequestAborted);
			if (know != null && know.Status == EKnowledgeStatus.OnShelf)
			{
				know.Status = EKnowledgeStatus.OffShelf;
				know.OnShelfTime = null;
				know.OffShelfTime = DateTime.Now;
				await _knowledgeRepository.UpdateAsync(know, HttpContext.RequestAborted);
			}
			else
				throw UserFriendlyException.SameMessage("知识下架失败");

		}

		/// <summary>
		/// 知识库-知识上架
		/// </summary>
		/// <param name="Id"></param>
		/// <returns></returns>
		[Permission(EPermission.KnowledgeOnTheShelf)]
		[HttpPut("ontheshelf")]
		public async Task KnowledgeOnTheShelf(string Id)
		{
			var know = await _knowledgeRepository.GetAsync(Id, HttpContext.RequestAborted);
			if (know != null && know.Status == EKnowledgeStatus.OffShelf)
			{
				know.Status = EKnowledgeStatus.OnShelf;
				know.OnShelfTime = DateTime.Now;
				know.OffShelfTime = null;
				await _knowledgeRepository.UpdateAsync(know, HttpContext.RequestAborted);
			}
			else
				throw UserFriendlyException.SameMessage("知识上架失败");
		}

		/// <summary>
		/// 知识库-修改
		/// </summary>
		/// <param name="dto"></param>
		/// <returns></returns>
		[Permission(EPermission.KnowledgeDraftsUpdate)]
		[HttpPut("update")]
		public async Task UpdateKnowledge([FromBody] UpdateStartFlowDto dto)
		{
			var update = _mapper.Map<UpdateKnowledgeDto>(dto.Data);
			var knowledge = await _knowledgeRepository.GetAsync(update.Id);
			if (knowledge == null)
				throw UserFriendlyException.SameMessage("知识库数据错误");
			if (knowledge.Status == EKnowledgeStatus.OnShelf || knowledge.Status == EKnowledgeStatus.Auditing)
				throw UserFriendlyException.SameMessage("知识库数据不可修改");
			_mapper.Map(dto.Data, knowledge);
			if (update.Tags.Any()) await _repositoryts.UpdateVectorAsync(update.Id, update.Tags, HttpContext.RequestAborted);
			if (dto.Workflow != null)
			{
				var startDto = _mapper.Map<StartWorkflowDto>(dto.Workflow);
				startDto.DefinitionModuleCode = WorkflowModuleConsts.KnowledgeAdd;
				startDto.Title = "知识库修改";
				await StartFlow(update.Id, WorkflowModuleConsts.KnowledgeUpdate, EKnowledgeApplyType.Update, startDto);
				knowledge.Status = EKnowledgeStatus.Auditing;
			}
			await _knowledgeRepository.UpdateAsync(knowledge, HttpContext.RequestAborted);
		}

		/// <summary>
		/// 删除知识
		/// </summary>
		/// <param name="id"></param>
		/// <returns></returns>
		[Permission(EPermission.KnowledgeDraftsDelete)]
		[HttpDelete]
		public async Task Remove([FromBody] DeleteStartFlowDto dto)
		{
			var delete = _mapper.Map<Knowledge>(dto.Data);
			var knowledge = await _knowledgeRepository.GetAsync(delete.Id, HttpContext.RequestAborted);
			if (knowledge == null) return;
			if (knowledge.Status == EKnowledgeStatus.OnShelf || knowledge.Status == EKnowledgeStatus.Auditing)
				throw UserFriendlyException.SameMessage("知识库数据不可删除");
			//await _knowledgeRepository.RemoveAsync(knowledge, false, HttpContext.RequestAborted);
			knowledge.Status = EKnowledgeStatus.Auditing;
			await _knowledgeRepository.UpdateAsync(knowledge, HttpContext.RequestAborted);
			var startDto = _mapper.Map<StartWorkflowDto>(dto.Workflow);
			startDto.DefinitionModuleCode = WorkflowModuleConsts.KnowledgeDelete;
			startDto.Title = "知识库删除";
			await StartFlow(delete.Id, WorkflowModuleConsts.KnowledgeDelete, EKnowledgeApplyType.Delete, startDto);
		}

		/// <summary>
		/// 知识库-知识修改-查询详情
		/// </summary>
		/// <param name="Id"></param>
		/// <returns></returns>
		[HttpGet("updateinfo/{Id}")]
		public async Task<KnowledgeInfoDto> KnowledgeUpdateInfo(string Id)
		{
			var know = await _knowledgeRepository.GetAsync(Id, HttpContext.RequestAborted);
			if (know is null)
				throw UserFriendlyException.SameMessage("知识查询失败！");

			var knowledgeInfoDto = _mapper.Map<KnowledgeInfoDto>(know);
			//分类
			var type = await _knowledgeTypeRepository.GetAsync(know.KnowledgeTypeId, HttpContext.RequestAborted);
			if (type != null)
				knowledgeInfoDto.KnowledgeTypeName = type.SpliceName;

			//热点
			var hot = await _hotspotTypeRepository.GetAsync(know.HotspotId, HttpContext.RequestAborted);
			if (hot != null)
				knowledgeInfoDto.HotspotName = hot.HotSpotFullName;
			//收藏
			var collect = await _knowledgeCollectRepository.GetAsync(x => x.KnowledgeId == Id && x.CreatorId == _sessionContext.UserId);
			if (collect != null)
				knowledgeInfoDto.Collect = _mapper.Map<KnowledgeCollectDto>(collect);

			return knowledgeInfoDto;
		}

		/// <summary>
		/// 知识库-查询详情-增加浏览量
		/// </summary>
		/// <param name="Id">知识Id</param>
		/// <param name="IsAddPv">默认不增加，false不增加，true增加浏览量</param>
		/// <returns></returns>
		[HttpGet("info/{Id}")]
		public async Task<KnowledgeInfoDto> KnowledgeInfo(string Id, bool? IsAddPv)
		{
			var knowledge = await _knowledgeDomainService.KnowledgeInfo(Id, HttpContext.RequestAborted);
			if (knowledge is null)
				throw UserFriendlyException.SameMessage("知识查询失败！");

			//转化
			var knowledgeShowInfoDto = _mapper.Map<KnowledgeInfoDto>(knowledge);

			var type = await _knowledgeTypeRepository.GetAsync(knowledge.KnowledgeTypeId, HttpContext.RequestAborted);
			if (type != null) 
			{
				knowledgeShowInfoDto.KnowledgeTypeName = type.SpliceName;
				knowledgeShowInfoDto.KnowledgeType =_mapper.Map<KnowledgeTypeDto>(type);
			}
			var hot = await _hotspotTypeRepository.GetAsync(knowledge.HotspotId, HttpContext.RequestAborted);
			if (hot != null)
				knowledgeShowInfoDto.HotspotName = hot.HotSpotFullName;
			//收藏
			var collect = await _knowledgeCollectRepository.GetAsync(x => x.KnowledgeId == Id && x.CreatorId == _sessionContext.UserId);
			if (collect != null)
				knowledgeShowInfoDto.Collect = _mapper.Map<KnowledgeCollectDto>(collect);

			if (IsAddPv == true)
				_mediator.Publish(new GetKnowledgeInfoNotify(knowledge));
			return knowledgeShowInfoDto;
		}

		/// <summary>
		/// 知识申请-关联知识-获取知识列表
		/// </summary>
		/// <returns></returns>
		[HttpGet("getknowledge")]
		public async Task<IReadOnlyList<KnowledgeCreateBMDataDto>> GetKnowledge()
		{
			var temp = await _knowledgeRepository
			   .Queryable()
			   .LeftJoin<SystemOrganize>((o, sys) => o.CreatorOrgId == sys.Id)
			   //重新构建数据
			   .Select((o, sys) => new
			   {
				   index = SqlFunc.RowNumber($"{o.Version} desc ", $"{o.Code}"),
				   DepartmentId = sys.Id,
				   Department = sys.Name,
				   o.Id,
				   o.Title,
				   o.Status,
				   o.Code
			   })
		   //将结果合并成一个表
		   .MergeTable()
		   //取第一条数据
		   .Where(d => d.index == 1 && d.Status == EKnowledgeStatus.OnShelf)
		  .ToListAsync();
			//返回数据
			return _mapper.Map<IReadOnlyList<KnowledgeCreateBMDataDto>>(temp);

		}

		/// <summary>
		/// 我的草稿箱
		/// </summary>
		/// <param name="pagedDto"></param>
		/// <returns></returns>
		[Permission(EPermission.KnowledgeMyDraftsList)]
		[HttpGet("mydraftslist")]
		public async Task<PagedDto<KnowledgeDataDto>> MyDraftsList([FromQuery] MyDraftsListPagedDto pagedDto)
		{
			var (total, items) = await _knowledgeRepository
			 .Queryable()
			 .Includes(it => it.User)
			 .Includes(it => it.KnowledgeType)
			 .Where(p => p.CreatorId == _sessionContext.RequiredUserId && p.Status == EKnowledgeStatus.Drafts)
			 .WhereIF(!string.IsNullOrEmpty(pagedDto.Keyword), d => d.Title.Contains(pagedDto.Keyword!))
			 .WhereIF(!string.IsNullOrEmpty(pagedDto.KnowledgeTypeId), d => d.KnowledgeTypeId == pagedDto.KnowledgeTypeId)
			 .WhereIF(pagedDto.StartTime != null, d => d.CreationTime >= pagedDto.StartTime)
			 .WhereIF(pagedDto.EndTime != null, d => d.CreationTime <= pagedDto.EndTime)
			 .OrderByDescending(p => p.CreationTime)
			 .ToPagedListAsync(pagedDto.PageIndex, pagedDto.PageSize, HttpContext.RequestAborted);

			return new PagedDto<KnowledgeDataDto>(total, _mapper.Map<IReadOnlyList<KnowledgeDataDto>>(items));
		}

		/// <summary>
		/// 知识库列表页面枚举值
		/// </summary>
		/// <returns></returns>
		[HttpGet("knowledge-status-data")]
		public async Task<object> KnowledgeStatus()
		{
			return new List<KeyValuePair<int, string>>
			{
				new KeyValuePair<int, string>(1, "审核中"),
				new KeyValuePair<int, string>(3, "已上架"),
				new KeyValuePair<int, string>(4, "已下架")
			};
		}

		/// <summary>
		/// 知识查询
		/// </summary>
		/// <param name="pagedDto"></param>
		/// <returns></returns>
		[Permission(EPermission.KnowledgeAllList)]
		[HttpGet]
		public async Task<PagedDto<KnowledgeDataDto>> GetKnowList([FromQuery] KnowPagedListDto pagedDto)
		{
			var type = new KnowledgeType();
			var hotspot = new Hotspot();
			var organize = new SystemOrganize();
			if (!string.IsNullOrEmpty(pagedDto.KnowledgeTypeId))
				type = await _knowledgeTypeRepository.GetAsync(x => x.Id == pagedDto.KnowledgeTypeId);
			if (!string.IsNullOrEmpty(pagedDto.HotspotId))
				hotspot = await _hotspotTypeRepository.GetAsync(x => x.Id == pagedDto.HotspotId);
			var (total, temp) = await _knowledgeRepository.Queryable()
				.Includes(x => x.User)
				.Includes(x => x.SystemOrganize)
				.Includes(x => x.KnowledgeType)
				.Includes(x => x.HotspotType)
				.Where(o => o.IsDeleted == false)
				.WhereIF(!string.IsNullOrEmpty(pagedDto.Title), x => x.Title.Contains(pagedDto.Title!))
				.WhereIF(pagedDto.Status.HasValue, x => x.Status == pagedDto.Status)
				.WhereIF(pagedDto.IsPublic.HasValue, x => x.IsPublic == pagedDto.IsPublic)
				.WhereIF(!string.IsNullOrEmpty(pagedDto.Summary), x => x.Summary != null && x.Summary.Contains(pagedDto.Summary!))
				.WhereIF(!string.IsNullOrEmpty(pagedDto.KnowledgeTypeId), x => type != null && x.KnowledgeType.SpliceName.EndsWith(type.SpliceName))
				.WhereIF(!string.IsNullOrEmpty(pagedDto.HotspotId), x => hotspot != null && x.HotspotType.HotSpotFullName.EndsWith(hotspot.HotSpotFullName))
				.WhereIF(!string.IsNullOrEmpty(pagedDto.CreateOrgId), x => x.HotspotType.CreatorId != null && x.HotspotType.CreatorId.EndsWith(pagedDto.CreateOrgId!))
				.OrderByDescending(d => d.CreationTime)
				//转分页数据
				.ToPagedListAsync(pagedDto.PageIndex, pagedDto.PageSize, HttpContext.RequestAborted);
			//返回数据
			return new PagedDto<KnowledgeDataDto>(total, _mapper.Map<IReadOnlyList<KnowledgeDataDto>>(temp));
		}

		/// <summary>
		/// 知识检索
		/// </summary>
		/// <param name="pagedDto"></param>
		/// <returns></returns>
		[Permission(EPermission.KnowledgeRetrieval)]
		[HttpGet("knowretrieval")]
		public async Task<PagedDto<KnowledgeRetrievalDataDto>> KnowRetrieval([FromQuery] KnowledgeRetrievalPagedListDto pagedDto)
		{
			var type = new KnowledgeType();
			var hotspot = new Hotspot();
			var organize = new SystemOrganize();
			if (!string.IsNullOrEmpty(pagedDto.KnowledgeTypeId))
				type = await _knowledgeTypeRepository.GetAsync(x => x.Id == pagedDto.KnowledgeTypeId);
			if (!string.IsNullOrEmpty(pagedDto.HotspotId))
				hotspot = await _hotspotTypeRepository.GetAsync(x => x.Id == pagedDto.HotspotId);
			var sugar = _knowledgeRepository
				.Queryable()
				.Includes(x => x.User)
				.Includes(x => x.SystemOrganize)
				.Includes(x => x.KnowledgeType)
				.Includes(x => x.HotspotType)
				.Where(o => o.IsDeleted == false)
				.WhereIF(pagedDto.RetrievalType == EKnowledgeRetrievalType.All && !string.IsNullOrEmpty(pagedDto.Keyword), d => d.Title.Contains(pagedDto.Keyword!) || d.Content.Contains(pagedDto.Keyword!))// || d.Additions.Contains(pagedDto.Keyword)
				.WhereIF(pagedDto.RetrievalType == EKnowledgeRetrievalType.Title && !string.IsNullOrEmpty(pagedDto.Keyword), d => d.Title.Contains(pagedDto.Keyword!))
				.WhereIF(pagedDto.RetrievalType == EKnowledgeRetrievalType.Content && !string.IsNullOrEmpty(pagedDto.Keyword), d => d.Content.Contains(pagedDto.Keyword!))
				.WhereIF(pagedDto.RetrievalType == EKnowledgeRetrievalType.Summary && !string.IsNullOrEmpty(pagedDto.Keyword), d => d.Summary.Contains(pagedDto.Keyword!))
				.WhereIF(!string.IsNullOrEmpty(pagedDto.KnowledgeTypeId), x => type != null && x.KnowledgeType.SpliceName.EndsWith(type.SpliceName))
				.WhereIF(!string.IsNullOrEmpty(pagedDto.HotspotId), x => hotspot != null && x.HotspotType.HotSpotFullName.EndsWith(hotspot.HotSpotFullName))
				.WhereIF(!string.IsNullOrEmpty(pagedDto.CreateOrgId), x => x.HotspotType.CreatorId != null && x.HotspotType.CreatorId.EndsWith(pagedDto.CreateOrgId!))
				.WhereIF(!string.IsNullOrEmpty(pagedDto.Attribution), x => x.Attribution == pagedDto.Attribution!);
			switch (pagedDto.Sort)
			{
				case "2":
					sugar = sugar.OrderByDescending(p => p.Score);
					break;
				case "3":
					sugar = sugar.OrderByDescending(p => p.CreationTime);
					break;
				default:
					sugar = sugar.OrderByDescending(p => p.PageView);
					break;			
			}
			var (total, temp) = await sugar.ToPagedListAsync(pagedDto.PageIndex, pagedDto.PageSize);
			return new PagedDto<KnowledgeRetrievalDataDto>(total, _mapper.Map<IReadOnlyList<KnowledgeRetrievalDataDto>>(temp));
		}
		#endregion

		#region 我的知识删除列表
		/// <summary>
		/// 我的知识删除列表页面枚举值
		/// </summary>
		/// <returns></returns>
		[HttpGet("delete-status-data")]
		public async Task<object> DeleteApplyStatus()
		{
			return EnumExts.GetDescriptions<EKnowledgeWorkFlowStatus>();
		}

		/// <summary>
		/// 我的知识删除列表
		/// </summary>
		/// <param name="pagedDto"></param>
		/// <returns></returns>
		[HttpGet("deletelist")]
		[Permission(EPermission.KnowledgeDeleteApply)]
		public async Task<PagedDto<KnowledgeDeleteApplyDataDto>> GetDeleteApplyList([FromQuery] KnowledgeDeletelPagedListDto pagedDto)
		{
			var (total, items) = await _knowledgeWorkFlowRepository
			   .Queryable(includeDeleted: true)
			   .Includes(it => it.Knowledge)
			   .Includes(it => it.User)
			   .Includes(it => it.SystemOrganize)
			   .Includes(it => it.Knowledge, it => it.KnowledgeType)
			   .Includes(it => it.Knowledge, it => it.HotspotType)
			   .Includes(it => it.Workflow)
			   .Where(d => d.CreatorId == _sessionContext.RequiredUserId && d.WorkflowModuleStatus == EKnowledgeApplyType.Delete && d.WorkflowId != null)
			   .WhereIF(pagedDto.EKnowledgeWorkFlowStatus.HasValue, d => d.WorkFlowApplyStatus == pagedDto.EKnowledgeWorkFlowStatus)
			   .WhereIF(pagedDto.StartApplyTime.HasValue, d => d.CreationTime >= pagedDto.StartApplyTime)
			   .WhereIF(pagedDto.EndApplyTime.HasValue, d => d.CreationTime <= pagedDto.EndApplyTime)
			   .WhereIF(!string.IsNullOrEmpty(pagedDto.Keyword), d => d.Knowledge.User.Name.Contains(pagedDto.Keyword!)
			   || d.Knowledge.SystemOrganize.Name.Contains(pagedDto.Keyword!)
			   || d.Knowledge.Title.Contains(pagedDto.Keyword!))

			   .OrderByDescending(p => p.CreationTime)
			   .ToPagedListAsync(pagedDto.PageIndex, pagedDto.PageSize, HttpContext.RequestAborted);

			return new PagedDto<KnowledgeDeleteApplyDataDto>(total, _mapper.Map<IReadOnlyList<KnowledgeDeleteApplyDataDto>>(items));
		}

		/// <summary>
		/// 审核管理页面枚举值
		/// </summary>
		/// <returns></returns>
		[HttpGet("approval-base-data")]
		public async Task<object> ApprovalBaseData()
		{
			return new
			{
				EKnowledgeWorkFlowStatus = EnumExts.GetDescriptions<EKnowledgeWorkFlowStatus>(),
				EKnowledgeApplyType = EnumExts.GetDescriptions<EKnowledgeApplyType>()
			};
		}

		/// <summary>
		/// 审核管理
		/// </summary>
		/// <param name="pagedDto"></param>
		/// <returns></returns>
		[Permission(EPermission.KnowledgeApprovedAllList)]
		[HttpGet("approvedlist")]
		public async Task<PagedDto<KnowledgeApprovalDataDto>> ApprovedList([FromQuery] KnowledgeApprovalPagedListDto pagedDto)
		{
			var (total, items) = await _knowledgeWorkFlowRepository
				.Queryable(includeDeleted: true)
				.Includes(it => it.Knowledge)
				.Includes(it => it.User)
				.Includes(it => it.SystemOrganize)
				.Includes(it => it.Knowledge, it => it.KnowledgeType)
				.Includes(it => it.Workflow)
				.Where(it => it.WorkflowId != null)
				.WhereIF(pagedDto.EKnowledgeApplyType.HasValue, d => d.WorkflowModuleStatus == pagedDto.EKnowledgeApplyType)
				.WhereIF(pagedDto.EKnowledgeWorkFlowStatus.HasValue, d => d.WorkFlowApplyStatus == pagedDto.EKnowledgeWorkFlowStatus)
				.WhereIF(!string.IsNullOrEmpty(pagedDto.Keyword), d => d.Knowledge.User.Name.Contains(pagedDto.Keyword!)
				|| d.Knowledge.SystemOrganize.Name.Contains(pagedDto.Keyword!)
				|| d.Knowledge.Title.Contains(pagedDto.Keyword!))

				.OrderByDescending(p => p.CreationTime)
				.ToPagedListAsync(pagedDto.PageIndex, pagedDto.PageSize, HttpContext.RequestAborted);

			foreach (var item in items)
			{
				if (item.Workflow != null)
					item.CanHandle = item.Workflow.CanHandle(_sessionContext.RequiredUserId, _sessionContext.RequiredOrgId);

			}
			//处理是否可以办理
			//items.ForEach(d => d.CanHandle = d.Workflow.CanHandle(_sessionContext.RequiredUserId, _sessionContext.RequiredOrgCode));

			return new PagedDto<KnowledgeApprovalDataDto>(total, _mapper.Map<IReadOnlyList<KnowledgeApprovalDataDto>>(items));
		}

		/// <summary>
		/// 获取知识热点词
		/// </summary>
		/// <returns></returns>
		[HttpGet("getkeyword")]
		public async Task<List<string>> GetKeyWord()
		{
			return await _knowledgeDomainService.GetKeyWord();
		}

		/// <summary>
		/// 工单受理知识检索
		/// </summary>
		/// <param name="pagedDto"></param>
		/// <returns></returns>
		[HttpGet("knowpopscreen")]
		public async Task<PagedDto<KnowledgeRetrievalDataDto>> KnowPopScreen([FromQuery] KnowledgePopScreenPagedListDto pagedDto)
		{
			RefAsync<int> total = 0;
			var temp = await _knowledgeRepository
			  .Queryable()
			  .Select(o => new
			  {
				  index = SqlFunc.RowNumber($"{o.Version} desc ", $"{o.Code}"),
				  o.Id,
				  o.Code,
				  o.Title,
				  o.Summary,
				  o.Content,
				  o.PageView,
				  o.Keywords,
				  o.HotspotId,
				  o.Status
			  })
		   //将结果合并成一个表
		   .MergeTable()
		   //取第一条数据
		   .Where(d => d.index == 1 && d.Status == EKnowledgeStatus.OnShelf)
		   .WhereIF(!string.IsNullOrEmpty(pagedDto.Keyword), p => p.Title.Contains(pagedDto.Keyword) || p.Keywords.Contains(pagedDto.Keyword))
		   .WhereIF(!string.IsNullOrEmpty(pagedDto.HotspotId), p => p.HotspotId == pagedDto.HotspotId)
		   .OrderByDescending(p => p.PageView)
		   .ToPageListAsync(pagedDto.PageIndex, pagedDto.PageSize, total);

			return new PagedDto<KnowledgeRetrievalDataDto>(total, _mapper.Map<IReadOnlyList<KnowledgeRetrievalDataDto>>(temp));
		}

		///// <summary>
		///// 新增-开始流程
		///// </summary>
		///// <param name="id">知识id</param>
		///// <param name="dto">流程开启参数</param>
		///// <returns></returns>
		//[Permission(EPermission.AddKnowledge)]
		//[HttpPost("{id}/add-startflow")]
		//public async Task AddStartFlow(string id, [FromBody] StartWorkflowDto dto)
		//{
		//	await StartFlow(id, WorkflowModuleConsts.KnowledgeAdd, EKnowledgeApplyType.Add, dto);
		//}

		///// <summary>
		///// 删除-开始流程
		///// </summary>
		///// <param name="id">知识id</param>
		///// <param name="dto">流程开启参数</param>
		///// <returns></returns>
		//[Permission(EPermission.KnowledgeDelete)]
		//[HttpPost("{id}/remove-startflow")]
		//public async Task RemoveStartFlow(string id, [FromBody] StartWorkflowDto dto)
		//{
		//	await StartFlow(id, WorkflowModuleConsts.KnowledgeDelete, EKnowledgeApplyType.Delete, dto);
		//}

		/// <summary>
		/// 查询知识库办理流程开启参数-新增
		/// </summary>
		/// <returns></returns>
		//[Permission(EPermission.AddKnowledge)]
		[HttpGet("add-flow-start")]
		public async Task<NextStepsDto> GetAddFlowStartOptionsAsync()
		{
			return await _workflowApplication.GetStartStepsAsync(WorkflowModuleConsts.KnowledgeAdd,
				HttpContext.RequestAborted);
		}

		/// <summary>
		/// 查询知识库办理流程开启参数-新增
		/// </summary>
		/// <returns></returns>
		//[Permission(EPermission.AddKnowledge)]
		[HttpGet("update-flow-start")]
		public async Task<NextStepsDto> GetUpdateFlowStartOptionsAsync()
		{
			return await _workflowApplication.GetStartStepsAsync(WorkflowModuleConsts.KnowledgeUpdate,
				HttpContext.RequestAborted);
		}

		/// <summary>
		/// 查询知识库办理流程开启参数-删除
		/// </summary>
		/// <returns></returns>
		//[Permission(EPermission.KnowledgeDelete)]
		[HttpGet("remove-flow-start")]
		public async Task<NextStepsDto> GetRemoveFlowStartOptionsAsync()
		{
			return await _workflowApplication.GetStartStepsAsync(WorkflowModuleConsts.KnowledgeDelete,
				HttpContext.RequestAborted);
		}

		/// <summary>
		/// 开始流程
		/// </summary>
		/// <param name="id">知识ID</param>
		/// <param name="moduleCode">知识模板编号</param>
		/// <param name="eKnowledgeApplyType">申请类型</param>
		/// <param name="dto">流程开启参数</param>
		/// <returns></returns>
		private async Task StartFlow(string id, string moduleCode, EKnowledgeApplyType eKnowledgeApplyType, StartWorkflowDto dto)
		{
			var knowledge = await _knowledgeRepository.GetAsync(id, HttpContext.RequestAborted);
			if (knowledge == null)
				throw UserFriendlyException.SameMessage("无效知识编号");

			if (eKnowledgeApplyType == EKnowledgeApplyType.Delete)
			{
				if (knowledge.IsDeleted == true)
					throw UserFriendlyException.SameMessage("知识删除失败");

				//验证是否已经发起过知识删除流程
				var exists = await _knowledgeWorkFlowRepository.GetAsync(p => p.KnowledgeId == knowledge.Id && p.WorkflowModuleStatus == EKnowledgeApplyType.Delete
				&& (p.WorkFlowApplyStatus == EKnowledgeWorkFlowStatus.Success || p.WorkFlowApplyStatus == EKnowledgeWorkFlowStatus.Auditing) && p.WorkflowId != null);
				if (exists != null)
					throw UserFriendlyException.SameMessage($"该知识已发起过{/*WorkflowModule.Modules[WorkflowModuleConsts.KnowledgeDelete]*/WorkflowModuleConsts.KnowledgeDelete}流程");//todo
			}

			//if (!string.IsNullOrEmpty(knowledge.WorkflowId) && eKnowledgeApplyType != EKnowledgeApplyType.Delete)
			//	throw UserFriendlyException.SameMessage("知识已发起流程");

			//知识审批主表
			var flowId = await _knowledgeDomainService.AddWorkFlowAsync(id, eKnowledgeApplyType, HttpContext.RequestAborted);

			dto.DefinitionModuleCode = moduleCode;
			dto.Title = knowledge.Title;
			await _workflowApplication.StartWorkflowAsync(dto, flowId, HttpContext.RequestAborted);

		}
		#endregion

		#region 知识库词库
		/// <summary>
		/// 新增知识库词库
		/// </summary>
		/// <param name="dtos"></param>
		/// <returns></returns>
		[Permission(EPermission.AddKnowledgeWord)]
		[HttpPost("knowledge_word")]
		public async Task Add([FromBody] KnowledgeWordAddDto dto)
		{
			var word = _mapper.Map<KnowledgeWord>(dto);
			await _knowledgeWrodRepository.AddAsync(word, HttpContext.RequestAborted);
		}

		/// <summary>
		/// 删除知识库词库
		/// </summary>
		/// <param name="dto"></param>
		/// <returns></returns>
		[Permission(EPermission.DeleteKnowledgeWord)]
		[HttpDelete("knowledge_word")]
		public async Task Delete([FromBody] KnowledgeWordDeleteDto dto)
		{
			await _knowledgeRepository.RemoveKnowledgeWrodBatchAsync(dto.Ids, HttpContext.RequestAborted);
		}

		/// <summary>
		/// 更新知识库词库
		/// </summary>
		/// <param name="dto"></param>
		/// <returns></returns>
		[Permission(EPermission.UpdateKnowledgeWord)]
		[HttpPut("knowledge_word")]
		public async Task Update([FromBody] KnowledgeWordUpdateDto dto)
		{
			var word = await _knowledgeWrodRepository.GetAsync(dto.Id, HttpContext.RequestAborted);
			if (word is null)
				throw UserFriendlyException.SameMessage("无效知识库词库");
			_mapper.Map(dto, word);
			word.LastModificationName = _sessionContext.UserName;
			await _knowledgeWrodRepository.UpdateAsync(word, HttpContext.RequestAborted);
		}

		/// <summary>
		/// 获取知识库词库列表
		/// </summary>
		/// <param name="dto"></param>
		/// <returns></returns>
		[Permission(EPermission.KnowledgeWordList)]
		[HttpGet("knowledge_word/list")]
		public async Task<PagedDto<KnowledgeWordDto>> List([FromQuery] KnowledgeWordListDto dto)
		{
			var (total, items) = await _knowledgeWrodRepository.Queryable()
				.WhereIF(!string.IsNullOrEmpty(dto.Tag), x => x.Tag == dto.Tag!)
				.WhereIF(!string.IsNullOrEmpty(dto.Classify), x => x.Classify == dto.Classify!)
				.WhereIF(!string.IsNullOrEmpty(dto.Synonym), x => x.Synonym != null && x.Synonym.Contains(dto.Synonym!))
				.OrderByDescending(x => x.CreationTime)
				.ToPagedListAsync(dto.PageIndex, dto.PageSize, HttpContext.RequestAborted);
			return new PagedDto<KnowledgeWordDto>(total, _mapper.Map<IReadOnlyList<KnowledgeWordDto>>(items));
		}

		/// <summary>
		/// 获取知识库词库
		/// </summary>
		/// <param name="id"></param>
		/// <returns></returns>
		[HttpGet("knowledge_word/{id}")]
		public async Task<KnowledgeWord> WordEntity(string id)
		{
			return await _knowledgeWrodRepository.Queryable()
				.FirstAsync(x => x.Id == id);
		}

		/// <summary>
		/// 获取知识库词库基本信息
		/// </summary>
		/// <returns></returns>
		[HttpGet("knowledge_word/base")]
		public async Task<object> Base()
		{
			var rsp = new
			{
				KnowledgeWordClassify = await _systemDomainService.GetSysDicDataByCodeAsync(SysDicTypeConsts.KnowledgeWordClassify),
			};
			return rsp;
		}
		#endregion

		#region 知识纠错
		/// <summary>
		/// 新增知识纠错
		/// </summary>
		/// <param name="dtos"></param>
		/// <returns></returns>
		[Permission(EPermission.AddKnowledgeCorrection)]
		[HttpPost("knowledge_correction")]
		public async Task Add([FromBody] KnowledgeCorrectionAddDto dto)
		{
			var correction = _mapper.Map<KnowledgeCorrection>(dto);
			await _knowledgeCorrectionRepository.AddAsync(correction, HttpContext.RequestAborted);
		}

		/// <summary>
		/// 删除知识纠错
		/// </summary>
		/// <param name="dto"></param>
		/// <returns></returns>
		[Permission(EPermission.DeleteKnowledgeCorrection)]
		[HttpDelete("knowledge_correction")]
		public async Task Delete([FromBody] KnowledgeCorrectionDeleteDto dto)
		{
			await _knowledgeCorrectionRepository.RemoveAsync(x => x.Id == dto.Id);
		}

		/// <summary>
		/// 更新知识纠错
		/// </summary>
		/// <param name="dto"></param>
		/// <returns></returns>
		[Permission(EPermission.UpdateKnowledgeCorrection)]
		[HttpPut("knowledge_correction")]
		public async Task Update([FromBody] KnowledgeCorrectionUpdateDto dto)
		{
			var correction = await _knowledgeCorrectionRepository.GetAsync(dto.Id, HttpContext.RequestAborted);
			if (correction is null)
				throw UserFriendlyException.SameMessage("无效知识纠错");
			_mapper.Map(dto, correction);
			await _knowledgeCorrectionRepository.UpdateAsync(correction, HttpContext.RequestAborted);
		}

		/// <summary>
		/// 答复知识纠错
		/// </summary>
		/// <param name="dto"></param>
		/// <returns></returns>
		[Permission(EPermission.UpdateKnowledgeCorrection)]
		[HttpPut("knowledge_correction/Reply")]
		public async Task Reply([FromBody] KnowledgeCorrectionUpdateDto dto)
		{
			var correction = await _knowledgeCorrectionRepository.GetAsync(dto.Id, HttpContext.RequestAborted);
			if (correction is null)
				throw UserFriendlyException.SameMessage("无效知识纠错");
			_mapper.Map(dto, correction);
			correction.ReplyTime = DateTime.Now;
			correction.ReplyUserName = _sessionContext.UserName;
			correction.State = ECorrectionState.AlreadyAnswered;
			await _knowledgeCorrectionRepository.UpdateAsync(correction, HttpContext.RequestAborted);
		}

		/// <summary>
		/// 获取知识纠错列表
		/// </summary>
		/// <param name="dto"></param>
		/// <returns></returns>
		[Permission(EPermission.KnowledgeCorrectionList)]
		[HttpGet("knowledge_correction/list")]
		public async Task<PagedDto<KnowledgeCorrectionDto>> List([FromQuery] KnowledgeCorrectionListDto dto)
		{
			var (total, items) = await _knowledgeCorrectionRepository.Queryable()
				.Includes(x => x.Knowledge)
				.Includes(x => x.Knowledge, y => y.KnowledgeType)
				.WhereIF(!string.IsNullOrEmpty(dto.KnowledgeTypeId), x => x.Knowledge.KnowledgeTypeId == dto.KnowledgeTypeId!)
				.WhereIF(!string.IsNullOrEmpty(dto.CreatorName), x => x.CreatorName == dto.CreatorName!)
				.OrderByDescending(x => x.CreationTime)
				.ToPagedListAsync(dto.PageIndex, dto.PageSize, HttpContext.RequestAborted);
			return new PagedDto<KnowledgeCorrectionDto>(total, _mapper.Map<IReadOnlyList<KnowledgeCorrectionDto>>(items));
		}

		/// <summary>
		/// 获取知识库纠错
		/// </summary>
		/// <param name="id"></param>
		/// <returns></returns>
		[Permission(EPermission.KnowledgeCorrectionEntity)]
		[HttpGet("knowledge_correction/{id}")]
		public async Task<KnowledgeCorrection> CorrectionEntity(string id)
		{
			return await _knowledgeCorrectionRepository.Queryable()
				.Includes(x=>x.Knowledge)
				.FirstAsync(x => x.Id == id);
		}
		#endregion

		#region 知识提问
		/// <summary>
		/// 新增知识提问
		/// </summary>
		/// <param name="dtos"></param>
		/// <returns></returns>
		[Permission(EPermission.AddKnowledgeQuestions)]
		[HttpPost("knowledge_questions")]
		public async Task Add([FromBody] KnowledgeQuestionsAddDto dto)
		{
			var questions = _mapper.Map<KnowledgeQuestions>(dto);
			await _knowledgeQuestionsRepository.AddAsync(questions, HttpContext.RequestAborted);
		}

		/// <summary>
		/// 删除知识提问
		/// </summary>
		/// <param name="dto"></param>
		/// <returns></returns>
		[Permission(EPermission.DeleteKnowledgeQuestions)]
		[HttpDelete("knowledge_questions")]
		public async Task Delete([FromBody] KnowledgeQuestionsDeleteDto dto)
		{
			await _knowledgeQuestionsRepository.RemoveAsync(x => x.Id == dto.Id);
		}

		/// <summary>
		/// 更新知识提问
		/// </summary>
		/// <param name="dto"></param>
		/// <returns></returns>
		[Permission(EPermission.UpdateKnowledgeQuestions)]
		[HttpPut("knowledge_questions")]
		public async Task Update([FromBody] KnowledgeQuestionsUpdateDto dto)
		{
			var questions = await _knowledgeQuestionsRepository.GetAsync(dto.Id, HttpContext.RequestAborted);
			if (questions is null)
				throw UserFriendlyException.SameMessage("无效知识提问");
			_mapper.Map(dto, questions);
			await _knowledgeQuestionsRepository.UpdateAsync(questions, HttpContext.RequestAborted);
		}

		/// <summary>
		/// 答复知识提问
		/// </summary>
		/// <param name="dto"></param>
		/// <returns></returns>
		[Permission(EPermission.UpdateKnowledgeQuestions)]
		[HttpPut("knowledge_questions/Reply")]
		public async Task Reply([FromBody] KnowledgeQuestionsUpdateDto dto)
		{
			var questions = await _knowledgeQuestionsRepository.GetAsync(dto.Id, HttpContext.RequestAborted);
			if (questions is null)
				throw UserFriendlyException.SameMessage("无效知识提问");
			_mapper.Map(dto, questions);
			questions.ReplyTime = DateTime.Now;
			questions.ReplyUserName = _sessionContext.UserName;
			questions.State = ECorrectionState.AlreadyAnswered;
			await _knowledgeQuestionsRepository.UpdateAsync(questions, HttpContext.RequestAborted);
		}

		/// <summary>
		/// 获取知识提问列表
		/// </summary>
		/// <param name="dto"></param>
		/// <returns></returns>
		[Permission(EPermission.KnowledgeQuestionsList)]
		[HttpGet("knowledge_questions/list")]
		public async Task<PagedDto<KnowledgeQuestionsDto>> List([FromQuery] KnowledgeQuestionsListDto dto)
		{
			var (total, items) = await _knowledgeQuestionsRepository.Queryable()
				.Includes(x => x.Knowledge)
				.Includes(x => x.Knowledge, y => y.KnowledgeType)
				.WhereIF(!string.IsNullOrEmpty(dto.KnowledgeTypeId), x => x.Knowledge.KnowledgeTypeId == dto.KnowledgeTypeId!)
				.WhereIF(!string.IsNullOrEmpty(dto.CreatorName), x => x.CreatorName == dto.CreatorName!)
				.OrderByDescending(x => x.CreationTime)
				.ToPagedListAsync(dto.PageIndex, dto.PageSize, HttpContext.RequestAborted);
			return new PagedDto<KnowledgeQuestionsDto>(total, _mapper.Map<IReadOnlyList<KnowledgeQuestionsDto>>(items));
		}

		/// <summary>
		/// 获取知识提问
		/// </summary>
		/// <param name="id"></param>
		/// <returns></returns>
		[Permission(EPermission.KnowledgeQuestionsEntity)]
		[HttpGet("knowledge_questions/{id}")]
		public async Task<KnowledgeQuestions> QuestionsEntity(string id)
		{
			return await _knowledgeQuestionsRepository.Queryable()
				.Includes(x=>x.Knowledge)
				.FirstAsync(x => x.Id == id);
		}

		#endregion

		#region 知识收藏
		/// <summary>
		/// 新增知识收藏
		/// </summary>
		/// <param name="dtos"></param>
		/// <returns></returns>
		[Permission(EPermission.AddKnowledgeCollect)]
		[HttpPost("knowledge_collect")]
		public async Task Add([FromBody] KnowledgeCollectAddDto dto)
		{
			var collect = await _knowledgeCollectRepository.GetAsync(x => x.KnowledgeId == dto.KnowledgeId && x.CreatorId == _sessionContext.UserId);
			if (collect != null)
			{
				collect.Collect = dto.Collect;
				await _knowledgeCollectRepository.UpdateAsync(collect, HttpContext.RequestAborted);
			}
			else {
				var collectNew = _mapper.Map<KnowledgeCollect>(dto);
				await _knowledgeCollectRepository.AddAsync(collectNew, HttpContext.RequestAborted);
			}
		}

		/// <summary>
		/// 知识评分
		/// </summary>
		/// <param name="dto"></param>
		/// <returns></returns>
		[Permission(EPermission.AddKnowledgeScore)]
		[HttpDelete("knowledge_score")]
		public async Task Delete([FromBody] KnowledgeCollectAddDto dto)
		{
			var collect = await _knowledgeCollectRepository.GetAsync(x => x.KnowledgeId == dto.KnowledgeId && x.CreatorId == _sessionContext.UserId);
			if (collect != null)
			{
				if (collect.Score > 0)
					throw UserFriendlyException.SameMessage("当前知识已经评分");
				collect.Score = dto.Score;
				await _knowledgeCollectRepository.UpdateAsync(collect, HttpContext.RequestAborted);
			}
			else
			{
				var questions = _mapper.Map<KnowledgeCollect>(dto);
				await _knowledgeCollectRepository.AddAsync(questions, HttpContext.RequestAborted);
			}
			//计算总分
			var sugar = _knowledgeCollectRepository.Queryable().Where(x => x.KnowledgeId == dto.KnowledgeId);
			var count = await sugar.CountAsync();
			var collects = await sugar.SumAsync(x => x.Score);
			var score = collects / count;
			var knowledge = await _knowledgeRepository.GetAsync(x => x.Id == dto.KnowledgeId);
			if (knowledge != null)
			{
				knowledge.Score = score;
				await _knowledgeRepository.UpdateAsync(knowledge, HttpContext.RequestAborted);
			}
		}
		#endregion
	}
}