using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Configuration;
using New_College.IServices;
using New_College.Model;
using New_College.Model.Models;
using New_College.Model.Request;
using New_College.Model.ViewModels;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
namespace New_College.Api.Controllers.Front
{
    [Route("api/front/[controller]/[action]")]
    [ApiController]
    public class NewsInfoController : ControllerBase
    {
        private readonly IConfiguration _configuration;
        private readonly ID_NewsCategoryServices iD_NewsCategory;
        private readonly ID_NewsInfoServices d_NewsInfo;
        public NewsInfoController(ID_NewsCategoryServices d_NewsCategoryServices, ID_NewsInfoServices d_NewsInfoServices, IConfiguration configuration)
        {
            this.iD_NewsCategory = d_NewsCategoryServices;
            this.d_NewsInfo = d_NewsInfoServices;
            this._configuration = configuration;
        }

        /// <summary>
        /// 校验新闻导入Key
        /// </summary>
        /// <returns></returns>
        private bool CheckNewsImportKey()
        {
            var configKey = _configuration["newskey"];

            if (string.IsNullOrWhiteSpace(configKey))
            {
                return false;
            }

            if (!Request.Headers.TryGetValue("X-Import-Key", out var requestKey))
            {
                return false;
            }

            return string.Equals(requestKey.ToString(), configKey, StringComparison.Ordinal);
        }
        /// <summary>
        /// 获取新闻分类
        /// </summary>
        /// <returns></returns>
        [HttpGet]
        public async Task<MessageModel<List<NewsClassCategoryResponse>>> GetNewsCategory()
        {


            return new MessageModel<List<NewsClassCategoryResponse>>()
            {
                msg = "ok",
                success = true,
                response = (await iD_NewsCategory.Query(c => c.IsDelete == false)).Select(c => new NewsClassCategoryResponse()
                {
                    Sort = c.OrderSort,
                    CategoryName = c.CategoryName,
                    Id = c.Id
                }).OrderBy(c => c.Sort).ToList(),
            };
        }


        /// <summary>
        /// 获取top多少的新闻
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [HttpGet]
        public async Task<MessageModel<List<NewsInfoResponse>>> GetTopNews([FromQuery] NewsRequest request)
        {
            try
            {
                var list = new List<NewsInfoResponse>();
                var query = (await d_NewsInfo.Query(e => e.IsDelete == false && e.CategoryId == request.CategoryId && e.ProvinceCode == request.provinceCode, " CreateTime desc")).Take(request.Top).OrderByDescending(s => s.Id);
                list = query.Select(s => new NewsInfoResponse
                {
                    CoverImg = s.CoverImg,
                    CreateTime = s.CreateTime.Value,
                    Source = s.Author,
                    Id = s.Id,
                    Title = s.Title,
                    Summary = s.Summary,
                }).ToList();
                return new MessageModel<List<NewsInfoResponse>>()
                {
                    msg = "success",
                    success = true,
                    response = list
                };
            }
            catch (Exception ex)
            {
                return new MessageModel<List<NewsInfoResponse>>()
                {
                    msg = ex.Message

                };
            }
        }



        /// <summary>
        /// 所有新闻列表带分页
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [HttpGet]
        public async Task<MessageModel<PageModel<NewsInfoResponse>>> GetPageNews([FromQuery] NewsPageRequest request)
        {
            var pageresponse = new PageModel<NewsInfoResponse>();
            try
            {
                ///
                var pageinfo = await d_NewsInfo.QueryPage(w => w.CategoryId == request.CategoryId && w.ProvinceCode == request.provinceCode, request.PageIndex, request.PageSize, "CreateTime desc");
                if (pageinfo.data.Any())
                {
                    pageresponse.data = pageinfo.data.Select(s => new NewsInfoResponse()
                    {
                        CoverImg = s.CoverImg,
                        CreateTime = s.CreateTime.Value,
                        Id = s.Id,
                        Summary = !string.IsNullOrWhiteSpace(s.Summary) ? s.Summary : s.Detail.Substring(0, 200) + "...",
                        Title = s.Title,
                        Source = s.Author
                    }).ToList();
                    pageresponse.pageCount = pageinfo.pageCount;
                    pageresponse.page = pageinfo.page;
                    pageresponse.dataCount = pageinfo.dataCount;
                    pageresponse.PageSize = pageinfo.PageSize;
                    pageresponse.pageCount = pageinfo.pageCount;
                }
                return new MessageModel<PageModel<NewsInfoResponse>>()
                {
                    msg = "success",
                    response = pageresponse,
                    success = true
                };

            }
            catch (Exception ex)
            {
                return new MessageModel<PageModel<NewsInfoResponse>>()
                {
                    msg = "fail",
                    success = false
                };
            }
        }


        /// <summary>
        /// 根据Id 获取新闻详情
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [HttpGet]
        public async Task<MessageModel<NewsDetailInfoResponse>> GetDetail([FromQuery] NewsDetailRequest request)
        {
            try
            {
                var result = new NewsDetailInfoResponse();
                var single = await d_NewsInfo.QueryById(request.Id);
                result.Author = single.Author;
                result.Click = single.Click;
                result.CoverImg = single.CoverImg;
                result.CreateTime = single.CreateTime.Value;
                result.Id = single.Id;
                result.Summary = single.Summary;
                result.Title = single.Title;
                result.Detail = single.Detail;
                return new MessageModel<NewsDetailInfoResponse>()
                {
                    msg = "success",
                    response = result,
                    success = true
                };
            }
            catch (Exception ex)
            {
                return new MessageModel<NewsDetailInfoResponse>()
                {
                    msg = ex.Message
                };
            }
        }



        /// <summary>
        /// 单独写入新闻资讯
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [HttpPost]
        [AllowAnonymous]
        public async Task<MessageModel<int>> AddNewsInfo([FromBody] NewsInfoAddRequest request)
        {
            try
            {
                if (!CheckNewsImportKey())
                {
                    return new MessageModel<int>()
                    {
                        msg = "无权限访问，Key校验失败",
                        success = false
                    };
                }

                if (request == null)
                {
                    return new MessageModel<int>()
                    {
                        msg = "参数不能为空",
                        success = false
                    };
                }

                if (request.CategoryId <= 0)
                {
                    return new MessageModel<int>()
                    {
                        msg = "新闻分类不能为空",
                        success = false
                    };
                }

                if (string.IsNullOrWhiteSpace(request.Title))
                {
                    return new MessageModel<int>()
                    {
                        msg = "新闻标题不能为空",
                        success = false
                    };
                }

                if (string.IsNullOrWhiteSpace(request.ProvinceCode))
                {
                    return new MessageModel<int>()
                    {
                        msg = "省份编号不能为空",
                        success = false
                    };
                }

                request.Title = request.Title.Trim();

                // 标题判重：标题已存在则不重复添加
                var existNews = await d_NewsInfo.Query(s =>
                    s.IsDelete == false &&
                    s.Title == request.Title
                );

                if (existNews != null && existNews.Any())
                {
                    return new MessageModel<int>()
                    {
                        msg = "新闻标题已存在，未重复添加",
                        success = true,
                        response = 0
                    };
                }

                var entity = new D_NewsInfo()
                {
                    CategoryId = request.CategoryId,
                    Author = request.Author,
                    ProvinceCode = request.ProvinceCode,
                    Title = request.Title,
                    CoverImg = request.CoverImg,
                    Summary = request.Summary,
                    Detail = request.Detail,
                    Click = request.Click,
                    IsDelete = false,
                    CreateTime = DateTime.Now
                };

                var id = await d_NewsInfo.Add(entity);

                return new MessageModel<int>()
                {
                    msg = "success",
                    success = true,
                    response = id
                };
            }
            catch (Exception ex)
            {
                return new MessageModel<int>()
                {
                    msg = ex.Message,
                    success = false
                };
            }
        }


        /// <summary>
        /// 批量写入新闻资讯
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [HttpPost]
        [AllowAnonymous]
        public async Task<MessageModel<int>> AddNewsInfoBatch([FromBody] NewsInfoBatchAddRequest request)
        {
            try
            {
                if (!CheckNewsImportKey())
                {
                    return new MessageModel<int>()
                    {
                        msg = "无权限访问，Key校验失败",
                        success = false
                    };
                }

                if (request == null || request.NewsList == null || !request.NewsList.Any())
                {
                    return new MessageModel<int>()
                    {
                        msg = "新闻列表不能为空",
                        success = false
                    };
                }

                var errorList = new List<string>();

                for (int i = 0; i < request.NewsList.Count; i++)
                {
                    var item = request.NewsList[i];

                    if (item.CategoryId <= 0)
                    {
                        errorList.Add($"第{i + 1}条新闻分类不能为空");
                    }

                    if (string.IsNullOrWhiteSpace(item.Title))
                    {
                        errorList.Add($"第{i + 1}条新闻标题不能为空");
                    }

                    if (string.IsNullOrWhiteSpace(item.ProvinceCode))
                    {
                        errorList.Add($"第{i + 1}条省份编号不能为空");
                    }
                }

                if (errorList.Any())
                {
                    return new MessageModel<int>()
                    {
                        msg = string.Join("；", errorList),
                        success = false
                    };
                }

                // 处理标题空格
                foreach (var item in request.NewsList)
                {
                    item.Title = item.Title.Trim();
                }

                // 获取本次提交的标题
                var requestTitles = request.NewsList
                    .Select(s => s.Title)
                    .Distinct()
                    .ToList();

                // 查询数据库中已存在的标题
                var existNewsList = await d_NewsInfo.Query(s =>
                    s.IsDelete == false &&
                    requestTitles.Contains(s.Title)
                );

                var existTitleList = existNewsList
                    .Select(s => s.Title)
                    .ToList();

                var newsList = new List<D_NewsInfo>();

                // 用于处理本次批量数据内部标题重复
                var currentAddTitleList = new List<string>();

                foreach (var item in request.NewsList)
                {
                    // 数据库已存在的标题，跳过
                    if (existTitleList.Contains(item.Title))
                    {
                        continue;
                    }

                    // 本次批量中已经添加过的标题，跳过
                    if (currentAddTitleList.Contains(item.Title))
                    {
                        continue;
                    }

                    currentAddTitleList.Add(item.Title);

                    newsList.Add(new D_NewsInfo()
                    {
                        CategoryId = item.CategoryId,
                        Author = item.Author,
                        ProvinceCode = item.ProvinceCode,
                        Title = item.Title,
                        CoverImg = item.CoverImg,
                        Summary = item.Summary,
                        Detail = item.Detail,
                        Click = item.Click,
                        IsDelete = false,
                        CreateTime = DateTime.Now
                    });
                }

                if (!newsList.Any())
                {
                    return new MessageModel<int>()
                    {
                        msg = "新闻标题均已存在，未新增数据",
                        success = true,
                        response = 0
                    };
                }

                var successCount = 0;

                foreach (var news in newsList)
                {
                    var id = await d_NewsInfo.Add(news);
                    if (id > 0)
                    {
                        successCount++;
                    }
                }

                return new MessageModel<int>()
                {
                    msg = $"success，本次成功新增{successCount}条，跳过重复标题{request.NewsList.Count - successCount}条",
                    success = true,
                    response = successCount
                };
            }
            catch (Exception ex)
            {
                return new MessageModel<int>()
                {
                    msg = ex.Message,
                    success = false
                };
            }
        }
    }
}