using HH.WMS.BLL;
using HH.WMS.BLL.InStock;
using HH.WMS.Common;
using HH.WMS.Entitys;
using HH.WMS.Entitys.Basic;
using HH.WMS.Entitys.Common;
using HH.WMS.WebApi.Areas.Common.Controllers;
using Newtonsoft.Json;
using Newtonsoft.Json.Converters;
using System;
using System.Collections.Generic;
using System.Data;
using System.Linq;
using System.Net;
using System.Net.Http;
using System.Web.Http;

namespace HH.WMS.WebApi.Areas.InStock.Controllers
{
    public class InOrderController : BaseController
    {
        #region 新增入库订单
        /// <summary>
        /// 新增入库订单
        /// </summary>
        /// <param name="Entity">入库订单实体</param>
        /// <returns></returns>
        /// <History>[HANHE(XDL)] CREATED BY 2019-02-20</History>
        [HttpPost]
        public OperateResult AddInOrder(TN_WM_IN_MSTEntity entity)
        {
            try
            {
                return ValidateToken(entity.TokenId, t =>
                {
                    OperateResult result = new OperateResult();

                    entity.CN_S_ORGAN = t.CN_S_ORGCODE;
                    entity.CN_S_CREATOR = t.CN_S_LOGIN;
                    entity.CN_S_CREATOR_BY = t.CN_S_NAME;
                    entity.CN_T_CREATE = DateTime.Now;

                    entity.CN_S_MODIFY = t.CN_S_LOGIN;
                    entity.CN_S_MODIFY_BY = t.CN_S_NAME;
                    entity.CN_T_MODIFY = DateTime.Now;

                    entity.CN_GUID = Guid.NewGuid().ToString();
                    entity.CN_S_OWNER = Constants.DefaultOwner;
                    int rowNo = 1;
                    foreach (var inDtl in entity.DTLEntity)
                    {
                        inDtl.CN_GUID = Guid.NewGuid().ToString();
                        inDtl.CN_N_ROW_NO = rowNo++;
                        inDtl.CN_S_MSTGUID = entity.CN_GUID;
                        inDtl.CN_S_OP_NO = entity.CN_S_OP_NO;
                        inDtl.CN_S_STATE = entity.CN_S_STATE;
                        inDtl.CN_S_ITEM_STATE = string.IsNullOrEmpty(inDtl.CN_S_ITEM_STATE) ? "合格" : inDtl.CN_S_ITEM_STATE.ToString();
                        inDtl.CN_T_CREATE = DateTime.Now;
                        inDtl.CN_S_CREATOR = entity.CN_S_CREATOR;
                        inDtl.CN_S_CREATOR_BY = entity.CN_S_CREATOR_BY;
                        inDtl.CN_T_MODIFY = DateTime.Now;
                        inDtl.CN_S_MODIFY = entity.CN_S_MODIFY;
                        inDtl.CN_S_MODIFY_BY = entity.CN_S_MODIFY_BY;
                    }

                    result = BLLCreator.Create<TN_WM_INBLL>().AddInOrder(entity, t);


                    if (result.Success && (entity.OperateMessage == Constants.Operate_EditAndSubmit))
                    {
                        List<TN_WM_B_EXAMINEEntity> examineList = new List<TN_WM_B_EXAMINEEntity>();
                        examineList.Add(new TN_WM_B_EXAMINEEntity()
                        {
                            CN_GUID = System.Guid.NewGuid().ToString().ToUpper(),
                            CN_S_EXAMINE_TYPE = Constants.State_Submit,
                            CN_S_OP_FROM = "入库订单",
                            CN_S_FROM_NO = entity.CN_S_OP_NO,
                            CN_S_CREATOR = t.CN_S_LOGIN,
                            CN_S_CREATOR_BY = t.CN_S_NAME,
                            CN_T_CREATE = DateTime.Now,
                            CN_S_OPINION = "",
                            TokenId = entity.TokenId
                        });

                        return SubmitInOrder(examineList);
                    }
                    return result;
                });
            }
            catch (Exception ex)
            {
                return OperateResult.Error(ex.Message);
            }
        }
        #endregion

        #region 修改入库订单
        /// <summary>
        /// 修改入库订单
        /// </summary>
        /// <param name="Entity">入库订单实体</param>
        /// <returns></returns>
        /// <History>[HANHE(XDL)] CREATED BY 2019-02-20</History>
        [HttpPost]
        public OperateResult UpdateInOrder(TN_WM_IN_MSTEntity entity)
        {
            try
            {
                return ValidateToken(entity.TokenId, t =>
                {
                    OperateResult result = new OperateResult();

                    var existsInMst = BLLCreator.Create<DapperBLL<TN_WM_IN_MSTEntity>>().GetSingleEntity(new
                    {
                        CN_S_OP_NO = entity.CN_S_OP_NO
                    });

                    entity.CN_GUID = existsInMst.CN_GUID;
                    entity.CN_T_CREATE = existsInMst.CN_T_CREATE;
                    entity.CN_S_CREATOR = existsInMst.CN_S_CREATOR;
                    entity.CN_S_CREATOR_BY = existsInMst.CN_S_CREATOR_BY;

                    //根据tokenId 获取当前登陆信息
                    entity.CN_S_ORGAN = t.CN_S_ORGCODE;
                    entity.CN_S_MODIFY = t.CN_S_LOGIN;
                    entity.CN_S_MODIFY_BY = t.CN_S_NAME;
                    //修改
                    entity.CN_T_MODIFY = DateTime.Now;
                    //货主不能为空，暂时赋值
                    entity.CN_S_OWNER = Constants.DefaultOwner;
                    int rowNo = 1;
                    foreach (var inDtl in entity.DTLEntity)
                    {
                        inDtl.CN_GUID = Guid.NewGuid().ToString();
                        inDtl.CN_N_ROW_NO = rowNo++;
                        inDtl.CN_S_MSTGUID = entity.CN_GUID;
                        inDtl.CN_S_OP_NO = entity.CN_S_OP_NO;
                        inDtl.CN_S_STATE = entity.CN_S_STATE;
                        inDtl.CN_S_ITEM_STATE = string.IsNullOrEmpty(inDtl.CN_S_ITEM_STATE.ToString()) ? "合格" : inDtl.CN_S_ITEM_STATE.ToString();
                        inDtl.CN_T_CREATE = DateTime.Now;
                        inDtl.CN_S_CREATOR = entity.CN_S_CREATOR;
                        inDtl.CN_S_CREATOR_BY = entity.CN_S_CREATOR_BY;
                        inDtl.CN_T_MODIFY = DateTime.Now;
                        inDtl.CN_S_MODIFY = entity.CN_S_MODIFY;
                        inDtl.CN_S_MODIFY_BY = entity.CN_S_MODIFY_BY;
                    }
                    result = BLLCreator.Create<TN_WM_INBLL>().UpdateInOrder(entity);

                    if (result.Success && (entity.OperateMessage == Constants.Operate_EditAndSubmit))
                    {
                        List<TN_WM_B_EXAMINEEntity> examineList = new List<TN_WM_B_EXAMINEEntity>();
                        examineList.Add(new TN_WM_B_EXAMINEEntity()
                        {
                            CN_GUID = System.Guid.NewGuid().ToString().ToUpper(),
                            CN_S_EXAMINE_TYPE = Constants.State_Submit,
                            CN_S_OP_FROM = "入库订单",
                            CN_S_FROM_NO = entity.CN_S_OP_NO,
                            CN_S_CREATOR = t.CN_S_LOGIN,
                            CN_S_CREATOR_BY = t.CN_S_NAME,
                            CN_T_CREATE = DateTime.Now,
                            CN_S_OPINION = "",
                            TokenId = entity.TokenId
                        });

                        return SubmitInOrder(examineList);
                    }
                    return result;
                });
            }
            catch (Exception ex)
            {
                return OperateResult.Error(ex.Message);
            }
        }
        #endregion

        #region 删除入库订单
        /// <summary>
        /// 删除入库订单
        /// </summary>
        /// <param name="opNo">入库订单号</param>
        /// <returns></returns>
        /// <History>[HANHE(XDL)] CREATED BY 2019-02-20</History>
        [HttpGet]
        public OperateResult DeleteInOrder(string opNo)
        {
            try
            {
                return ValidateToken(t =>
                {
                    return BLLCreator.Create<TN_WM_INBLL>().DeleteInOrder(opNo);
                });
            }
            catch (Exception ex)
            {
                return OperateResult.Error(ex.Message);
            }
        }
        #endregion

        #region 提交入库订单
        /// <summary>
        /// 提交入库订单
        /// </summary>
        /// <param name="entity">审批实体</param>
        /// <returns></returns>
        /// <History>[HANHE(XDL)] CREATED BY 2019-02-20</History>
        [HttpPost]
        public OperateResult SubmitInOrder(List<TN_WM_B_EXAMINEEntity> entity)
        {
            try
            {
                return ValidateToken(entity[0].TokenId, t =>
                {
                    return BLLCreator.Create<TN_WM_INBLL>().SubmitInOrder(entity);
                });
            }
            catch (Exception ex)
            {
                return OperateResult.Error(ex.Message);
            }
        }
        #endregion

        #region 审核入库订单
        /// <summary>
        /// 审核入库订单
        /// </summary>
        /// <param name="entity">审批实体</param>
        /// <returns></returns>
        /// <History>[HANHE(XDL)] CREATED BY 2019-02-20</History>
        [HttpPost]
        public OperateResult AuditInOrder(List<TN_WM_B_EXAMINEEntity> entity)
        {
            try
            {
                return ValidateToken(entity[0].TokenId, t =>
                {
                    return ChangeInOperate(entity[0].CN_S_FROM_NO, outMst =>
                    {
                        if (outMst.CN_S_STATE != Constants.State_Submit && outMst.CN_S_STATE != Constants.State_ReAudit)
                        {
                            return OperateResult.Error("该单据状态已被修改，请刷新页面");
                        }
                        return BLLCreator.Create<TN_WM_INBLL>().AuditInOrder(entity);
                    });
                });
            }
            catch (Exception ex)
            {
                return OperateResult.Error(ex.Message);
            }
        }
        #endregion

        #region 反审入库订单
        /// <summary>
        /// 反审入库订单
        /// </summary>
        /// <param name="entity">审批实体</param>
        /// <returns></returns>
        /// <History>[HANHE(XDL)] CREATED BY 2019-02-20</History>
        [HttpPost]
        public OperateResult ReAuditInOrder(List<TN_WM_B_EXAMINEEntity> entity)
        {
            try
            {
                return ValidateToken(entity[0].TokenId, t =>
                {
                    return ChangeInOperate(entity[0].CN_S_FROM_NO, outMst =>
                    {
                        //反审时状态必须为 已审核
                        if (outMst.CN_S_STATE != Constants.State_Audit)
                        {
                            return OperateResult.Error("该单据状态已被修改，请刷新页面");
                        }
                        return BLLCreator.Create<TN_WM_INBLL>().ReAuditInOrder(entity);
                    });
                });
            }
            catch (Exception ex)
            {
                return OperateResult.Error(ex.Message);
            }
        }
        #endregion

        #region 驳回入库订单
        /// <summary>
        /// 驳回入库订单
        /// </summary>
        /// <param name="entity">审批实体</param>
        /// <returns></returns>
        /// <History>[HANHE(XDL)] CREATED BY 2019-02-20</History>
        [HttpPost]
        public OperateResult RejectInOrder(List<TN_WM_B_EXAMINEEntity> entity)
        {
            try
            {
                return ValidateToken(entity[0].TokenId, t =>
                {
                    return ChangeInOperate(entity[0].CN_S_FROM_NO, outMst =>
                    {
                        string rejectMsg = Util.ToString(entity[0].CN_S_OPINION);
                        if (string.IsNullOrEmpty(rejectMsg))
                            return OperateResult.Error("驳回意见不可为空");
                        //驳回时状态必须为 已提交
                        if (outMst.CN_S_STATE != Constants.State_Submit && outMst.CN_S_STATE != Constants.State_ReAudit)
                        {
                            return OperateResult.Error("该单据状态已被修改，请刷新页面");
                        } //驳回实体
                        TN_WM_B_REJECTEntity rejectEntity = new TN_WM_B_REJECTEntity()
                        {
                            CN_GUID = Guid.NewGuid().ToString(),
                            CN_S_OP_FROM = Constants.Rule_OutOrder,
                            CN_S_FROM_NO = entity[0].CN_S_FROM_NO,
                            CN_S_OPINION = rejectMsg,
                            CN_S_CREATOR = Util.ToString(entity[0].CN_S_CREATOR),
                            CN_S_CREATOR_BY = Util.ToString(entity[0].CN_S_CREATOR_BY),
                            CN_T_CREATE = DateTime.Now,
                            CN_S_MODIFY = Util.ToString(entity[0].CN_S_CREATOR),
                            CN_S_MODIFY_BY = Util.ToString(entity[0].CN_S_CREATOR_BY),
                            CN_T_MODIFY = DateTime.Now
                        };
                        return BLLCreator.Create<TN_WM_INBLL>().RejectInOrder(entity, rejectEntity);
                    });
                });
            }
            catch (Exception ex)
            {
                return OperateResult.Error(ex.Message);
            }
        }
        #endregion

        #region 带出入库订单实体
        /// <summary>
        /// 带出入库订单实体
        /// </summary>
        /// <param name="opNo"></param>
        /// <param name="funcOut"></param>
        /// <returns></returns>
        public OperateResult ChangeInOperate(string opNo, Func<TN_WM_IN_MSTEntity, OperateResult> funcIn)
        {
            try
            {
                if (string.IsNullOrEmpty(opNo))
                    return OperateResult.Error("入库订单号不可为空");
                var inMst = BLLCreator.Create<DapperBLL<TN_WM_IN_MSTEntity>>().GetSingleEntity(new
                {
                    CN_S_OP_NO = opNo
                });
                if (inMst == null)
                    return OperateResult.Error("未找到入库订单号：" + opNo);
                return funcIn(inMst);
            }
            catch (Exception ex)
            {
                return OperateResult.Error(ex.Message);
            }
        }
        #endregion

        #region 查询数据集
        /// <summary>
        /// 获取入库订单列表
        /// </summary>
        /// <param name="searchModel">查询实体（页码，显示条数，条件等）</param>
        /// <returns></returns>
        /// <History>[HANHE(XDL)] CREATED BY 2018-11-24</History>
        [HttpPost]
        public string GetInOrderList(SearchModel searchModel)
        {
            return ValidateToken(searchModel.TokenId, t =>
              {
                  IsoDateTimeConverter timeFormat = new IsoDateTimeConverter();
                  timeFormat.DateTimeFormat = "yyyy-MM-dd HH:mm:ss";

                  OperateResult pagingList = BLLCreator.Create<TN_WM_INBLL>().GetInOrderList(searchModel);
                  return JsonConvert.SerializeObject(pagingList, timeFormat);
              });
        }
        #endregion

        #region 到货单联机新增-选择来源
        /// <summary>
        /// 到货单页面，选择来源单据
        /// </summary>
        /// <param name="searchModel">实体</param>
        /// <returns></returns>
        /// <History>[HANHE(XDL)] CREATED BY 2018-11-26</History>
        [HttpPost]
        public string GetFromInOrderList(SearchModel searchModel)
        {
            return ValidateToken(searchModel.TokenId, t =>
               {
                   OperateResult pagingList = BLLCreator.Create<TN_WM_INBLL>().GetFromInOrderList(searchModel);
                   return JsonConvert.SerializeObject(pagingList);
               });
        }

        [HttpGet]
        public string GetFromInOrderDtl(string opNo)
        {
            return ValidateToken(t =>
                {
                    List<TN_WM_IN_DTLEntity> arrivalDtl = BLLCreator.Create<TN_WM_INBLL>().GetFromInOrderDtl(opNo);
                    return JsonConvert.SerializeObject(arrivalDtl);
                });
        }


        /// <summary>
        /// 根据单号获取主子表信息
        /// </summary>
        /// <param name="CN_S_OP_NO">模糊查询条件：入库单号</param>
        /// <returns></returns>
        [HttpGet]
        public string GetInOrderMstAndDtl(string opNo)
        {
            try
            {
                return ValidateToken(t =>
                {
                    TN_WM_IN_MSTEntity inMstEntity = BLLCreator.Create<TN_WM_INBLL>().GetInOrderMstAndDtl(opNo);
                    return JsonConvert.SerializeObject(OperateResult.Succeed("", inMstEntity));
                });
            }
            catch (Exception ex)
            {
                return JsonConvert.SerializeObject(OperateResult.Error(ex.Message.ToString()));
            }
        }
        #endregion

        
    }
}