using Hotline.Caching.Interfaces;
using Hotline.Permissions;
using Hotline.Quality;
using Hotline.Repository.SqlSugar.Extensions;
using Hotline.Repository.SqlSugar.System;
using Hotline.Settings;
using Hotline.Settings.CommonOpinions;
using Hotline.Share.Dtos;
using Hotline.Share.Dtos.Dic;
using Hotline.Share.Dtos.Menu;
using Hotline.Share.Dtos.Quality;
using Hotline.Share.Dtos.Settings;
using Hotline.Share.Dtos.Trunk;
using Hotline.Share.Enums.Quality;
using Hotline.Share.Enums.Settings;
using Hotline.Share.Requests;
using MapsterMapper;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;
using Microsoft.AspNetCore.Mvc.Rendering;
using System.Diagnostics.CodeAnalysis;
using XF.Domain.Authentications;
using XF.Domain.Exceptions;
using XF.Domain.Repository;
using XF.Utility.EnumExtensions;

namespace Hotline.Api.Controllers
{
    /// <summary>
    ///  系统管理相关接口
    /// </summary>
    public class SysController : BaseController
    {
        private readonly IMapper _mapper;
        private readonly IRepository<SystemSetting> _systemSettingsRepository;
        private readonly ISystemMenuRepository _systemMenuRepository;
        private readonly IRepository<SystemDicType> _sysDicTypeRepository;
        private readonly IRepository<SystemDicData> _sysDicDataRepository;
        private readonly ISystemAreaDomainService _systemAreaDomainService;
        private readonly IRepository<SystemArea> _systemAreaRepository;
        private readonly ISystemCommonOpinionDomainService _commonOpinionDomainService;
        private readonly IRepository<SystemCommonOpinion> _commonOpinionRepository;
        private readonly ISessionContext _sessionContext;
        private readonly ISystemDicDataCacheManager _systemDicDataCacheManager;
        private readonly IRepository<SystemLog> _systemLogRepository;

        /// <summary>
        /// 系统管理相关接口
        /// </summary>
        /// <param name="mapper"></param>
        /// <param name="systemSettingsRepository"></param>
        /// <param name="systemMenuRepository"></param>
        /// <param name="sysDicDataRepository"></param>
        /// <param name="sysDicTypeRepository"></param>
        /// <param name="commonOpinionDomainService"></param>
        /// <param name="commonOpinionRepository"></param>
        /// <param name="sessionContext"></param>
        /// <param name="systemAreaDomainService"></param>
        /// <param name="systemAreaRepository"></param>
        public SysController(
            IMapper mapper,
            IRepository<SystemSetting> systemSettingsRepository,
            ISystemMenuRepository systemMenuRepository,
            IRepository<SystemDicType> sysDicTypeRepository,
            IRepository<SystemDicData> sysDicDataRepository,
            ISystemAreaDomainService systemAreaDomainService,
            IRepository<SystemArea> systemAreaRepository,
            ISystemCommonOpinionDomainService commonOpinionDomainService,
            IRepository<SystemCommonOpinion> commonOpinionRepository,
            ISessionContext sessionContext,
            ISystemDicDataCacheManager systemDicDataCacheManager,
            IRepository<SystemLog> systemLogRepository
			)
        {
            _mapper = mapper;
            _systemSettingsRepository = systemSettingsRepository;
            _systemMenuRepository = systemMenuRepository;
            _sysDicTypeRepository = sysDicTypeRepository;
            _sysDicDataRepository = sysDicDataRepository;
            _systemAreaDomainService = systemAreaDomainService;
            _systemAreaRepository = systemAreaRepository;
            _commonOpinionDomainService = commonOpinionDomainService;
            _commonOpinionRepository = commonOpinionRepository;
            _sessionContext = sessionContext;
            _systemDicDataCacheManager = systemDicDataCacheManager;
            _systemLogRepository = systemLogRepository;

		}

        #region 菜单管理
        /// <summary>
        /// 获取菜单
        /// </summary>
        /// <returns></returns>
        //[Permission(EPermission.GetMenuJson)]
        [AllowAnonymous]
        [HttpGet("getmenujson")]
        public async Task<IReadOnlyList<SystemMenu>> GetMenuJson()
        {
            //获取菜单树形
            return await _systemMenuRepository.GetSystemMenus();
        }

        /// <summary>
        /// 新增菜单
        /// </summary>
        /// <param name="dto"></param>
        /// <returns></returns>
        [Permission(EPermission.AddMenu)]
        [HttpPost("add-menu")]
        public async Task AddMenu([FromBody] AddMenuDto dto)
        {
            var menu = _mapper.Map<SystemMenu>(dto);
            await _systemMenuRepository.AddAsync(menu,HttpContext.RequestAborted);
        }

        /// <summary>
        /// 修改菜单
        /// </summary>
        /// <param name="dto"></param>
        /// <returns></returns>
        [Permission(EPermission.UpdateMenu)]
        [HttpPost("update-menu")]
        public async Task UpdateMenu([FromBody] UpdateMenuDto dto)
        {
            var menu = await _systemMenuRepository.GetAsync(dto.Id, HttpContext.RequestAborted);
            if (menu is null)
                throw UserFriendlyException.SameMessage("无效菜单");

            _mapper.Map(dto, menu);
            await _systemMenuRepository.UpdateAsync(menu, HttpContext.RequestAborted);
        }

        /// <summary>
        /// 删除菜单
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        [Permission(EPermission.RemoveMenu)]
        [HttpDelete("removemenu/{id}")]
        public async Task RemoveMenu(string id)
        {
            var menu = await _systemMenuRepository.GetAsync(id, HttpContext.RequestAborted);
            if (menu is null)
                throw UserFriendlyException.SameMessage("无效菜单");
            //检查是否存在下级菜单
            var ishavemenu = await _systemMenuRepository.AnyAsync(x => x.ParentId == id);
            if (ishavemenu)
                throw UserFriendlyException.SameMessage("存在下级菜单，暂时不能删除");
            //检查是否存在按钮
            //var ishavebutton = await _systemButtonRepository.AnyAsync(x => x.MenuId == id);
            //if (ishavebutton)
            //    throw UserFriendlyException.SameMessage("存在按钮权限，暂时不能删除");

            await _systemMenuRepository.RemoveAsync(id, false, HttpContext.RequestAborted);
        }

        /// <summary>
        /// 获取菜单对象
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        [HttpGet("menu/{id}")]
        public async Task<SystemMenu> GetMenu(string id)
        {
            var menu = await _systemMenuRepository.GetAsync(id, HttpContext.RequestAborted);
            if (menu is null)
                throw UserFriendlyException.SameMessage("无效菜单");
            return menu;
        }

        #region 按钮管理

        ///// <summary>
        ///// 通过菜单ID获取按钮列表
        ///// </summary>
        ///// <param name="menuid"></param>
        ///// <returns></returns>
        //[Permission(EPermission.GetButtonByMenu)]
        //[HttpGet("getbuttonmenu")]
        //public async Task<IReadOnlyList<SystemButton>> GetButtonByMenu(string menuid)
        //{
        //    return await _systemButtonRepository.QueryAsync(x => x.MenuId == menuid);
        //}

        ///// <summary>
        ///// 新增按钮
        ///// </summary>
        ///// <param name="dto"></param>
        ///// <returns></returns>
        //[Permission(EPermission.AddButton)]
        //[HttpPost("add-button")]
        //public async Task AddButton([FromBody] AddButtonDto dto)
        //{
        //    var button = _mapper.Map<SystemButton>(dto);
        //    await _systemButtonRepository.AddAsync(button);
        //}

        ///// <summary>
        ///// 编辑按钮
        ///// </summary>
        ///// <param name="dto"></param>
        ///// <returns></returns>
        //[Permission(EPermission.UpdateButton)]
        //[HttpPost("update-button")]
        //public async Task UpdateButton([FromBody] UpdateButtonDto dto)
        //{
        //    var button = await _systemButtonRepository.GetAsync(dto.Id, HttpContext.RequestAborted);
        //    if (button is null)
        //        throw UserFriendlyException.SameMessage("无效按钮");
        //    _mapper.Map(dto, button);
        //    await _systemButtonRepository.UpdateAsync(button);
        //}

        ///// <summary>
        ///// 删除按钮
        ///// </summary>
        ///// <param name="id"></param>
        ///// <returns></returns>
        //[Permission(EPermission.RemoveButton)]
        //[HttpDelete("removebutton/{id}")]
        //public async Task RemoveButton(string id)
        //{
        //    var button = await _systemButtonRepository.GetAsync(id, HttpContext.RequestAborted);
        //    if (button is null)
        //        throw UserFriendlyException.SameMessage("无效按钮");
        //    await _systemButtonRepository.RemoveAsync(id, false, HttpContext.RequestAborted);
        //}

        ///// <summary>
        ///// 获取按钮对象
        ///// </summary>
        ///// <param name="id"></param>
        ///// <returns></returns>
        //[Permission(EPermission.GetButton)]
        //[HttpGet("button/{id}")]
        //public async Task<SystemButton> GetButton(string id)
        //{
        //    var button = await _systemButtonRepository.GetAsync(id, HttpContext.RequestAborted);
        //    if (button is null)
        //        throw UserFriendlyException.SameMessage("无效按钮");
        //    return button;
        //}


        #endregion
        #endregion

        #region 字典管理

        /// <summary>
        /// 获取字典类型列表
        /// </summary>
        /// <returns></returns>
        [Permission(EPermission.GetSysDicType)]
        [HttpPost("dictype-list")]
        public async Task<List<SystemDicType>> GetSysDicType()
        {
            return await _sysDicTypeRepository.Queryable().ToListAsync();
        }

        /// <summary>
        /// 根据字典类型ID获取字典列表
        /// </summary>
        /// <param name="dto"></param>
        /// <returns></returns>
        [Permission(EPermission.GetSysDicData)]
        [HttpGet("dictdata-type")]
        public async Task<List<SystemDicData>> GetSysDicData([FromQuery] GetSysDicDataDto dto)
        {
            return await _sysDicDataRepository.Queryable().Where(x => x.DicTypeId == dto.typeid).OrderBy(x=>x.Sort)/*.WhereIF(!string.IsNullOrEmpty(dto.datavalue),x=>x.DicDataValue.Contains(dto.datavalue))*/.ToTreeAsync(x=>x.Children,x=>x.ParentId,"");
            //return await _sysDicDataRepository.Queryable().Where(x => x.DicTypeId == dto.typeid).WhereIF(!string.IsNullOrEmpty(dto.datavalue), x => x.DicDataValue.Contains(dto.datavalue)).WhereIF(!string.IsNullOrEmpty(dto.ParentId), x => x.ParentId == dto.ParentId).ToListAsync();
        }

        /// <summary>
        /// 根据字典类型Code获取字典列表
        /// </summary>
        /// <param name="code"></param>
        /// <returns></returns>
        [HttpGet("dictdata-code/{code}")]
        public async Task<List<SystemDicData>> GetSysDicDataByCode(string code)
        {
            return await _sysDicDataRepository.Queryable().Where(x => x.DicTypeCode == code).OrderBy(x=>x.Sort).ToListAsync();
        }
         
        /// <summary>
        /// 获取字典对象
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        [Permission(EPermission.SysDicDataModel)]
        [HttpGet("dicdata/{id}")]
        public async Task<SystemDicData> SysDicDataModel(string id)
        {
            var dicData = await _sysDicDataRepository.GetAsync(id, HttpContext.RequestAborted);
            if (dicData is null)
                throw UserFriendlyException.SameMessage("无效数据");
            return dicData;
        }

        /// <summary>
        /// 新增字典数据
        /// </summary>
        /// <param name="dto"></param>
        /// <returns></returns>
        [Permission(EPermission.AddDicData)] 
        [HttpPost("add-dicdata")]
        public async Task AddDicData([FromBody] AddDicDataDto dto)
        {
            var dicType = await _sysDicTypeRepository.GetAsync(dto.DicTypeId, HttpContext.RequestAborted);
            if (dicType is null)
                throw UserFriendlyException.SameMessage("无效字典类型");
            var dicData = _mapper.Map<SystemDicData>(dto);
            dicData.DicTypeCode = dicType.DicTypeCode;
            _systemDicDataCacheManager.RemoveSysDicDataCache(dicType.DicTypeCode);
            await _sysDicDataRepository.AddAsync(dicData);
        }

        /// <summary>
        /// 修改字典数据
        /// </summary>
        /// <param name="dto"></param>
        /// <returns></returns>
        [Permission(EPermission.UpdateDicData)]
        [HttpPost("update-dicdata")]
        public async Task UpdateDicData([FromBody]UpdateDicDataDto dto)
        {
            var dicData = await _sysDicDataRepository.GetAsync(dto.Id, HttpContext.RequestAborted);
            if (dicData is null)
                throw UserFriendlyException.SameMessage("无效字典数据");
            var dicType = await _sysDicTypeRepository.GetAsync(dto.DicTypeId, HttpContext.RequestAborted);
            if (dicType is null)
                throw UserFriendlyException.SameMessage("无效字典类型");
            _mapper.Map(dto, dicData);
            dicData.DicTypeCode = dicType.DicTypeCode;
            _systemDicDataCacheManager.RemoveSysDicDataCache(dicType.DicTypeCode);
            await _sysDicDataRepository.UpdateAsync(dicData,HttpContext.RequestAborted);
        }

        #endregion

        #region 行政区划

        /// <summary>
        /// 获取省市区树形
        /// </summary>
        /// <returns></returns>
        [HttpGet("area/tree")]
        public async Task<List<SystemArea>> GetAreaTree()
        {
            return await _systemAreaDomainService.GetAreaTree();
        }

        /// <summary>
        /// 新增省市区
        /// </summary>
        /// <param name="dto"></param>
        /// <returns></returns>
        [Permission(EPermission.AddArea)]
        [HttpPost("area")]
        public async Task AddArea([FromBody] AddAreaDto dto)
        {
            var model = _mapper.Map<SystemArea>(dto);
            if (string.IsNullOrEmpty(model.ParentId) || model.ParentId.Length > 8)
            {
                throw UserFriendlyException.SameMessage("只允许添加乡镇、街道数据，请选择区县");
            }
            if(model.ParentId.Substring(6,2) == "00")
            {
                throw UserFriendlyException.SameMessage("只允许添加乡镇、街道数据，请选择区县");
            }
            //验证重复
            var area = await _systemAreaRepository.Queryable(includeDeleted:true).FirstAsync(x => x.ParentId == dto.ParentId && x.AreaName == dto.AreaName);
            if (area!=null)
            {
                if (area.IsDeleted)
                {
                    area.IsDeleted = false;
                    await _systemAreaRepository.UpdateAsync(area, HttpContext.RequestAborted);
                    throw UserFriendlyException.SameMessage("同目录下已存在被删除的相同数据，已重新启用");
                }
                else
                {
                    throw UserFriendlyException.SameMessage("同目录下已存在相同数据，不能重复添加");
                }
            }
            //生成新Code
            model.Id = await _systemAreaDomainService.GenerateNewAreaCodeAsync(dto.ParentId, HttpContext.RequestAborted);
            model.IsCanModify = true;
            await _systemAreaDomainService.AddArea(model, HttpContext.RequestAborted);
        }

        /// <summary>
        /// 修改省市区
        /// </summary>
        /// <param name="dto"></param>
        /// <returns></returns>
        [Permission(EPermission.ModifyArea)]
        [HttpPut("area")]
        public async Task ModifyArea([FromBody] ModifyAreaDto dto)
        {
            var model = await _systemAreaDomainService.GetArea(dto.Id, HttpContext.RequestAborted);
            if (model is null)
                throw UserFriendlyException.SameMessage("未知数据，请刷新页面");
            if (!model.IsCanModify)
                throw UserFriendlyException.SameMessage("系统数据，不能修改");

            _mapper.Map(dto,model); //_mapper.Map<SystemArea>(dto);

            //验证重复
            var area = await _systemAreaRepository.Queryable(includeDeleted: true).Where(x => x.ParentId == dto.ParentId && x.AreaName == dto.AreaName).ToListAsync();
            if (area.Count > 1)
            {
               throw UserFriendlyException.SameMessage("同目录下已存在相同数据，不能修改");
            }

            await _systemAreaDomainService.ModifyArea(model, HttpContext.RequestAborted);
        }

        /// <summary>
        /// 删除省市区（逻辑）
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        [Permission(EPermission.DelArea)]
        [HttpDelete("area/{id}")]
        public async Task DelArea(string id)
        {
            var model = await _systemAreaDomainService.GetArea(id, HttpContext.RequestAborted);
            if (model is null)
                throw UserFriendlyException.SameMessage("未知数据，请刷新页面");
            if (!model.IsCanModify)
                throw UserFriendlyException.SameMessage("系统数据不能删除");

            await _systemAreaDomainService.DelArea(id, HttpContext.RequestAborted);
        }

        /// <summary>
        /// 获取区域
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        [Permission(EPermission.GetArea)]
        [HttpGet("area/{id}")]
        public async Task<SystemArea?> GetArea(string id)
        {
            var model = await _systemAreaDomainService.GetArea(id, HttpContext.RequestAborted);
            if (model is null)
                throw UserFriendlyException.SameMessage("未知数据，请刷新页面");
            return model;
        }

        #endregion

        #region 常用意见
        #region 个人
        /// <summary>
        /// 获取常用意见
        /// </summary>
        /// <returns></returns>
        [HttpGet("common-list")]
        public async Task<IReadOnlyList<SystemCommonOpinion>> GetCommon([FromQuery]ECommonType commonType,bool isOpen)
        {
            return await _commonOpinionRepository.Queryable().Where(x => x.CommonType == commonType && x.IsOpen == isOpen)
                .WhereIF(isOpen== false,x=> x.CreatorId == _sessionContext.RequiredUserId).ToListAsync();
        }

        /// <summary>
        /// 新增常用意见
        /// </summary>
        /// <param name="dto"></param>
        /// <returns></returns>
        [HttpPost("add-common")]
        public async Task AddCommon([FromBody]AddCommonDto dto)
        {
            var entity = _mapper.Map<SystemCommonOpinion>(dto);
            await _commonOpinionDomainService.AddCommonOpinion(entity, HttpContext.RequestAborted);
        }

        /// <summary>
        /// 批量删除常用意见
        /// </summary>
        /// <param name="dto"></param>
        /// <returns></returns>
        [HttpPost("del-common")]
        public async Task DelCommon([FromBody]DelCommonDto dto)
        {
            await _commonOpinionDomainService.DelCommonOpinion(dto.Ids, HttpContext.RequestAborted);
        }

        /// <summary>
        /// 常用意见页面基础信息
        /// </summary>
        /// <returns></returns>
        [HttpGet("common-basepage")]
        public async Task<object> CommonBasePage()
        {
            var rsp = new
            {
                CommonType = EnumExts.GetDescriptions<ECommonType>(),
            };

            return rsp;
        }

        #endregion

        #region 公开
        /// <summary>
        /// 查询公开常用意见
        /// </summary>
        /// <returns></returns>
        [Permission(EPermission.QueryOpenCommonOpinionList)]
        [HttpGet("open-common")]
        public async Task<PagedDto<SystemCommonOpinion>> QueryOpenCommonOpinionList([FromQuery]QueryCommonDto dto)
        {
            var (total,items) = await _commonOpinionRepository.Queryable()
                .WhereIF(dto.IsOpen != null,x=>x.IsOpen == dto.IsOpen)
                .WhereIF(!string.IsNullOrEmpty(dto.UserName),x=>x.CreatorName.Contains(dto.UserName))
                .WhereIF(dto.CommonType!=null, x => x.CommonType == dto.CommonType)
                .ToPagedListAsync(dto.PageIndex, dto.PageSize, HttpContext.RequestAborted);
            return new PagedDto<SystemCommonOpinion>(total, items);
        }


        /// <summary>
        /// 修改公开常用意见
        /// </summary>
        /// <param name="dto"></param>
        /// <returns></returns>
        [Permission(EPermission.CommonModify)]
        [HttpPost("common-modify")]
        public async Task CommonModify([FromBody]CommonModifyDto dto)
        {
            var model = await _commonOpinionRepository.GetAsync(dto.Id, HttpContext.RequestAborted);
            if (model is null)
                throw UserFriendlyException.SameMessage("无效数据");

            _mapper.Map(dto, model);

            await _commonOpinionRepository.UpdateAsync(model, HttpContext.RequestAborted);
        }

		#endregion

		#endregion

		#region 日志
		/// <summary>
		/// 获取日志列表
		/// </summary>
		/// <param name="dto"></param>
		/// <returns></returns>
		[HttpGet("log_list")]
		public async Task<PagedDto<SystemLogDto>> List([FromQuery] PagedKeywordRequest dto)
		{
			var (total, items) = await _systemLogRepository.Queryable()
                .Where(x=> !string.IsNullOrEmpty(x.Name))
				.WhereIF(!string.IsNullOrEmpty(dto.Keyword), x => x.Name.Contains(dto.Keyword!) || x.CreatorName.Contains(dto.Keyword!))
				.OrderByDescending(x => x.CreationTime)
				.ToPagedListAsync(dto.PageIndex, dto.PageSize, HttpContext.RequestAborted);
			return new PagedDto<SystemLogDto>(total, _mapper.Map<IReadOnlyList<SystemLogDto>>(items));
		}

		/// <summary>
		/// 获取日志实体
		/// </summary>
		/// <param name="id"></param>
		/// <returns></returns>
		[HttpGet("log/{id}")]
		public async Task<SystemLogDto> ItemEntity(string id)
		{
			var log = await _systemLogRepository.Queryable()
				.FirstAsync(x => x.Id == id);
            return _mapper.Map<SystemLogDto>(log);
		}

        [HttpPost("log")]
        public async Task<string> LogAdd([FromBody]SystemLogDto dto)
        {
            var log = _mapper.Map<SystemLog>(dto);
            return await _systemLogRepository.AddAsync(log, HttpContext.RequestAborted);
        }

        #endregion

    }
}