using RIZO.Model;
using RIZO.Model.MES.recipe;
using RIZO.Model.MES.recipe.Dto;
using RIZO.Repository;
using RIZO.Service.MES.recipe.IService;
using Infrastructure.Attribute;
using Infrastructure.Extensions;
using Infrastructure.Model;
using JinianNet.JNTemplate.Nodes;
using MDM.Service;

namespace RIZO.Service.MES.recipe
{
    /// <summary>
    /// 配方版本控制表Service业务层处理
    /// </summary>
    [AppService(ServiceType = typeof(IPfRecipeVersionService), ServiceLifetime = LifeTime.Transient)]
    public class PfRecipeVersionService : BaseService<PfRecipeVersion>, IPfRecipeVersionService
    {
        private readonly PfRefProductRecipeService pfRefProductRecipeService = new PfRefProductRecipeService();
        private readonly PfRecipeParametersService pfRecipeParametersService = new PfRecipeParametersService();
        /// <summary>
        /// 查询配方版本控制表列表
        /// </summary>
        /// <param name="parm"></param>
        /// <returns></returns>
        public PagedInfo<PfRecipeVersionDto> GetList(PfRecipeVersionQueryDto parm)
        {
            var predicate = QueryExp(parm);
            var query = Context.Queryable<PfRecipeVersion, PfRefProductRecipe>((t, p) => new object[] {
             JoinType.Inner, t.RecipeCode == p.RecipeCode })
            .Where(predicate.ToExpression())
            .Select((t, p) => new PfRecipeVersionDto
            {
                Id = t.Id,
                RecipeCode = t.RecipeCode,
                Version = t.Version,
                Status = t.Status,
                Sequence = t.Sequence,
                ProductCode = p.Productcode,
                ProductName = p.ProductName,
                IssueStatus = SqlFunc.Subqueryable<PfRecipeIssueLog>()
                .Where(h => h.RecipeCode == t.RecipeCode && h.Version == t.Version)
                .Any() ? 1 : 0
            }).OrderByDescending(t => t.Sequence);
            var response = query.ToPage<PfRecipeVersionDto>(parm);
            return response;
        }

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

            return response;
        }

        /// <summary>
        /// 添加配方版本控制表
        /// </summary>
        /// <param name="model"></param>
        /// <returns></returns>
        public PfRecipeVersion AddPfRecipeVersion(PfRecipeVersion model)
        {
            return Insertable(model).ExecuteReturnEntity();
        }

        /// <summary>
        /// 修改配方版本控制表
        /// </summary>
        /// <param name="model"></param>
        /// <returns></returns>
        public int UpdatePfRecipeVersion(PfRecipeVersion model)
        {
            return Update(model, true);
        }

        /// <summary>
        /// 查询导出表达式
        /// </summary>
        /// <param name="parm"></param>
        /// <returns></returns>
        private static Expressionable<PfRecipeVersion> QueryExp(PfRecipeVersionQueryDto parm)
        {
            var predicate = Expressionable.Create<PfRecipeVersion>();
            if (parm != null)
            { 
                if (!string.IsNullOrEmpty(parm.RecipeCode))
                {
                    predicate.And(t => t.RecipeCode == parm.RecipeCode);
                }
                if (!string.IsNullOrEmpty(parm.Version))
                {
                    predicate.And(t => t.Version == parm.Version);
                }
                //if (!string.IsNullOrEmpty(parm.Status.ToString()))
                //{
                //    predicate.And(t => t.Status == parm.Status);
                //}
            }
            return predicate;
        }

        public ApiResult CreatePfRecipeVersionAndParameters(PfRecipeVersionDto parm)
        {

            try
            {
                int Sequence = 1;
                var pfVersionMax = Queryable()
                   .Where(x => x.RecipeCode == parm.RecipeCode).OrderByDescending(x => x.Sequence).First();
                if (pfVersionMax != null)
                {
                    Sequence = pfVersionMax.Sequence;
                    Sequence += 1;
                }
                var pfVersion = Queryable().Where(x => x.RecipeCode == parm.RecipeCode && x.Version == parm.Version).First();
                if (pfVersion != null)
                {
                    return ApiResult.Error("该配方版本已存在！");
                }
                PfRecipeVersion pfRecipeVersion = new PfRecipeVersion();
                List<PfRecipeParameters> pfRecipeParametersList = new List<PfRecipeParameters>();
                pfRecipeVersion.RecipeCode = parm.RecipeCode;
                pfRecipeVersion.Version = parm.Version;
                pfRecipeVersion.Status = 1;
                pfRecipeVersion.Sequence = Sequence;
                pfRecipeVersion.CreatedBy = parm.CreatedBy;
                pfRecipeVersion.CreatedTime = parm.CreatedTime;
                pfRecipeVersion.UpdatedBy = parm.UpdatedBy;
                pfRecipeVersion.UpdatedTime = parm.UpdatedTime;
                foreach (var item in parm.RecipeParametersList)
                {
                    PfRecipeParameters pfRecipeParameters = new PfRecipeParameters();
                    pfRecipeParameters.RecipeCode = parm.RecipeCode;
                    pfRecipeParameters.Version = parm.Version;
                    pfRecipeParameters.ParamName = item.ParamName;
                    pfRecipeParameters.Unit = item.Unit;
                    pfRecipeParameters.UpperLimit = item.UpperLimit;
                    pfRecipeParameters.LowerLimit = item.LowerLimit;
                    pfRecipeParameters.StandardValue = item.StandardValue;
                    pfRecipeParameters.Remark = item.Remark;
                    pfRecipeParameters.Ifcheck = item.Ifcheck;
                    pfRecipeParameters.CreatedBy = item.CreatedBy;
                    pfRecipeParameters.CreatedTime = item.CreatedTime;
                    pfRecipeParameters.UpdatedBy = item.UpdatedBy;
                    pfRecipeParameters.UpdatedTime = item.UpdatedTime;
                    pfRecipeParametersList.Add(pfRecipeParameters);
                }
                int iResult = Insert(pfRecipeVersion);
                if (iResult > 0)
                {
                    iResult = pfRecipeParametersService.Insert(pfRecipeParametersList);
                    return ApiResult.Success("操作成功！", pfRecipeParametersList);
                }
                else
                {
                    return ApiResult.Error("操作失败！");
                }
            }
            catch (Exception ex)
            {
                return ApiResult.Error(ex.Message);
            }
        }

        public ApiResult QuerylatestVersion(PfRecipeVersionQueryDto parm)
        {
            var pfVersionMax = Queryable()
                   .Where(x => x.RecipeCode == parm.RecipeCode).OrderByDescending(x => x.Sequence).First();
            if (pfVersionMax == null)
            {
                return ApiResult.Success("操作成功！", null);
            }
            else
            {
                var parametersList = pfRecipeParametersService.Queryable()
                    .Where(x => x.RecipeCode == pfVersionMax.RecipeCode && x.Version == pfVersionMax.Version)
                    .Select(x => new PfRecipeParametersDto
                    {
                        Id = x.Id,
                        RecipeCode = x.RecipeCode,
                        ParamName = x.ParamName,
                        Unit = x.Unit,
                        UpperLimit = x.UpperLimit,
                        LowerLimit = x.LowerLimit,
                        StandardValue = x.StandardValue,
                        Remark = x.Remark,
                        Ifcheck = x.Ifcheck,
                    })
                    .ToList();
                if (parametersList != null && parametersList.Count > 0)
                {
                    return ApiResult.Success("操作成功！", parametersList);
                }
                else
                {
                    return ApiResult.Success("操作成功！", null);
                }
            }
        }

        public ApiResult DELPfRecipeVersion(PfRecipeVersionDto parm)
        { 
            string recipeCode = parm.RecipeCode;
            string version = parm.Version;
            if (string.IsNullOrEmpty(recipeCode) || string.IsNullOrEmpty(version))
            { 
                return ApiResult.Error("参数错误！");
            }
            var iResult = Deleteable()
                .Where(x => x.RecipeCode == recipeCode && x.Version == version)
                .ExecuteCommand();
            if (iResult > 0)
            {
                pfRecipeParametersService.Deleteable()
                    .Where(x => x.RecipeCode == recipeCode && x.Version == version)
                    .ExecuteCommand();
                return ApiResult.Success("操作成功！");
            }
            else
            {
                return ApiResult.Error("操作失败！");
            }
        }
    }
}