using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Bowin.Common.Linq.Entity;
using Bowin.Common.Linq;
using EMIS.DataLogic.DegreeManage.DegreeSetting;
using EMIS.ViewModel;
using EMIS.ViewModel.DegreeManage.DegreeSetting;
using System.Linq.Expressions;
using EMIS.Entities;

namespace EMIS.CommonLogic.DegreeManage.DegreeSetting
{
    public class DegreeConditionPackageServices : BaseServices, IDegreeConditionPackageServices
    {
        public DegreeConditionPackageDAL DegreeConditionPackageDAL { get; set; }

        /// <summary>
        /// 查询对应的学位公式信息View（只查询学位公式信息，不查询学位公式对应的学位条件）
        /// </summary>
        /// <param name="configuretView"></param>
        /// <param name="isDefault"></param>
        /// <param name="pageIndex"></param>
        /// <param name="pageSize"></param>
        /// <returns></returns>
        public IGridResultSet<DegreeConditionPackageView> GetDegreeConditionPackageViewGrid(ConfiguretView configuretView, 
                int? isDefault, int pageIndex, int pageSize)
        {
            //学位公式
            Expression<Func<ER_DegreeConditionPackage, bool>> exp = (x => true);
            if (isDefault.HasValue)
            {
                if (isDefault == 1)
                {
                    exp = exp.And(x => x.IsDefault.Value == true);
                }
                if (isDefault == 0)
                {
                    exp = exp.And(x => x.IsDefault.Value != true);
                }
            }

            var query = DegreeConditionPackageDAL.GetDegreeConditionPackageViewQueryable(exp);

            //查询条件
            if (!string.IsNullOrEmpty(configuretView.ConditionValue))
            {
                query = query.DynamicWhere(configuretView.Attribute, configuretView.Condition, configuretView.ConditionValue.Trim());
            }

            return query.OrderByDescending(x => x.Title).ThenBy(x => x.IsDefault)
                    .ToGridResultSet<DegreeConditionPackageView>(pageIndex, pageSize);
        }

        /// <summary>
        /// 查询对应的学位公式信息List
        /// </summary>
        /// <param name="configuretView"></param>
        /// <param name="isDefault"></param>
        /// <returns></returns>
        public List<DegreeConditionPackageView> GetDegreeConditionPackageViewList(ConfiguretView configuretView, int? isDefault)
        {
            //学位公式
            Expression<Func<ER_DegreeConditionPackage, bool>> exp = (x => true);
            if (isDefault.HasValue)
            {
                if (isDefault == 1)
                {
                    exp = exp.And(x => x.IsDefault.Value == true);
                }
                if (isDefault == 0)
                {
                    exp = exp.And(x => x.IsDefault.Value != true);
                }
            }

            var query = DegreeConditionPackageDAL.GetDegreeConditionPackageViewQueryable(exp);

            //查询条件
            if (!string.IsNullOrEmpty(configuretView.ConditionValue))
            {
                query = query.DynamicWhere(configuretView.Attribute, configuretView.Condition, configuretView.ConditionValue.Trim());
            }

            return query.OrderByDescending(x => x.Title).ThenBy(x => x.IsDefault).ToList();
        }

        /// <summary>
        /// 根据学位公式ID查询对应的学位公式信息DegreeConditionPackageView
        /// </summary>
        /// <param name="DegreeConditionPackageID"></param>
        /// <returns></returns>
        public DegreeConditionPackageView GetDegreeConditionPackageView(Guid? DegreeConditionPackageID)
        {
            try
            {
                var query = DegreeConditionPackageDAL
                    .GetDegreeConditionPackageViewQueryable(x => x.DegreeConditionPackageID == DegreeConditionPackageID)
                    .SingleOrDefault();

                return query;
            }
            catch (Exception ex)
            {

                throw new Exception(ex.Message);
            }
        }

        /// <summary>
        /// 根据学位公式ID查询对应的学位条件信息List
        /// </summary>
        /// <param name="DegreeConditionPackageID"></param>
        /// <returns></returns>
        public List<DegreeConditionView> GetDegreeConditionList(Guid? DegreeConditionPackageID)
        {
            var query = DegreeConditionPackageDAL
                    .GetDegreeConditionQueryable(x => x.DegreeConditionPackageID == DegreeConditionPackageID);

            return query.OrderBy(x => x.OrderNo).ToList();
        }

        /// <summary>
        /// 查询学位公式中未存在的学位条件信息View
        /// </summary>
        /// <param name="configuretView"></param>
        /// <param name="degreeConditionPackageID"></param>
        /// <param name="isCurrent"></param>
        /// <param name="pageIndex"></param>
        /// <param name="pageSize"></param>
        /// <returns></returns>
        public IGridResultSet<DegreeConditionView> GetDegreeConditionNoViewGrid(ConfiguretView configuretView, 
                Guid? degreeConditionPackageID, int? isCurrent, int pageIndex, int pageSize)
        {
            //学位条件
            Expression<Func<ER_DegreeCondition, bool>> expDegreeCondition = (x => true);
            if (isCurrent.HasValue)
            {
                if (isCurrent == 1)
                {
                    expDegreeCondition = expDegreeCondition.And(x => x.RecordStatus >= (int)SYS_STATUS.USABLE);
                }
                if (isCurrent == 0)
                {
                    expDegreeCondition = expDegreeCondition.And(x => x.RecordStatus <= (int)SYS_STATUS.UNUSABLE);
                }
            }

            var query = DegreeConditionPackageDAL.GetDegreeConditionNoQueryable(expDegreeCondition, degreeConditionPackageID);
            
            //查询条件
            if (!string.IsNullOrEmpty(configuretView.ConditionValue))
            {
                query = query.DynamicWhere(configuretView.Attribute, configuretView.Condition, configuretView.ConditionValue.Trim());
            }

            return query.OrderBy(x => x.OrderNo).ToGridResultSet<DegreeConditionView>(pageIndex, pageSize);
        }

        /// <summary>
        /// 查询学位公式中未存在的学位条件信息List
        /// </summary>
        /// <param name="configuretView"></param>
        /// <param name="isCurrent"></param>
        /// <returns></returns>
        public IList<DegreeConditionView> GetDegreeConditionNoViewList(ConfiguretView configuretView, 
                Guid? degreeConditionPackageID, int? isCurrent)
        {
            //学位条件
            Expression<Func<ER_DegreeCondition, bool>> expDegreeCondition = (x => true);
            if (isCurrent.HasValue)
            {
                if (isCurrent == 1)
                {
                    expDegreeCondition = expDegreeCondition.And(x => x.RecordStatus >= (int)SYS_STATUS.USABLE);
                }
                if (isCurrent == 0)
                {
                    expDegreeCondition = expDegreeCondition.And(x => x.RecordStatus <= (int)SYS_STATUS.UNUSABLE);
                }
            }

            var query = DegreeConditionPackageDAL.GetDegreeConditionNoQueryable(expDegreeCondition, degreeConditionPackageID);

            //查询条件
            if (!string.IsNullOrEmpty(configuretView.ConditionValue))
            {
                query = query.DynamicWhere(configuretView.Attribute, configuretView.Condition, configuretView.ConditionValue.Trim());
            }

            return query.OrderBy(x => x.OrderNo).ToList();
        }

        /// <summary>
        /// 编辑（新增、修改）
        /// 注：判断是否默认状态（同一种学生类别，只有一种默认公式）
        /// 暂时不考虑当公式被引用时，不可修改公式中条件的情况
        /// </summary>
        /// <param name="degreeConditionPackageView"></param>
        /// <param name="degreeConditionViewList"></param>
        public void DegreeConditionPackageEdit(DegreeConditionPackageView degreeConditionPackageView, 
                IList<DegreeConditionView> degreeConditionViewList)
        {
            try
            {
                //查询数据库进行验证
                var degreeConditionPackageVerification = DegreeConditionPackageDAL.DegreeConditionPackageRepository
                        .GetList(x => x.DegreeConditionPackageID != degreeConditionPackageView.DegreeConditionPackageID
                                && x.Title == degreeConditionPackageView.Title)
                                .SingleOrDefault();

                //列表页面对应的学位条件IDList
                var degreeConditionIDList = degreeConditionViewList.Select(x => x.DegreeConditionID).ToList();

                //列表页面对应的学位条件信息List
                var degreeConditionList = DegreeConditionPackageDAL.DegreeConditionRepository
                        .GetList(x => degreeConditionIDList.Contains(x.DegreeConditionID)).ToList();

                if (degreeConditionPackageVerification == null)
                {
                    //数据有误验证
                    if (degreeConditionPackageView.DegreeConditionPackageID != Guid.Empty)
                    {
                        var degreeConditionPackage = DegreeConditionPackageDAL.DegreeConditionPackageRepository
                                .GetList(x => x.DegreeConditionPackageID == degreeConditionPackageView.DegreeConditionPackageID)
                                .SingleOrDefault();
                        if (degreeConditionPackage == null)
                        {
                            throw new Exception("数据有误，请核查");
                        }
                        else
                        {
                            //表示修改
                            ////注：当学位申请、学位审核、学位名单中有引用相关的学位公式时，不可对相应的学位公式进行修改--是否默认列除外

                            ////根据学位公式查询对应的学位申请、学位审核、学位名单信息（外键引用）
                            //var degreeApplyList = DegreeConditionPackageDAL.DegreeApplyRepository
                            //        .GetList(x => x.DegreeConditionPackageID == degreeConditionPackageView.DegreeConditionPackageID).ToList();


                            //判断是否默认状态（同一种学生类别，只能启用一种默认公式）
                            if (degreeConditionPackageView.IsDefault)
                            {
                                var degreeConditionPackageList = DegreeConditionPackageDAL
                                        .DegreeConditionPackageRepository
                                        .GetList(x => x.StudentType == degreeConditionPackageView.StudentTypeID && x.IsDefault.Value
                                            && x.DegreeConditionPackageID != degreeConditionPackageView.DegreeConditionPackageID)
                                        .ToList();

                                degreeConditionPackageList.ForEach(x => x.IsDefault = false);
                            }

                            degreeConditionPackage.Title = degreeConditionPackageView.Title;
                            degreeConditionPackage.StudentType = degreeConditionPackageView.StudentTypeID;
                            degreeConditionPackage.IsDefault = degreeConditionPackageView.IsDefault;
                            SetModifyStatus(degreeConditionPackage);

                            ////查询学位公式对应的学位条件信息
                            //var degreeConditionList = DegreeConditionPackageDAL
                            //        .GetDegreeConditionQueryable(x => x.DegreeConditionPackageID == degreeConditionPackageView.DegreeConditionPackageID)
                            //        .ToList();

                            ////查询学位公式对应的学位条件IDList
                            //var degreeConditionIDList = degreeConditionList.Select(x => x.DegreeConditionID).ToList();

                            ////先删除学位公式对应的全部学位条件信息，再对选择的学位条件进行新增
                            //degreeConditionPackage.ER_DegreeCondition
                            //        .RemoveWhere(x => degreeConditionIDList.Contains(x.DegreeConditionID));


                            //物理删除（暂时将上述逻辑删除代码注释）
                            UnitOfWork.Delete(degreeConditionPackage, (x => x.ER_DegreeCondition));

                            //对应的学位条件
                            if (degreeConditionViewList != null && degreeConditionViewList.Count() > 0)
                            {
                                foreach (var degreeCondition in degreeConditionList)
                                {
                                    degreeConditionPackage.ER_DegreeCondition.Add(degreeCondition);
                                }
                            }

                        }
                    }
                    else
                    {
                        //表示新增
                        //判断是否默认状态（同一种学生类别，只能启用一种默认公式）
                        if (degreeConditionPackageView.IsDefault)
                        {
                            var degreeConditionPackageList = DegreeConditionPackageDAL
                                    .DegreeConditionPackageRepository
                                    .GetList(x => x.StudentType == degreeConditionPackageView.StudentTypeID && x.IsDefault.Value)
                                    .ToList();

                            degreeConditionPackageList.ForEach(x => x.IsDefault = false);
                        }

                        ER_DegreeConditionPackage degreeConditionPackage = new ER_DegreeConditionPackage();
                        degreeConditionPackage.DegreeConditionPackageID = Guid.NewGuid();
                        degreeConditionPackage.Title = degreeConditionPackageView.Title;
                        degreeConditionPackage.StudentType = degreeConditionPackageView.StudentTypeID;
                        degreeConditionPackage.IsDefault = degreeConditionPackageView.IsDefault;
                        SetNewStatus(degreeConditionPackage);
                        UnitOfWork.Add(degreeConditionPackage);

                        //对应的学位条件
                        if (degreeConditionViewList != null && degreeConditionViewList.Count() > 0)
                        {
                            foreach (var degreeCondition in degreeConditionList)
                            {
                                degreeConditionPackage.ER_DegreeCondition.Add(degreeCondition);
                            }
                        }
                    }

                    //事务提交
                    UnitOfWork.Commit();
                }
                else
                {
                    throw new Exception("已存在相同的学位公式，请核查");
                }

            }
            catch (Exception ex)
            {

                throw new Exception(ex.Message);
            }
        }

        /// <summary>
        /// 删除（当对应的学位公式被引用时，不可删除--学位公式、对应的学位条件）
        /// </summary>
        /// <param name="DegreeConditionPackageIDList"></param>
        /// <returns></returns>
        public bool DegreeConditionPackageDelete(List<Guid?> DegreeConditionPackageIDList)
        {
            try
            {
                //根据学位公式查询对应的学位申请、学位审核、学位名单信息（外键引用）
                var degreeApplyList = DegreeConditionPackageDAL.DegreeApplyRepository
                        .GetList(x => DegreeConditionPackageIDList.Contains(x.DegreeConditionPackageID)).ToList();

                if (degreeApplyList != null && degreeApplyList.Count() > 0)
                {
                    throw new Exception("存在与其有关联的数据，如：学位申请、学位审核、学位名单等");
                }

                //查询相应的学位公式及对应的学位条件信息List
                var degreeConditionPackageList = DegreeConditionPackageDAL.DegreeConditionPackageRepository
                        .GetList(x => DegreeConditionPackageIDList.Contains(x.DegreeConditionPackageID), x => x.ER_DegreeCondition)
                        .ToList();

                foreach (var degreeConditionPackage in degreeConditionPackageList)
                {
                    //物理删除
                    UnitOfWork.Delete(degreeConditionPackage, (x => x.ER_DegreeCondition));

                    UnitOfWork.Delete<ER_DegreeConditionPackage>(x => x.DegreeConditionPackageID == degreeConditionPackage.DegreeConditionPackageID);

                }

                UnitOfWork.Commit();

                return true;
            }
            catch (Exception ex)
            {

                throw new Exception(ex.Message);
            }
        }

        /// <summary>
        /// 根据学生类别查询对应的默认学位公式信息View（DegreeConditionPackageView）
        /// </summary>
        /// <param name="studentType"></param>
        /// <returns></returns>
        public DegreeConditionPackageView GetDegreeConditionPackageIsDefaultView(int? studentType)
        {
            try
            {
                //学位公式
                Expression<Func<ER_DegreeConditionPackage, bool>> exp = (x => true);
                exp = exp.And(x => x.IsDefault.Value == true);
                exp = exp.And(x => x.StudentType == studentType);

                var degreeConditionPackageView = DegreeConditionPackageDAL
                        .GetDegreeConditionPackageViewQueryable(exp).SingleOrDefault();

                return degreeConditionPackageView;

            }
            catch (Exception ex)
            {

                throw new Exception(ex.Message);
            }
        }

    }
}