using AutoMapper;
using WIDESEA_Common.LocationEnum;
using WIDESEA_Core;
using WIDESEA_Core.BaseRepository;
using WIDESEA_Core.BaseServices;
using WIDESEA_IStockService;
using WIDESEA_Model.Models;

namespace WIDESEA_StockService
{
    public partial class StockInfoService : ServiceBase<Dt_StockInfo, IRepository<Dt_StockInfo>>, IStockInfoService
    {
        private readonly IMapper _mapper;

        public IRepository<Dt_StockInfo> Repository => BaseDal;

        public StockInfoService(IRepository<Dt_StockInfo> BaseDal, IMapper mapper) : base(BaseDal)
        {
            _mapper = mapper;
        }

        /// <summary>
        /// 获取库存统计数据
        /// </summary>
        /// <returns></returns>
        public WebResponseContent GetStockStatistics()
        {
            var response = new WebResponseContent();
            try
            {
                // 定义库存状态常量
                const int STOCK_STATUS_INBOUND_COMPLETE = 6; // 入库完成状态
                const int STOCK_STATUS_OUTBOUND_COMPLETE = 8; // 出库完成状态

                // 获取当前日期时间
                var now = DateTime.Now;

                // 获取今日日期范围
                var todayStart = now.Date;
                var todayEnd = now.Date.AddDays(1);

                // 获取本周日期范围
                // 计算本周一的日期：如果今天是周日(0)，减去6天；否则减去当前星期几减1天
                var daysToSubtract = (int)now.DayOfWeek == 0 ? 6 : (int)now.DayOfWeek - 1;
                var weekStart = now.Date.AddDays(-daysToSubtract);
                var weekEnd = weekStart.AddDays(7);

                // 获取本月日期范围
                var monthStart = new DateTime(now.Year, now.Month, 1);
                var monthEnd = monthStart.AddMonths(1);

                // 获取所有库存数据，用于后续统计
                var allStockData = Repository.Db.Queryable<Dt_StockInfo>().ToList();

                // 调试信息：打印日期范围和库存数据总数
                var debugInfo = new
                {
                    CurrentDateTime = now,
                    TodayRange = $"{todayStart:yyyy-MM-dd HH:mm:ss} ~ {todayEnd:yyyy-MM-dd HH:mm:ss}",
                    WeekRange = $"{weekStart:yyyy-MM-dd HH:mm:ss} ~ {weekEnd:yyyy-MM-dd HH:mm:ss}",
                    MonthRange = $"{monthStart:yyyy-MM-dd HH:mm:ss} ~ {monthEnd:yyyy-MM-dd HH:mm:ss}",
                    TotalStockCount = allStockData.Count,
                    AllStockStatus = allStockData.Select(it => new { it.Id, it.StockStatus, it.CreateDate }).ToList()
                };

                // 总库存数量：库存状态为入库完成的记录数量
                var totalStock = allStockData.Count(it => it.StockStatus == STOCK_STATUS_INBOUND_COMPLETE);

                // 今日入库数量：今天创建且库存状态为入库完成的记录数量
                var todayInbound = allStockData.Count(it =>
                    it.CreateDate >= todayStart && it.CreateDate < todayEnd &&
                    it.StockStatus == STOCK_STATUS_INBOUND_COMPLETE);

                // 今日出库数量：今天创建且库存状态为出库完成的记录数量
                var todayOutbound = allStockData.Count(it =>
                    it.CreateDate >= todayStart && it.CreateDate < todayEnd &&
                    it.StockStatus == STOCK_STATUS_OUTBOUND_COMPLETE);

                // 本周入库数量：本周创建且库存状态为入库完成的记录数量
                var weekInbound = allStockData.Count(it =>
                    it.CreateDate >= weekStart && it.CreateDate < weekEnd &&
                    it.StockStatus == STOCK_STATUS_INBOUND_COMPLETE);

                // 本周出库数量：本周创建且库存状态为出库完成的记录数量
                var weekOutbound = allStockData.Count(it =>
                    it.CreateDate >= weekStart && it.CreateDate < weekEnd &&
                    it.StockStatus == STOCK_STATUS_OUTBOUND_COMPLETE);

                // 本月入库数量：本月创建且库存状态为入库完成的记录数量
                var monthInbound = allStockData.Count(it =>
                    it.CreateDate >= monthStart && it.CreateDate < monthEnd &&
                    it.StockStatus == STOCK_STATUS_INBOUND_COMPLETE);

                // 本月出库数量：本月创建且库存状态为出库完成的记录数量
                var monthOutbound = allStockData.Count(it =>
                    it.CreateDate >= monthStart && it.CreateDate < monthEnd &&
                    it.StockStatus == STOCK_STATUS_OUTBOUND_COMPLETE);

                // 待处理订单数量：由于只有Dt_StockInfo表，暂时返回0
                var pendingOrders = 0;

                // 库存状态分布：统计不同库存状态的数量
                var stockStatusDistribution = allStockData
                    .GroupBy(it => it.StockStatus)
                    .Select(g => new { Status = g.Key, Count = g.Count() })
                    .ToList();
                
                // 货位分布：统计不同货位的库存数量
                var locationDistribution = allStockData
                    .Where(it => !string.IsNullOrEmpty(it.LocationCode))
                    .GroupBy(it => it.LocationCode)
                    .Select(g => new { Location = g.Key, Count = g.Count() })
                    .OrderByDescending(g => g.Count)
                    .Take(10) // 只取前10个货位
                    .ToList();
                
                // 货位利用率：从数据库获取货位信息
                // 获取所有货位
                var allLocations = Repository.Db.Queryable<Dt_LocationInfo>().ToList();
                var totalLocations = allLocations.Count;
                
                // 统计不同状态的货位数
                var freeLocations = allLocations.Count(it => it.LocationStatus == (int)LocationStatusEnum.Free);
                var inStockLocations = allLocations.Count(it => it.LocationStatus == (int)LocationStatusEnum.InStock);
                var inStockLockLocations = allLocations.Count(it => it.LocationStatus == (int)LocationStatusEnum.InStockLock);
                var lockLocations = allLocations.Count(it => it.LocationStatus == (int)LocationStatusEnum.Lock);
                var freeLockLocations = allLocations.Count(it => it.LocationStatus == (int)LocationStatusEnum.FreeLock);
                var palletLockLocations = allLocations.Count(it => it.LocationStatus == (int)LocationStatusEnum.PalletLock);
                
                // 计算已使用和未使用的货位数
                // 已使用：有货、有货锁定
                var usedLocations = inStockLocations + inStockLockLocations;
                // 未使用：空闲、空闲锁定
                var unusedLocations = freeLocations + freeLockLocations;
                
                // 库存变化趋势：模拟最近7天的数据
                // 实际应根据数据库中的历史记录生成
                var stockTrend = Enumerable.Range(0, 7)
                    .Select(i => {
                        var date = now.AddDays(-6 + i).Date;
                        var count = allStockData.Count(it => 
                            it.CreateDate.Date <= date && 
                            it.StockStatus == STOCK_STATUS_INBOUND_COMPLETE &&
                            (it.StockStatus != STOCK_STATUS_OUTBOUND_COMPLETE || it.CreateDate.Date > date));
                        return new { Date = date.ToString("MM-dd"), Count = count };
                    })
                    .ToList();
                
                // 日出入库明细：按小时统计
                var dailyInout = new {
                    inbound = Enumerable.Range(8, 10).Select(hour => 
                        allStockData.Count(it => 
                            it.CreateDate >= todayStart.AddHours(hour) && 
                            it.CreateDate < todayStart.AddHours(hour + 1) && 
                            it.StockStatus == STOCK_STATUS_INBOUND_COMPLETE))
                        .ToList(),
                    outbound = Enumerable.Range(8, 10).Select(hour => 
                        allStockData.Count(it => 
                            it.CreateDate >= todayStart.AddHours(hour) && 
                            it.CreateDate < todayStart.AddHours(hour + 1) && 
                            it.StockStatus == STOCK_STATUS_OUTBOUND_COMPLETE))
                        .ToList()
                };
                
                // 周出入库统计：按天统计
                var weekInout = new {
                    inbound = Enumerable.Range(0, 7).Select(day => 
                        allStockData.Count(it => 
                            it.CreateDate >= weekStart.AddDays(day) && 
                            it.CreateDate < weekStart.AddDays(day + 1) && 
                            it.StockStatus == STOCK_STATUS_INBOUND_COMPLETE))
                        .ToList(),
                    outbound = Enumerable.Range(0, 7).Select(day => 
                        allStockData.Count(it => 
                            it.CreateDate >= weekStart.AddDays(day) && 
                            it.CreateDate < weekStart.AddDays(day + 1) && 
                            it.StockStatus == STOCK_STATUS_OUTBOUND_COMPLETE))
                        .ToList()
                };
                
                // 月出入库趋势：按5天统计
                var monthInout = new {
                    inbound = Enumerable.Range(0, 7).Select(i => 
                        allStockData.Count(it => 
                            it.CreateDate >= monthStart.AddDays(i * 5) && 
                            it.CreateDate < monthStart.AddDays((i + 1) * 5) && 
                            it.StockStatus == STOCK_STATUS_INBOUND_COMPLETE))
                        .ToList(),
                    outbound = Enumerable.Range(0, 7).Select(i => 
                        allStockData.Count(it => 
                            it.CreateDate >= monthStart.AddDays(i * 5) && 
                            it.CreateDate < monthStart.AddDays((i + 1) * 5) && 
                            it.StockStatus == STOCK_STATUS_OUTBOUND_COMPLETE))
                        .ToList()
                };
                
                // 组装返回数据，包含调试信息和图表数据
                var data = new
                {
                    totalLocations,
                    todayInbound,
                    todayOutbound,
                    weekInbound,
                    weekOutbound,
                    monthInbound,
                    monthOutbound,
                    pendingOrders,
                    
                    // 图表数据
                    stockStatus = stockStatusDistribution.Select(item => new { name = $"状态{item.Status}", value = item.Count }).ToList(),
                    locationDistribution = locationDistribution.Select(item => new { name = item.Location, value = item.Count }).ToList(),
                    // 货位利用率：包含不同状态的货位数量
                    warehouseUtilization = new {
                        total = totalLocations,
                        free = freeLocations,
                        inStock = inStockLocations,
                        inStockLock = inStockLockLocations,
                        lockLocations = lockLocations,
                        freeLock = freeLockLocations,
                        palletLock = palletLockLocations,
                        used = usedLocations,
                        unused = unusedLocations
                    },
                    stockTrend = stockTrend.Select(item => item.Count).ToList(),
                    dailyInout,
                    weekInout,
                    monthInout,
                    
                    debugInfo
                };

                response.Status = true;
                response.Data = data;
                response.Message = "获取成功";
            }
            catch (Exception ex)
            {
                response.Status = false;
                response.Message = ex.Message;
                response.Data = new
                {
                    Exception = ex.ToString(),
                    StackTrace = ex.StackTrace
                };
            }
            return response;
        }   
    }
}