using Infrastructure.Attribute;
using Infrastructure.Extensions;
using ZR.Model.Business.Dto;
using ZR.Model.Business;
using ZR.Repository;
using ZR.Service.Business.IBusinessService;

namespace ZR.Service.Business
{
    /// <summary>
    /// 端口Service业务层处理
    /// </summary>
    [AppService(ServiceType = typeof(IOdfPortsService), ServiceLifetime = LifeTime.Transient)]
    public class OdfPortsService : BaseService<OdfPorts>, IOdfPortsService
    {
        /// <summary>
        /// 查询端口列表
        /// </summary>
        /// <param name="parm"></param>
        /// <returns></returns>
        public PagedInfo<OdfPortsDto> GetList(OdfPortsQuerysDto parm)
        {
            var predicate = QueryExp(parm);

            var response = Queryable()
                //.OrderBy("Id asc")
                .Where(predicate.ToExpression())
                .OrderBy("RoomId asc,RackId asc,FrameId asc,RowNumber asc,PortNumber Asc")
                //.OrderBy(it => it.RoomId)
                //.OrderBy(it => it.RackId)
                //.OrderBy(it => it.Id)
                //.OrderBy(it => it.Name)
                .ToPage<OdfPorts, OdfPortsDto>(parm);

            return response;
        }

        /// <summary>
        /// 查询端口列表
        /// </summary>
        /// <param name="parm"></param>
        /// <returns></returns>
        public PagedInfo<OdfPortsDto> GetList(OdfPortsQueryDto parm)
        {
            var predicate = QueryExp(parm);

            var response = Queryable()
                //.OrderBy("Id asc")
                .Where(predicate.ToExpression())
                .OrderBy("RoomId asc,RackId asc,FrameId asc,RowNumber asc,PortNumber Asc")
                .ToPage<OdfPorts, OdfPortsDto>(parm);

            return response;
        }


        /// <summary>
        /// 获取详情
        /// </summary>
        /// <param name="Id"></param>
        /// <returns></returns>
        public OdfPorts GetInfo(int Id)
        {
            var response = Queryable()
                .Where(x => x.Id == Id)
                .First();

            return response;
        }

        /// <summary>
        /// 添加端口
        /// </summary>
        /// <param name="model"></param>
        /// <returns></returns>
        public OdfPorts AddOdfPorts(OdfPorts model)
        {
            return Insertable(model).ExecuteReturnEntity();
        }

        /// <summary>
        /// 修改端口
        /// </summary>
        /// <param name="model"></param>
        /// <returns></returns>
        public int UpdateOdfPorts(OdfPorts model)
        {
            return Update(model, true, "修改端口");
        }

        /// <summary>
        /// 导入端口
        /// </summary>
        /// <returns></returns>
        public (string, object, object) ImportOdfPorts(List<OdfPorts> list)
        {
            var x = Context.Storageable(list)
                .SplitInsert(it => !it.Any())
                .SplitError(x => x.Item.Name.IsEmpty(), "端口名称不能为空")
                .SplitError(x => x.Item.RoomId.IsEmpty(), "机房ID不能为空")
                .SplitError(x => x.Item.RoomName.IsEmpty(), "机房名称不能为空")
                .SplitError(x => x.Item.RackId.IsEmpty(), "机架ID不能为空")
                .SplitError(x => x.Item.RackName.IsEmpty(), "机架名称不能为空")
                .SplitError(x => x.Item.FrameId.IsEmpty(), "框ID不能为空")
                .SplitError(x => x.Item.FrameName.IsEmpty(), "框名称不能为空")
                .SplitError(x => x.Item.DeptId.IsEmpty(), "部门ID不能为空")
                .SplitError(x => x.Item.RowNumber.IsEmpty(), "行号（1-6）不能为空")
                .SplitError(x => x.Item.PortNumber.IsEmpty(), "端口号（1-12）不能为空")
                .SplitError(x => x.Item.Status.IsEmpty(), "连接状态，0正常，1断开不能为空")
                .SplitError(x => x.Item.CreatedAt.IsEmpty(), "创建时间不能为空")
                .SplitError(x => x.Item.UpdatedAt.IsEmpty(), "修改时间不能为空")
                //.WhereColumns(it => it.UserName)//如果不是主键可以这样实现（多字段it=>new{it.x1,it.x2}）
                .ToStorage();
            var result = x.AsInsertable.ExecuteCommand();//插入可插入部分;

            string msg = $"插入{x.InsertList.Count} 更新{x.UpdateList.Count} 错误数据{x.ErrorList.Count} 不计算数据{x.IgnoreList.Count} 删除数据{x.DeleteList.Count} 总共{x.TotalList.Count}";
            Console.WriteLine(msg);

            //输出错误信息               
            foreach (var item in x.ErrorList)
            {
                Console.WriteLine("错误" + item.StorageMessage);
            }
            foreach (var item in x.IgnoreList)
            {
                Console.WriteLine("忽略" + item.StorageMessage);
            }

            return (msg, x.ErrorList, x.IgnoreList);
        }

        /// <summary>
        /// 导出端口
        /// </summary>
        /// <param name="parm"></param>
        /// <returns></returns>
        public PagedInfo<OdfPortsDto> ExportList(OdfPortsQueryDto parm)
        {
            parm.PageNum = 1;
            parm.PageSize = 100000;
            var predicate = QueryExp(parm);

            var response = Queryable()
                .Where(predicate.ToExpression())
                   .OrderBy("RoomId asc,RackId asc,FrameId asc,RowNumber asc,PortNumber Asc")
                .Select((it) => new OdfPortsDto()
                {
                }, true)
                .ToPage(parm);

            return response;
        }

        /// <summary>
        /// 导出端口
        /// </summary>
        /// <param name="parm"></param>
        /// <returns></returns>
        public PagedInfo<OdfPortsDto> ExportList(OdfPortsQuerysDto parm)
        {
            parm.PageNum = 1;
            parm.PageSize = 100000;
            var predicate = QueryExp(parm);

            var response = Queryable()
                .Where(predicate.ToExpression())
                   .OrderBy("RoomId asc,RackId asc,FrameId asc,RowNumber asc,PortNumber Asc")
                .Select((it) => new OdfPortsDto()
                {
                }, true)
                .ToPage(parm);

            return response;
        }
        /// <summary>
        /// 查询导出表达式
        /// </summary>
        /// <param name="parm"></param>
        /// <returns></returns>
        private static Expressionable<OdfPorts> QueryExp(OdfPortsQuerysDto parm)
        {
            var predicate = Expressionable.Create<OdfPorts>();

            predicate = predicate.AndIF(!string.IsNullOrEmpty(parm.RoomName), it => it.RoomName.Contains(parm.RoomName));
            predicate = predicate.AndIF(!string.IsNullOrEmpty(parm.RackName), it => it.RackName.Contains(parm.RackName));
            predicate = predicate.AndIF(!string.IsNullOrEmpty(parm.FrameName), it => it.FrameName.Contains(parm.FrameName));
            predicate = predicate.AndIF(parm.Status != null, it => it.Status == parm.Status);
            predicate = predicate.AndIF(!string.IsNullOrEmpty(parm.Remarks), it => it.Remarks.Contains(parm.Remarks));
            predicate = predicate.AndIF(!string.IsNullOrEmpty(parm.OpticalAttenuation), it => it.OpticalAttenuation.Contains(parm.OpticalAttenuation));
            predicate = predicate.AndIF(!string.IsNullOrEmpty(parm.HistoryRemarks), it => it.HistoryRemarks.Contains(parm.HistoryRemarks));
            if (!string.IsNullOrEmpty(parm.OpticalCableOffRemarks))
            {
                predicate = predicate.And(f => f.OpticalCableOffRemarks.Contains(parm.OpticalCableOffRemarks));
            }
            return predicate;
        }

        /// <summary>
        /// 查询导出表达式
        /// </summary>
        /// <param name="parm"></param>
        /// <returns></returns>
        private static Expressionable<OdfPorts> QueryExp(OdfPortsQueryDto parm)
        {
            var predicate = Expressionable.Create<OdfPorts>();
            if (parm.RoomId != null)
            {
                predicate = predicate.And(f => f.RoomId == parm.RoomId);
            }
            if (parm.RacksId != null)
            {
                predicate = predicate.And(f => f.RackId == parm.RacksId);
            }
            if (parm.FramesId != null)
            {
                predicate = predicate.And(f => f.FrameId == parm.FramesId);
            }
            if (!string.IsNullOrEmpty(parm.Name))
            {
                predicate = predicate.And(f => f.Name.Contains(parm.Name));
            }
            if (!string.IsNullOrEmpty(parm.Remarks))
            {
                predicate = predicate.And(f => f.Remarks.Contains(parm.Remarks));
            }
            if (!string.IsNullOrEmpty(parm.HistoryRemarks))
            {
                predicate = predicate.And(f => f.HistoryRemarks.Contains(parm.HistoryRemarks));
            }
            if (!string.IsNullOrEmpty(parm.OpticalCableOffRemarks))
            {
                predicate = predicate.And(f => f.OpticalCableOffRemarks.Contains(parm.OpticalCableOffRemarks));
            }
            return predicate;
        }
    }
}