using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using System.Transactions;
using AutoMapper;
using Datory;
using GxPress.Common.Exceptions;
using GxPress.Common.Page;
using GxPress.Common.Tools;
using GxPress.Repository.Interface;
using GxPress.Repository.Interface.Collection;
using GxPress.Repository.Interface.Missive;
using GxPress.Repository.Interface.Note;
using GxPress.Repository.Interface.Visit;
using GxPress.Request.Analyze;
using GxPress.Request.App.Middle;
using GxPress.Request.App.Note;
using GxPress.Result;
using GxPress.Result.App.Note;
using GxPress.Service.Interface.Analyze;
using GxPress.Service.Interface.Middle;
using GxPress.Service.Interface.Note;
using GxPress.Service.Interface.Visit;
using Newtonsoft.Json;
using GxPress.Service.Interface.UserMiddle;
using GxPress.Repository.Interface.RecordFolder;
using GxPress.EnumConst;
using GxPress.Request.App.Analyze;
using GxPress.Result.Web;
using GxPress.Request.Web;
using GxPress.Repository.Interface.Media;
using GxPress.Service.Interface.CommonSqlKata;

namespace GxPress.Service.Implement.Note
{
    public class NoteService : INoteService
    {
        private readonly IMiddleService _middleService;
        private readonly INoteRepository _noteRepository;
        private readonly IMiddleRepository _middleRepository;
        private readonly IUserRepository _userRepository;
        private readonly IMapper _mapper;
        private readonly IArticleRepository _articleRepository;
        private readonly INoticeRepository _noticeRepository;
        private readonly IMissiveRepository _missiveRepository;
        private readonly ITopicRepository _topicRepository;
        private readonly IGroupRepository _groupRepository;
        private readonly ICollectionRepository _collectionRepository;
        private readonly ICommentRepository _commentRepository;
        private readonly IVisitRepository _visitRepository;
        private readonly IVisitService _visitService;
        private readonly IFolderUserRepository _folderUserRepository;
        private readonly IAnalyzeService _analyzeService;
        private readonly IUserMiddleService _userMiddleService;
        private readonly IRecordFolderRepository recordFolderRepository;
        private readonly IMediaRepository mediaRepository;
        private readonly ICommonSqlKataService commonSqlKataService;
        public NoteService(IMiddleService middleService, INoteRepository noteRepository,
            IMiddleRepository middleRepository, IMapper mapper, IUserRepository userRepository,
            IArticleRepository articleRepository, INoticeRepository noticeRepository,
            IMissiveRepository missiveRepository, ITopicRepository topicRepository, IGroupRepository groupRepository,
            ICollectionRepository collectionRepository, ICommentRepository commentRepository,
            IVisitRepository visitRepository,
            IVisitService visitService,
            IFolderUserRepository folderUserRepository,
            IAnalyzeService analyzeService,
            IUserMiddleService userMiddleService,
            IRecordFolderRepository recordFolderRepository,
            IMediaRepository mediaRepository, ICommonSqlKataService commonSqlKataService)
        {
            _middleService = middleService;
            _noteRepository = noteRepository;
            _middleRepository = middleRepository;
            _mapper = mapper;
            _userRepository = userRepository;
            _articleRepository = articleRepository;
            _missiveRepository = missiveRepository;
            _noteRepository = noteRepository;
            _noticeRepository = noticeRepository;
            _topicRepository = topicRepository;
            _groupRepository = groupRepository;
            _collectionRepository = collectionRepository;
            _commentRepository = commentRepository;
            _visitRepository = visitRepository;
            _visitService = visitService;
            _folderUserRepository = folderUserRepository;
            _analyzeService = analyzeService;
            _userMiddleService = userMiddleService;
            this.recordFolderRepository = recordFolderRepository;
            this.mediaRepository = mediaRepository;
            this.commonSqlKataService = commonSqlKataService;
        }

        /// <summary>
        /// 添加个人笔记
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        public async Task<NoteAddOrModifyResult> InsertNoteAsync(NoteInRequest request)
        {
            var result = new NoteAddOrModifyResult();
            try
            {
                using (TransactionScope transactionScope = new TransactionScope())
                {
                    if (string.IsNullOrEmpty(request.Content))
                        throw new BusinessException("内容未填写");
                    var noteContent = JsonConvert.DeserializeObject<List<ContentJsonData>>(request.Content);
                    var textContent = string.Empty;
                    foreach (var item in noteContent)
                    {
                        item.File = StringUtils.RemoveDomain(item.File);
                        if (item.Type == AllTypeConst.Text.GetHashCode())
                            textContent += item.Text;
                    }
                    //获取公开
                    if (request.FolderId == 0 && request.IsTopic)
                        request.FolderId = await _middleRepository.GetSytemFolderAsync(request.UserId);
                    //添加笔记
                    var note = new Entity.Note.Note
                    {
                        Title = request.Title,
                        Content = JsonConvert.SerializeObject(noteContent),
                        HtmlContent = request.HtmlContent,
                        UserId = request.UserId,
                        IsDelete = false,
                        IsTopic = request.IsTopic,
                        FolderId = request.FolderId,
                        MediaId = request.MediaId,
                        MediaType = request.MediaType,
                        CatalogId = request.CatalogId,
                        ChapterId = request.ChapterId,
                        TextContent = textContent,
                        //是否草稿
                        IsDraft = request.IsDraft,
                        Id = request.Id
                    };
                    if (note.Id > 0)
                        return await UpdateNoteAsync(note);
                    var noteId = await _noteRepository.InsertAsync(note);
                    if (!request.IsDraft)
                    {
                        //添加中间件
                        var middleInsertTypes = new MiddleInsertTypeRequest
                        {
                            FolderId = request.FolderId,
                            MiddleId = noteId,
                            FolderType = request.IsTopic ? AllTypeConst.TopicNote.GetHashCode() : AllTypeConst.Note.GetHashCode(),
                            UserId = request.UserId,
                            MiddleSonId = 0,
                            AttributeValue = 1,
                            IsAdmin = true
                        };
                        await _middleService.InsertAsync(middleInsertTypes);
                        //修改话题访问量
                        await _visitService.AddVisit(request.UserId, middleInsertTypes.FolderType, noteId);
                    }
                    //添加默认文件夹
                    await recordFolderRepository.AddAsync(request.IsTopic ? AllTypeConst.TopicNote.GetHashCode() : AllTypeConst.Note.GetHashCode(), request.UserId, request.FolderId);
                    var middle = await _middleRepository.GetMiddleAsync(request.FolderId);
                    result.Id = noteId;
                    result.FolderId = request.FolderId;
                    result.FolderName = middle == null ? "根目录" : middle.FolderName;
                    transactionScope.Complete();
                }
            }
            catch (Exception e)
            {
                Console.WriteLine(e);
                throw;
            }
            return result;
        }
        /// <summary>
        /// 获取笔记/话题草稿分页
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        public async Task<PagedList<NoteNotFolderPageResult>> NoteTopicDraftPageListAsync(NoteSearchPageListRequest request)
        {
            var result = await _noteRepository.NoteTopicDraftPageListAsync(request);
            foreach (var item in result.Items)
            {
                if (string.IsNullOrEmpty(item.FolderName))
                    item.FolderName = "根目录";
                if (string.IsNullOrEmpty(item.Title))
                    item.Title = string.Empty;
                item.MiddleId = item.Id;
                //是否摘录
                if (item.MediaId > 0)
                {
                    item.IsExtract = true;
                    var query = Q.NewQuery();
                    query.Where(nameof(Entity.tede2.Media.Media.Id), item.MediaId);
                    item.MediaNoteResult = await mediaRepository.GetAsync(query);
                    if (item.MediaNoteResult != null)
                        item.MediaNoteResult.ImageUrls = StringUtils.AddDomain(item.MediaNoteResult.ImageUrls);
                }
                if (string.IsNullOrWhiteSpace(item.Content))
                    item.Content = "[]";
                var contentJsonData = JsonConvert.DeserializeObject<List<ContentJsonData>>(item.Content);
                foreach (var contentJsonDataItem in contentJsonData)
                    contentJsonDataItem.File = StringUtils.AddDomain(contentJsonDataItem.File);
                if (contentJsonData.Count == 0)
                    item.DataType = 1;
                item.Content = "";
                if (contentJsonData.Count > 0)
                {
                    var imgData = new List<ContentJsonData>();
                    var FileData = new List<ContentJsonData>();
                    var forCount = 1;
                    var firstContent = string.Empty;
                    foreach (var jsonData in contentJsonData)
                    {
                        if (jsonData.TypeValue == AllTypeConst.Text.GetHashCode() && forCount == 1)
                            //文本
                            firstContent = jsonData.Text;
                        else if (jsonData.TypeValue == AllTypeConst.Text.GetHashCode() && forCount > 1)
                            //文本
                            continue;
                        //图片
                        else if (jsonData.TypeValue == AllTypeConst.Image.GetHashCode() && FileData.Count == 0)
                        {
                            if (imgData.Count > 9)
                                break;
                            imgData.Add(jsonData);
                        }
                        //附件
                        else
                        {
                            FileData.Add(jsonData);
                            break;
                        }
                        forCount++;
                    }
                    item.Content = string.IsNullOrWhiteSpace(firstContent) ? "" : firstContent;
                    if (imgData.Count > 0) { item.DataType = 2; item.Data = imgData; }
                    else if (FileData.Count > 0) { item.DataType = 3; item.Data = FileData; }
                    else item.DataType = 1;
                    var contType = new List<int> { AllTypeConst.Text.GetHashCode(), AllTypeConst.Image.GetHashCode() };
                    item.FileCount = contentJsonData.Count(n => !contType.Contains(n.Type));
                }
                if (item.Data == null || item.Data.Count == 0)
                    item.Data = new List<ContentJsonData>();
            }
            return result;
        }
        /// <summary>
        /// 获取笔记分页
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        public async Task<PagedList<NotePageListRequest>> NotePageListAsync(NoteSearchPageListRequest request)
        {
            var typeValue = request.TypeValue == 0 ? AllTypeConst.Note.GetHashCode() : AllTypeConst.TopicNote.GetHashCode();
            var middle = new Entity.Middle.Middle();
            if (request.FolderId > 0 && middle != null)
            {
                middle = await _middleRepository.GetMiddleAsync(request.FolderId);
                if (request.UserId <= 0)
                    request.UserId = middle.UserId;
            }
            var query = new SqlKata.Query("tede_middle");
            query.LeftJoin("tede_note", "tede_note.Id", "tede_middle.MiddleId");
            query.LeftJoin("tede_user", "tede_user.Id", "tede_note.UserId");
            //公用
            query = commonSqlKataService.GetCommonQueryAsync(typeValue, request.UserId, query, "tede_middle.MiddleId");
            var enjoyUser = new SqlKata.Query("tede_user_middle");
            enjoyUser.Where("MiddleType", typeValue);
            enjoyUser.WhereColumns("DataSourceId", "=", "tede_middle.Id");
            enjoyUser.SelectRaw("GROUP_CONCAT(SourceName Separator'、')");
            query.Select(enjoyUser, "EnjoyUser");
            var parameterQuery = new SqlKata.Query("tede_middle as a");
            parameterQuery.WhereColumns("a.Id", "=", "tede_middle.ParentId");
            parameterQuery.Select("a.FolderName");
            query.Select(parameterQuery, "FolderParentName");
            parameterQuery = new SqlKata.Query("tede_middle as b");
            parameterQuery.WhereColumns("b.Id", "=", "tede_middle.ParentId");
            parameterQuery.Select("b.Id");
            query.Select(parameterQuery, "FolderId");
            //文件数量
            parameterQuery = new SqlKata.Query("tede_middle as e");
            parameterQuery.WhereColumns("e.ParentId", "=", "tede_middle.Id");
            parameterQuery.Where("e.IsDelete", false);
            parameterQuery.Where("e.FolderType", typeValue);
            parameterQuery.AsCount();
            query.Select(parameterQuery, "FileCount");
            query.Where("tede_middle.FolderType", typeValue);
            query.Where("tede_middle.IsDelete", false);
            query.Where("tede_middle.UserId", request.VisitUserId > 0 ? request.VisitUserId : request.UserId);
            if (typeValue == AllTypeConst.Note.GetHashCode())
                query.Where(n => n.Where("tede_middle.RoleId", MiddleRoleConst.PrivatelyOwned.GetHashCode())
                .OrWhereIn("tede_middle.AttributeValue", new List<int> { AttributeValueConst.File.GetHashCode(), AttributeValueConst.Folder.GetHashCode() }));
            else
                query.Where(n => n.WhereIn("tede_middle.RoleId", new List<int> { MiddleRoleConst.Publicity.GetHashCode(), MiddleRoleConst.Share.GetHashCode() })
                  .OrWhereIn("tede_middle.AttributeValue", new List<int> { AttributeValueConst.File.GetHashCode(), AttributeValueConst.Folder.GetHashCode() }));
            //判断是否是匿名用户
            if (request.VisitUserId > 0 && request.FolderId == 0)
            {
                // var sqlStr = $"tede_middle.Id";
                // if (request.FolderId > 0)
                //     sqlStr = "tede_middle.ParentId";
                // var userIdQuery = new SqlKata.Query("tede_user as c");
                // userIdQuery.WhereRaw("1=tede_middle.RoleId");
                // userIdQuery.Select("c.Id");
                parameterQuery = new SqlKata.Query("tede_folder_user as d");
                parameterQuery.Where("d.UserId", request.UserId);
                parameterQuery.WhereColumns("d.MiddleId", "=", "tede_middle.Id");
                parameterQuery.Select("MiddleId");
                query.Where(n => n.Where("tede_middle.RoleId", MiddleRoleConst.Publicity.GetHashCode()).OrWhereIn("tede_middle.Id", parameterQuery));
                query.Where("tede_middle.AttributeValue", AttributeValueConst.Folder.GetHashCode());
            }
            if (request.FolderId == 0 && !string.IsNullOrEmpty(request.SearchKey))
            {
                query.Where(n => n.OrWhereLike("tede_note.Title", $"%{request.SearchKey}%")
                .OrWhereLike("tede_middle.FolderName", $"%{request.SearchKey}%")
                .OrWhereLike("tede_note.TextContent", $"%{request.SearchKey}%"));

            }
            if (!string.IsNullOrEmpty(request.SearchKey))
            {
                query.Where("tede_middle.ParentId", request.FolderId);
                query.Where(n => n.OrWhereLike("tede_note.Title", $"%{request.SearchKey}%")
                              .OrWhereLike("tede_middle.FolderName", $"%{request.SearchKey}%")
                              .OrWhereLike("tede_note.TextContent", $"%{request.SearchKey}%"));
            }
            else
                query.Where("tede_middle.ParentId", request.FolderId);
            var countQuery = query;
            query.OrderByDesc("tede_middle.IsSystemDefault");
            query.OrderByDesc("tede_middle.AttributeValue");
            query.OrderByDesc("tede_middle.IsTop");
            query.OrderByDesc("tede_middle.LastModifiedDate");
            query.Select("tede_middle.{Id,MiddleId,RoleId,ParentId,AttributeValue,UserId,CreatedDate,LastModifiedDate,IsTop,FolderName,FolderType}",
                        "tede_note.{Title,Content,ReadCount,MediaId,CatalogId,ChapterId}",
                        "tede_user.{Name,AvatarUrl}");
            request.ResultQuery = query;
            request.CountQuery = countQuery;
            var result = await _noteRepository.NotePageListAsync(request);
            result.DraftCount = await _noteRepository.GetDraftCountAsync(request.UserId, request.TypeValue == 1);
            result.IsDraft = result.DraftCount > 0;
            result.DraftId = await _noteRepository.GetNoteIdByDraftAsync(request.UserId, request.TypeValue == 1);
            if (request.FolderId > 0 && middle != null)
            {
                result.RoleId = middle != null ? middle.RoleId : 0;
                result.ParentId = middle != null ? middle.ParentId : 0;
                result.IsSystemDefault = middle.IsSystemDefault;
            }
            //是否收藏和转发数量
            if (request.VisitUserId > 0)
            {
                var user = await _userRepository.GetAsync(request.VisitUserId);
                result.Author = user.Name;
                var analyzeRequest = new AnalyzeRequest();
                analyzeRequest.SourceUserId = request.VisitUserId;
                analyzeRequest.AnalyzeType = 3;
                analyzeRequest.CommentId = 0;
                analyzeRequest.SourceId = request.FolderId;
                analyzeRequest.UserId = request.UserId;
                analyzeRequest.TypeValue = request.FolderId == 0 ? AllTypeConst.TopicNoteAll.GetHashCode() : AllTypeConst.TopicNoteFolder.GetHashCode();
                result.IsCollect = await _analyzeService.ExistsSourceUserAsync(analyzeRequest);
                analyzeRequest.AnalyzeType = 4;
                result.RetransmissionCount = await _analyzeService.RetransmissionCountAsync(analyzeRequest);
            }
            foreach (var item in result.Items)
            {
                if (!string.IsNullOrEmpty(item.FolderName))
                    item.FolderId = item.Id;
                // if (!string.IsNullOrEmpty(item.FolderParentName))
                //     item.FolderName = item.FolderParentName;
                //是否摘录
                if (item.MediaId > 0)
                {
                    item.IsExtract = true;
                    query = Q.NewQuery();
                    query.Where(nameof(Entity.tede2.Media.Media.Id), item.MediaId);
                    item.MediaNoteResult = await mediaRepository.GetAsync(query);
                    if (item.MediaNoteResult != null)
                        item.MediaNoteResult.ImageUrls = StringUtils.AddDomain(item.MediaNoteResult.ImageUrls);
                }
                if (string.IsNullOrWhiteSpace(item.Content))
                    item.Content = "[]";
                var contentJsonData = JsonConvert.DeserializeObject<List<ContentJsonData>>(item.Content);
                foreach (var contentJsonDataItem in contentJsonData)
                    contentJsonDataItem.File = StringUtils.AddDomain(contentJsonDataItem.File);
                if (contentJsonData.Count == 0)
                    item.DataType = 1;
                item.Content = "";
                if (contentJsonData.Count > 0)
                {
                    var imgData = new List<ContentJsonData>();
                    var FileData = new List<ContentJsonData>();
                    var forCount = 1;
                    var firstContent = string.Empty;
                    foreach (var jsonData in contentJsonData)
                    {
                        if (jsonData.TypeValue == AllTypeConst.Text.GetHashCode() && forCount == 1)
                            //文本
                            firstContent = jsonData.Text;
                        else if (jsonData.TypeValue == AllTypeConst.Text.GetHashCode() && forCount > 1)
                            //文本
                            continue;
                        //图片
                        else if (jsonData.TypeValue == AllTypeConst.Image.GetHashCode() && FileData.Count == 0)
                        {
                            if (imgData.Count > 9)
                                break;
                            imgData.Add(jsonData);
                        }
                        //附件
                        else
                        {
                            FileData.Add(jsonData);
                            break;
                        }
                        forCount++;
                    }
                    item.Content = string.IsNullOrWhiteSpace(firstContent) ? "" : firstContent;
                    if (imgData.Count > 0) { item.DataType = 2; item.Data = imgData; }
                    else if (FileData.Count > 0) { item.DataType = 3; item.Data = FileData; }
                    else item.DataType = 1;
                    var contType = new List<int> { AllTypeConst.Text.GetHashCode(), AllTypeConst.Image.GetHashCode() };
                    item.FileCount = contentJsonData.Count(n => !contType.Contains(n.Type));
                }
                if (item.Data == null || item.Data.Count == 0)
                    item.Data = new List<ContentJsonData>();
                foreach (var data in item.Data)
                {
                    if (data.Type == AllTypeConst.CollectFolder.GetHashCode())
                    {
                        var userName = await _userRepository.GetNameAsync(data.SourceUserId);
                        data.Author = userName;
                    }
                    if (string.IsNullOrEmpty(data.Title))
                        data.Title = string.Empty;
                    if (string.IsNullOrEmpty(data.FileName))
                        data.FileName = string.Empty;
                }
            }

            return result;
        }
        /// <summary>
        /// 笔记解析
        /// </summary>
        /// <param name="data"></param>
        /// <returns></returns>
        public async Task<List<ContentJsonData>> AnalyzeAsync(List<ContentJsonData> data)
        {
            var result = new List<ContentJsonData>();
            var fileCount = data.Count(n => n.Type == AllTypeConst.File.GetHashCode());
            //提取图片
            if (data.Any(n => n.Type == AllTypeConst.Image.GetHashCode()))
            {
                var contentJsonData = new ContentJsonData { FileCount = fileCount, Type = AllTypeConst.Image.GetHashCode() };
                //获取图片
                var imgList = data.Where(n => n.Type == AllTypeConst.Image.GetHashCode());
                contentJsonData.ArticleImgUrl = imgList.Select(n => StringUtils.AddDomain(n.File)).ToList();
                result.Add(contentJsonData);
                return result;
            }
            //获取
            foreach (var item in data.Where(n => n.Type != AllTypeConst.Text.GetHashCode() && n.Type != AllTypeConst.File.GetHashCode()))
            {
                return await StructNoteData(item.Id, item.Type);
            }
            return result;
        }

        /// <summary>
        ///  类型1 txt文字 2 img:图片 3 file:文件 4 Article:文章 5 notice通知 6 topic话题 7 note笔记 8 collection收藏 9站内信 10小组
        /// </summary>
        /// <param name="collectionDataId"></param>
        /// <param name="collectionType"></param>
        /// <returns></returns>
        public async Task<List<ContentJsonData>> StructNoteData(int collectionDataId, int collectionType)
        {
            var list = new List<ContentJsonData>();
            //文章类型
            if (collectionType == AllTypeConst.Article.GetHashCode())
            {
                var article = await _articleRepository.GetArticleAsync(collectionDataId);
                if (article == null)
                    return new List<ContentJsonData>();
                var imageUrls = StringUtils.StringCollectionToStringList(article.ImageUrls).ToList();
                var articleImgUrl = new List<string>();
                foreach (var t in imageUrls)
                    articleImgUrl.Add(StringUtils.AddDomain(t));
                list.Add(new ContentJsonData
                {
                    Author = article.Source,
                    Title = article.Title,
                    CreatedData = article.CreatedDate,
                    Type = AllTypeConst.Article.GetHashCode(),
                    Id = article.Id,
                    ArticleImgUrl = articleImgUrl,
                    ReadCount = article.ReadCount
                });
            }

            //话题类型
            if (collectionType == AllTypeConst.Topic.GetHashCode())
            {
                var topic = await _topicRepository.GetAsync(collectionDataId);
                if (topic == null)
                    return list;
                //查询ID
                var user = await _userRepository.GetAsync(topic.UserId);
                list.Add(new ContentJsonData
                {
                    Author = user.Name,
                    Title = topic.Title,
                    CreatedData = topic.CreatedDate,
                    Type = AllTypeConst.Topic.GetHashCode(),
                    Id = topic.Id,
                    File = StringUtils.AddDomain(user.AvatarUrl),
                    ReadCount = topic.ReadCount
                });
            }

            //收藏
            if (collectionType == AllTypeConst.Collect.GetHashCode())
            {
                var collection = await GetCollectionRecursion(collectionDataId);
                if (collection == null)
                    return new List<ContentJsonData>();
                list = await StructNoteData(collection.CollectionDataId, collection.CollectionType);
            }

            //笔记
            if (collectionType == AllTypeConst.Note.GetHashCode() || collectionType == AllTypeConst.TopicNote.GetHashCode())
            {
                var note = await _noteRepository.GetAsync(collectionDataId);
                if (note == null)
                    return list;
                var user = await _userRepository.GetAsync(note.UserId);
                list.Add(new ContentJsonData
                {
                    Author = user.Name,
                    NickName = user.Nick,
                    Title = note.Title,
                    CreatedData = note.CreatedDate,
                    Type = collectionType,
                    Id = note.Id,
                    File = ""
                });
            }
            //通知
            if (collectionType == AllTypeConst.Notice.GetHashCode())
            {
                var notice = await _noticeRepository.GetAsync(collectionDataId);
                if (notice == null)
                    return new List<ContentJsonData>();
                var user = await _userRepository.GetAsync(notice.UserId);
                list.Add(new ContentJsonData
                {
                    Author = user.Name,
                    Title = notice.Title,
                    CreatedData = notice.CreatedDate,
                    Type = AllTypeConst.Notice.GetHashCode(),
                    Id = notice.Id,
                    File = ""
                });
            }

            //站内信
            if (collectionType == AllTypeConst.Missive.GetHashCode())
            {
                var missive = await _missiveRepository.GetAsync(collectionDataId);
                if (missive == null)
                    return new List<ContentJsonData>();
                var user = await _userRepository.GetAsync(missive.UserId);
                list.Add(new ContentJsonData
                {
                    Author = user.Name,
                    Title = missive.Title,
                    CreatedData = missive.CreatedDate,
                    Type = collectionType,
                    Id = missive.Id,
                    File = ""
                });
            }

            //小组
            if (collectionType == AllTypeConst.Group.GetHashCode())
            {
                if (collectionDataId == 0)
                    return new List<ContentJsonData>();
                var group = await _groupRepository.GetAsync(collectionDataId);
                var user = await _userRepository.GetAsync(group.UserId);
                list.Add(new ContentJsonData
                {
                    Author = user.Name,
                    Title = group.Name,
                    CreatedData = group.CreatedDate,
                    Type = collectionType,
                    Id = group.Id,
                    File = StringUtils.AddDomain(group.AvatarUrl)
                });
            }

            return list;
        }

        /// <summary>
        /// 递归获取不是收藏的数据
        /// </summary>
        /// <param name="middleId"></param>
        /// <returns></returns>
        public async Task<Entity.Collection> GetCollectionRecursion(int middleId)
        {
            //var middle = await _middleRepository.GetMiddleAsync(middleId);
            var collection = await _collectionRepository.GetAsync(middleId);
            if (collection == null)
                return new Entity.Collection();
            if (collection.CollectionType == AllTypeConst.Collect.GetHashCode())
                await GetCollectionRecursion(collection.CollectionType);
            return collection;
        }

        /// <summary>
        /// 获取笔记详情
        /// </summary>
        /// <param name="id"></param>
        /// <param name="userId"></param>
        /// <returns></returns>
        public async Task<NoteDetailResult> GetNoteDetailAsync(int id, int userId)
        {
            var note = await _noteRepository.GetAsync(id);
            if (note == null || note.IsDelete)
                throw new BusinessException("已删除！");
            var result = _mapper.Map<NoteDetailResult>(note);
            var user = await _userRepository.GetAsync(result.UserId);
            result.Name = user.Name;
            result.AvatarUrl = StringUtils.AddDomainMin(user.AvatarUrl);
            var list = JsonConvert.DeserializeObject<List<ContentJsonData>>(note.Content);
            foreach (var item in list)
                item.File = StringUtils.AddDomain(item.File);
            if (userId == 0)
                return result;
            //获取共享文件夹名称
            if (result.FolderId > 0)
            {
                var middle = await _middleRepository.GetMiddleAsync(result.FolderId);
                result.FolderName = middle != null ? middle.FolderName : "";
            }
            var analyzeRequest = new Request.App.Analyze.AnalyzeRequest();
            analyzeRequest.TypeValue = note.IsTopic ? AllTypeConst.TopicNote.GetHashCode() : AllTypeConst.Note.GetHashCode();
            analyzeRequest.AnalyzeType = 1;
            analyzeRequest.SourceId = id;
            analyzeRequest.UserId = userId;
            //点赞数量
            result.PraiseCount = await _analyzeService.CountAsync(analyzeRequest);
            //是否点赞
            result.IsPraise = await _analyzeService.ExistsAsync(analyzeRequest);
            //获取话题的评论数量
            var commentCount =
                await _commentRepository.CountAsync(Q.Where(nameof(Entity.Comment.ArticleId), id).Where(nameof(Entity.Comment.TypeValue), analyzeRequest.TypeValue).Where(nameof(Entity.Comment.Pid), 0));
            result.CommentCount = commentCount;
            //获取话题的转发数量
            analyzeRequest.AnalyzeType = 4;
            var retransmissionCount = await _analyzeService.CountAsync(analyzeRequest);
            result.RetransmissionCount = retransmissionCount;
            result.IsRetransmission = await _analyzeService.ExistsAsync(analyzeRequest);
            //获取话题的收藏数量
            analyzeRequest.AnalyzeType = 3;
            var collectCount = await _analyzeService.CountAsync(analyzeRequest);
            result.CollectCount = collectCount;
            //是否收藏
            result.IsCollect = await _analyzeService.ExistsAsync(analyzeRequest);
            result.Data = list;
            //修改访问量
            await _visitService.AddVisit(userId, analyzeRequest.TypeValue, id);
            //是否自建
            result.IsAdmin = note.UserId == userId;
            var praisePageSearchRequest = new PraisePageSearchRequest { SourceId = id, TypeValue = analyzeRequest.TypeValue, Page = 1, PerPage = 3 };
            result.NotePraisePagedList = await _analyzeService.GetPraisePageAsync(praisePageSearchRequest);
            return result;
        }
        /// <summary>
        /// 修改笔记
        /// </summary>
        /// <param name="note"></param>
        /// <returns></returns>
        public async Task<NoteAddOrModifyResult> UpdateNoteAsync(Entity.Note.Note note)
        {
            var entity = await _noteRepository.GetAsync(note.Id);
            if (string.IsNullOrWhiteSpace(note.Content) && string.IsNullOrWhiteSpace(note.Title))
                throw new BusinessException("标题和内容至少一项必填！");
            if (!string.IsNullOrWhiteSpace(note.Content))
            {
                entity.TextContent = string.Empty;
                var json = JsonConvert.DeserializeObject<List<ContentJsonData>>(note.Content);
                foreach (var item in json)
                {
                    item.File = StringUtils.RemoveDomain(item.File);
                    if (item.Type == AllTypeConst.Text.GetHashCode())
                        entity.TextContent += item.Text;
                }
                entity.Content = JsonConvert.SerializeObject(json);
                entity.HtmlContent = note.HtmlContent;
            }
            else
            {
                entity.Content = string.Empty;
                entity.HtmlContent = string.Empty;
                entity.TextContent = string.Empty;
            }
            if (note.FolderId > 0)
            {
                entity.FolderId = note.FolderId;
                var query = Q.NewQuery();
                query.Where(nameof(Entity.Middle.Middle.MiddleId), note.Id);
                query.Where(nameof(Entity.Middle.Middle.FolderType), note.IsTopic ? AllTypeConst.TopicNote.GetHashCode() : AllTypeConst.Note.GetHashCode());
                query.Where(nameof(Entity.Middle.Middle.UserId), entity.UserId);
                //获取middle
                var middle = await _middleRepository.GetMiddleAsync(query);
                if (middle != null)
                {
                    //修改middle
                    middle.ParentId = note.FolderId;
                    await _middleRepository.UpdateAsync(middle);
                }
            }
            //不是草稿
            if (entity.IsDraft && !note.IsDraft)
            {
                //添加中间件
                var middleInsertTypes = new MiddleInsertTypeRequest
                {
                    FolderId = note.FolderId,
                    MiddleId = entity.Id,
                    FolderType = entity.IsTopic ? AllTypeConst.TopicNote.GetHashCode() : AllTypeConst.Note.GetHashCode(),
                    UserId = entity.UserId,
                    MiddleSonId = 0,
                    AttributeValue = 1,
                    IsAdmin = true
                };
                await _middleService.InsertAsync(middleInsertTypes);
                //修改话题访问量
                await _visitService.AddVisit(note.UserId, middleInsertTypes.FolderType, note.Id);
            }
            //添加默认文件夹
            await recordFolderRepository.AddAsync(note.IsTopic ? AllTypeConst.TopicNote.GetHashCode() : AllTypeConst.Note.GetHashCode(), note.UserId, note.FolderId);
            entity.Title = note.Title;
            entity.IsDraft = note.IsDraft;
            await _noteRepository.UpdateAsync(entity);
            var middleDto = await _middleRepository.GetMiddleAsync(entity.FolderId);
            var result = new NoteAddOrModifyResult()
            {
                Id = entity.Id,
                FolderId = entity.FolderId,
                FolderName = middleDto == null ? "" : middleDto.FolderName
            };
            return result;
        }

        public async Task<bool> DeleteAsync(int id, int userId)
        {
            //获取笔记
            var note = await _noteRepository.GetAsync(id);
            if (note == null || note.UserId != userId)
                throw new BusinessException("不满足删除条件！");
            try
            {
                using (var transactionScope = new TransactionScope())
                {
                    //修改笔记
                    note.IsDelete = true;
                    await _noteRepository.DeleteAsync(id);
                    //获取middle修改middle
                    var query = Q.NewQuery();
                    query.Where(nameof(Entity.Middle.Middle.MiddleId), id);
                    query.Where(nameof(Entity.Middle.Middle.UserId), userId);
                    query.Where(nameof(Entity.Middle.Middle.FolderType), note.IsTopic ? AllTypeConst.TopicNote.GetHashCode() : AllTypeConst.Note.GetHashCode());
                    var middle = await _middleRepository.GetMiddleAsync(query);
                    await _middleRepository.DeleteAsync(Q.Where(nameof(Entity.Middle.Middle.Id), middle.Id));
                    transactionScope.Complete();
                }
            }
            catch (System.Exception ex)
            {
                throw new BusinessException(ex.Message);
            }
            return true;
        }

        public async Task<bool> DraftDeleteAsync(int id)
        {
            try
            {
                using (var transactionScope = new TransactionScope())
                {
                    //修改笔记
                    await _noteRepository.DeleteAsync(Q.Where(nameof(Entity.Note.Note.Id), id));
                    transactionScope.Complete();
                }
            }
            catch
            {
                return false;
            }
            return true;
        }


        /// <summary>
        /// 查询个人摘录
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        public async Task<PagedList<NoteUserExtractResult>> GetAllByUserId(NoteUserRequest request)
        {
            var result = await _noteRepository.GetAllByUserId(request);
            foreach (var item in result.Items)
            {
                item.AvatarUrl = StringUtils.AddDomain(item.AvatarUrl);
            }
            return result;
        }

        /// <summary>
        /// 笔记没有文件夹分页
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        public async Task<PagedList<NoteNotFolderPageResult>> GetNoteNotFolderPageResult(NoteSearchPageListRequest request)
        {
            var result = await _noteRepository.GetNoteNotFolderPageResult(request);
            foreach (var item in result.Items)
            {
                if (string.IsNullOrEmpty(item.FolderName))
                    item.FolderName = "根目录";
                // item.MiddleId = item.Id;
                //是否摘录
                if (item.MediaId > 0)
                {
                    item.IsExtract = true;
                    var query = Q.NewQuery();
                    query.Where(nameof(Entity.tede2.Media.Media.Id), item.MediaId);
                    item.MediaNoteResult = await mediaRepository.GetAsync(query);
                    if (item.MediaNoteResult != null)
                        item.MediaNoteResult.ImageUrls = StringUtils.AddDomain(item.MediaNoteResult.ImageUrls);
                }
                if (string.IsNullOrWhiteSpace(item.Content))
                    item.Content = "[]";
                var contentJsonData = JsonConvert.DeserializeObject<List<ContentJsonData>>(item.Content);
                foreach (var contentJsonDataItem in contentJsonData)
                    contentJsonDataItem.File = StringUtils.AddDomain(contentJsonDataItem.File);
                if (contentJsonData.Count == 0)
                    item.DataType = 1;
                item.Content = "";
                if (contentJsonData.Count > 0)
                {
                    var imgData = new List<ContentJsonData>();
                    var FileData = new List<ContentJsonData>();
                    var forCount = 1;
                    var firstContent = string.Empty;
                    foreach (var jsonData in contentJsonData)
                    {
                        if (jsonData.TypeValue == AllTypeConst.Text.GetHashCode() && forCount == 1)
                            //文本
                            firstContent = jsonData.Text;
                        else if (jsonData.TypeValue == AllTypeConst.Text.GetHashCode() && forCount > 1)
                            //文本
                            continue;
                        //图片
                        else if (jsonData.TypeValue == AllTypeConst.Image.GetHashCode() && FileData.Count == 0)
                        {
                            if (imgData.Count > 9)
                                break;
                            imgData.Add(jsonData);
                        }
                        //附件
                        else
                        {
                            FileData.Add(jsonData);
                            break;
                        }
                        forCount++;
                    }
                    item.Content = string.IsNullOrWhiteSpace(firstContent) ? "" : firstContent;
                    if (imgData.Count > 0) { item.DataType = 2; item.Data = imgData; }
                    else if (FileData.Count > 0) { item.DataType = 3; item.Data = FileData; }
                    else item.DataType = 1;
                    var contType = new List<int> { AllTypeConst.Text.GetHashCode(), AllTypeConst.Image.GetHashCode() };
                    item.FileCount = contentJsonData.Count(n => !contType.Contains(n.Type));
                }
                if (item.Data == null || item.Data.Count == 0)
                    item.Data = new List<ContentJsonData>();
                foreach (var data in item.Data)
                {
                    if (data.Type == AllTypeConst.CollectFolder.GetHashCode())
                    {
                        var userName = await _userRepository.GetNameAsync(data.SourceUserId);
                        data.Author = userName;
                    }
                    if (string.IsNullOrEmpty(data.Title))
                        data.Title = string.Empty;
                    if (string.IsNullOrEmpty(data.FileName))
                        data.FileName = string.Empty;
                }
            }
            result.IsDraft = await _noteRepository.IsExistsDraftAsync(request.UserId, false);
            result.DraftId = await _noteRepository.GetNoteIdByDraftAsync(request.UserId, false);
            result.DraftCount = await _noteRepository.GetDraftCountAsync(request.UserId, false);
            return result;
        }

        public async Task<bool> UpdateNoteTextContentAsync()
        {
            var query = Q.NewQuery();
            query.Where(nameof(Entity.Note.Note.TextContent), "=", "");
            query.OrderByDesc(nameof(Entity.Note.Note.CreatedDate));
            query.Limit(100);
            var result = await _noteRepository.GetAllAsync(query);
            foreach (var item in result)
            {
                if (!string.IsNullOrEmpty(item.Content))
                {
                    var contentJsonData = JsonConvert.DeserializeObject<List<ContentJsonData>>(item.Content);
                    foreach (var data in contentJsonData)
                    {
                        if (data.Type == AllTypeConst.Text.GetHashCode())
                            item.TextContent += data.Text;
                    }
                    if (!string.IsNullOrEmpty(item.TextContent))
                        await _noteRepository.UpdateAsync(item);
                    else
                    {
                        item.TextContent = "[]";
                        await _noteRepository.UpdateAsync(item);
                    }
                }
            }
            return true;
        }
    }

}