using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Logging;
using NCC.Common.Core.Manager;
using NCC.Common.Enum;
using NCC.Dependency;
using NCC.DynamicApiController;
using NCC.Extend.Entitys.Dto.LqCompanyCalendar;
using NCC.Extend.Entitys.Enum;
using NCC.Extend.Entitys.lq_company_calendar;
using NCC.Extend.Interfaces.LqCompanyCalendar;
using NCC.FriendlyException;
using SqlSugar;
using Yitter.IdGenerator;

namespace NCC.Extend
{
    /// <summary>
    /// 公司日历服务
    /// </summary>
    [ApiDescriptionSettings(Tag = "绿纤公司日历管理", Name = "LqCompanyCalendar", Order = 200)]
    [Route("api/Extend/LqCompanyCalendar")]
    public class LqCompanyCalendarService : IDynamicApiController, ITransient, ILqCompanyCalendarService
    {
        private readonly IUserManager _userManager;
        private readonly ILogger<LqCompanyCalendarService> _logger;
        private readonly ISqlSugarClient _db;

        /// <summary>
        /// 构造函数
        /// </summary>
        public LqCompanyCalendarService(IUserManager userManager, ILogger<LqCompanyCalendarService> logger, ISqlSugarClient db)
        {
            _userManager = userManager;
            _logger = logger;
            _db = db;
        }

        #region 事件类型管理

        /// <summary>
        /// 获取事件类型列表
        /// </summary>
        [HttpPost("GetEventTypeList")]
        public async Task<List<LqCompanyCalendarTypeOutput>> GetEventTypeListAsync([FromBody] LqCompanyCalendarTypeQueryInput input)
        {
            try
            {
                var query = _db.Queryable<LqCompanyCalendarTypeEntity>()
                    .Where(x => x.IsEffective == StatusEnum.有效.GetHashCode());

                if (!string.IsNullOrWhiteSpace(input?.TypeName))
                {
                    query = query.Where(x => x.TypeName.Contains(input.TypeName));
                }

                var list = await query.OrderBy(x => x.SortCode).ToListAsync();

                return list.Select(x => new LqCompanyCalendarTypeOutput
                {
                    Id = x.Id,
                    TypeName = x.TypeName,
                    TypeCode = x.TypeCode,
                    Color = x.Color,
                    SortCode = x.SortCode,
                    CreateTime = x.CreateTime
                }).ToList();
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "获取事件类型列表失败");
                throw NCCException.Oh($"获取失败：{ex.Message}");
            }
        }

        /// <summary>
        /// 创建事件类型
        /// </summary>
        [HttpPost("CreateEventType")]
        public async Task<string> CreateEventTypeAsync([FromBody] LqCompanyCalendarTypeCreateInput input)
        {
            try
            {
                var exists = await _db.Queryable<LqCompanyCalendarTypeEntity>()
                    .Where(x => x.TypeCode == input.TypeCode && x.IsEffective == StatusEnum.有效.GetHashCode())
                    .AnyAsync();

                if (exists)
                {
                    throw NCCException.Oh("类型编码已存在");
                }

                var id = YitIdHelper.NextId().ToString();
                var entity = new LqCompanyCalendarTypeEntity
                {
                    Id = id,
                    TypeName = input.TypeName,
                    TypeCode = input.TypeCode,
                    Color = input.Color,
                    SortCode = input.SortCode,
                    IsEffective = StatusEnum.有效.GetHashCode(),
                    CreateUser = _userManager.UserId,
                    CreateTime = DateTime.Now
                };

                await _db.Insertable(entity).ExecuteCommandAsync();

                return id;
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "创建事件类型失败");
                throw NCCException.Oh($"创建失败：{ex.Message}");
            }
        }

        /// <summary>
        /// 更新事件类型
        /// </summary>
        [HttpPost("UpdateEventType")]
        public async Task<bool> UpdateEventTypeAsync([FromBody] LqCompanyCalendarTypeUpdateInput input)
        {
            try
            {
                var entity = await _db.Queryable<LqCompanyCalendarTypeEntity>()
                    .Where(x => x.Id == input.Id && x.IsEffective == StatusEnum.有效.GetHashCode())
                    .FirstAsync();

                if (entity == null)
                {
                    throw NCCException.Oh("事件类型不存在或已失效");
                }

                var codeExists = await _db.Queryable<LqCompanyCalendarTypeEntity>()
                    .Where(x => x.TypeCode == input.TypeCode && x.Id != input.Id && x.IsEffective == StatusEnum.有效.GetHashCode())
                    .AnyAsync();

                if (codeExists)
                {
                    throw NCCException.Oh("类型编码已存在");
                }

                entity.TypeName = input.TypeName;
                entity.TypeCode = input.TypeCode;
                entity.Color = input.Color;
                entity.SortCode = input.SortCode;
                entity.UpdateUser = _userManager.UserId;
                entity.UpdateTime = DateTime.Now;

                await _db.Updateable(entity).ExecuteCommandAsync();

                return true;
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "更新事件类型失败");
                throw NCCException.Oh($"更新失败：{ex.Message}");
            }
        }

        /// <summary>
        /// 删除事件类型
        /// </summary>
        [HttpPost("DeleteEventType/{id}")]
        public async Task<bool> DeleteEventTypeAsync(string id)
        {
            try
            {
                var hasEvents = await _db.Queryable<LqCompanyCalendarEntity>()
                    .Where(x => x.EventType == id && x.IsEffective == StatusEnum.有效.GetHashCode())
                    .AnyAsync();

                if (hasEvents)
                {
                    throw NCCException.Oh("该类型下存在事件，无法删除");
                }

                var entity = await _db.Queryable<LqCompanyCalendarTypeEntity>()
                    .Where(x => x.Id == id && x.IsEffective == StatusEnum.有效.GetHashCode())
                    .FirstAsync();

                if (entity == null)
                {
                    throw NCCException.Oh("事件类型不存在或已失效");
                }

                entity.IsEffective = StatusEnum.无效.GetHashCode();
                entity.UpdateUser = _userManager.UserId;
                entity.UpdateTime = DateTime.Now;

                await _db.Updateable(entity).ExecuteCommandAsync();

                return true;
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "删除事件类型失败");
                throw NCCException.Oh($"删除失败：{ex.Message}");
            }
        }

        #endregion

        #region 事件管理

        /// <summary>
        /// 获取公司日历事件列表（分页）
        /// </summary>
        [HttpPost("GetCalendarEvents")]
        public async Task<LqCompanyCalendarPageOutput> GetCalendarEventsAsync([FromBody] LqCompanyCalendarQueryInput input)
        {
            try
            {
                var page = input.CurrentPage < 1 ? 1 : input.CurrentPage;
                var pageSize = input.PageSize < 1 ? 20 : (input.PageSize > 100 ? 100 : input.PageSize);

                var query = _db.Queryable<LqCompanyCalendarEntity>()
                    .Where(x => x.IsEffective == StatusEnum.有效.GetHashCode());

                if (input.StartTime.HasValue)
                {
                    query = query.Where(x => x.EndTime >= input.StartTime.Value);
                }

                if (input.EndTime.HasValue)
                {
                    query = query.Where(x => x.StartTime <= input.EndTime.Value);
                }

                if (!string.IsNullOrWhiteSpace(input.EventType))
                {
                    query = query.Where(x => x.EventType == input.EventType);
                }

                if (!string.IsNullOrWhiteSpace(input.StoreId))
                {
                    query = query.Where(x => x.StoreId == input.StoreId);
                }

                var total = await query.CountAsync();
                var list = await query.OrderBy(x => x.StartTime, OrderByType.Desc)
                    .Skip((page - 1) * pageSize)
                    .Take(pageSize)
                    .ToListAsync();

                var typeIds = list.Select(x => x.EventType).Distinct().ToList();
                var types = await _db.Queryable<LqCompanyCalendarTypeEntity>()
                    .Where(x => typeIds.Contains(x.Id) && x.IsEffective == StatusEnum.有效.GetHashCode())
                    .ToListAsync();

                var typeMap = types.ToDictionary(x => x.Id, x => x);

                return new LqCompanyCalendarPageOutput
                {
                    List = list.Select(x =>
                    {
                        var type = typeMap.ContainsKey(x.EventType) ? typeMap[x.EventType] : null;
                        return new LqCompanyCalendarOutput
                        {
                            Id = x.Id,
                            Title = x.Title,
                            EventType = x.EventType,
                            EventTypeName = type?.TypeName ?? "",
                            EventTypeColor = type?.Color ?? "#3b82f6",
                            Date = x.StartTime.ToString("yyyy-MM-dd"),
                            Start = x.StartTime.ToString("yyyy-MM-ddTHH:mm:ss"),
                            End = x.EndTime.ToString("yyyy-MM-ddTHH:mm:ss"),
                            Desc = x.Description,
                            StoreId = x.StoreId,
                            Store = x.StoreName,
                            Remark = x.Remark,
                            Attachments = x.Attachments,
                            CreateUser = x.CreateUser,
                            CreateTime = x.CreateTime
                        };
                    }).ToList(),
                    Total = total
                };
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "获取公司日历事件列表失败");
                throw NCCException.Oh($"获取失败：{ex.Message}");
            }
        }

        /// <summary>
        /// 获取公司日历事件列表（不分页，用于日历展示）
        /// </summary>
        [HttpPost("GetCalendarEventList")]
        public async Task<List<LqCompanyCalendarOutput>> GetCalendarEventListAsync([FromBody] LqCompanyCalendarQueryInput input)
        {
            try
            {
                var query = _db.Queryable<LqCompanyCalendarEntity>()
                    .Where(x => x.IsEffective == StatusEnum.有效.GetHashCode());

                if (input.StartTime.HasValue)
                {
                    query = query.Where(x => x.EndTime >= input.StartTime.Value);
                }

                if (input.EndTime.HasValue)
                {
                    query = query.Where(x => x.StartTime <= input.EndTime.Value);
                }

                if (!string.IsNullOrWhiteSpace(input.EventType))
                {
                    query = query.Where(x => x.EventType == input.EventType);
                }

                if (!string.IsNullOrWhiteSpace(input.StoreId))
                {
                    query = query.Where(x => x.StoreId == input.StoreId);
                }

                var list = await query.OrderBy(x => x.StartTime).ToListAsync();

                var typeIds = list.Select(x => x.EventType).Distinct().ToList();
                var types = await _db.Queryable<LqCompanyCalendarTypeEntity>()
                    .Where(x => typeIds.Contains(x.Id) && x.IsEffective == StatusEnum.有效.GetHashCode())
                    .ToListAsync();

                var typeMap = types.ToDictionary(x => x.Id, x => x);

                return list.Select(x =>
                {
                    var type = typeMap.ContainsKey(x.EventType) ? typeMap[x.EventType] : null;
                    return new LqCompanyCalendarOutput
                    {
                        Id = x.Id,
                        Title = x.Title,
                        EventType = x.EventType,
                        EventTypeName = type?.TypeName ?? "",
                        EventTypeColor = type?.Color ?? "#3b82f6",
                        Date = x.StartTime.ToString("yyyy-MM-dd"),
                        Start = x.StartTime.ToString("yyyy-MM-ddTHH:mm:ss"),
                        End = x.EndTime.ToString("yyyy-MM-ddTHH:mm:ss"),
                        Desc = x.Description,
                        StoreId = x.StoreId,
                        Store = x.StoreName,
                        Remark = x.Remark,
                        Attachments = x.Attachments,
                        CreateUser = x.CreateUser,
                        CreateTime = x.CreateTime
                    };
                }).ToList();
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "获取公司日历事件列表失败");
                throw NCCException.Oh($"获取失败：{ex.Message}");
            }
        }

        /// <summary>
        /// 创建公司日历事件
        /// </summary>
        [HttpPost("CreateCalendarEvent")]
        public async Task<string> CreateCalendarEventAsync([FromBody] LqCompanyCalendarCreateInput input)
        {
            try
            {
                var id = YitIdHelper.NextId().ToString();
                var entity = new LqCompanyCalendarEntity
                {
                    Id = id,
                    Title = input.Title,
                    EventType = input.EventType,
                    StartTime = input.StartTime,
                    EndTime = input.EndTime,
                    Description = input.Description,
                    StoreId = input.StoreId,
                    StoreName = input.StoreName,
                    Remark = input.Remark,
                    Attachments = input.Attachments,
                    IsEffective = StatusEnum.有效.GetHashCode(),
                    CreateUser = _userManager.UserId,
                    CreateTime = DateTime.Now
                };

                await _db.Insertable(entity).ExecuteCommandAsync();

                return id;
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "创建公司日历事件失败");
                throw NCCException.Oh($"创建失败：{ex.Message}");
            }
        }

        /// <summary>
        /// 更新公司日历事件
        /// </summary>
        [HttpPost("UpdateCalendarEvent")]
        public async Task<bool> UpdateCalendarEventAsync([FromBody] LqCompanyCalendarUpdateInput input)
        {
            try
            {
                var entity = await _db.Queryable<LqCompanyCalendarEntity>()
                    .Where(x => x.Id == input.Id && x.IsEffective == StatusEnum.有效.GetHashCode())
                    .FirstAsync();

                if (entity == null)
                {
                    throw NCCException.Oh("事件不存在或已失效");
                }

                entity.Title = input.Title;
                entity.EventType = input.EventType;
                entity.StartTime = input.StartTime;
                entity.EndTime = input.EndTime;
                entity.Description = input.Description;
                entity.StoreId = input.StoreId;
                entity.StoreName = input.StoreName;
                entity.Remark = input.Remark;
                entity.Attachments = input.Attachments;
                entity.UpdateUser = _userManager.UserId;
                entity.UpdateTime = DateTime.Now;

                await _db.Updateable(entity).ExecuteCommandAsync();

                return true;
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "更新公司日历事件失败");
                throw NCCException.Oh($"更新失败：{ex.Message}");
            }
        }

        /// <summary>
        /// 删除公司日历事件
        /// </summary>
        [HttpPost("DeleteCalendarEvent/{id}")]
        public async Task<bool> DeleteCalendarEventAsync(string id)
        {
            try
            {
                var entity = await _db.Queryable<LqCompanyCalendarEntity>()
                    .Where(x => x.Id == id && x.IsEffective == StatusEnum.有效.GetHashCode())
                    .FirstAsync();

                if (entity == null)
                {
                    throw NCCException.Oh("事件不存在或已失效");
                }

                entity.IsEffective = StatusEnum.无效.GetHashCode();
                entity.UpdateUser = _userManager.UserId;
                entity.UpdateTime = DateTime.Now;

                await _db.Updateable(entity).ExecuteCommandAsync();

                return true;
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "删除公司日历事件失败");
                throw NCCException.Oh($"删除失败：{ex.Message}");
            }
        }

        #endregion
    }
}