package com.nanometer.smartlab.service;

import com.nanometer.smartlab.dao.BaseMetaDao;
import com.nanometer.smartlab.dao.EmailStatusDao;
import com.nanometer.smartlab.dao.OpeOrderDao;
import com.nanometer.smartlab.entity.*;
import com.nanometer.smartlab.entity.enumtype.ApplyStatus;
import com.nanometer.smartlab.entity.enumtype.ArrivalStatus;
import com.nanometer.smartlab.entity.enumtype.EmailSendStatus;
import com.nanometer.smartlab.entity.enumtype.OperateStatus;
import com.nanometer.smartlab.entity.enumtype.StoreType;
import com.nanometer.smartlab.exception.AlarmCode;
import com.nanometer.smartlab.exception.AlarmException;
import com.nanometer.smartlab.exception.BusinessException;
import com.nanometer.smartlab.exception.ExceptionEnumCode;
import com.nanometer.smartlab.util.IDUtils;
import com.nanometer.smartlab.util.MessageUtil;
import org.apache.commons.lang.StringUtils;
import org.apache.log4j.Logger;
import org.springframework.context.annotation.Lazy;
import org.springframework.dao.DataAccessException;
import org.springframework.dao.DataIntegrityViolationException;
import org.springframework.dao.DuplicateKeyException;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;

import javax.annotation.Resource;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.sql.Timestamp;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * Created by johnny on 17/12/14.
 */
@Service("opeOrderService")
public class OpeOrderServiceImpl implements OpeOrderService {

    private static Logger logger = Logger.getLogger(OpeOrderService.class);

    @Resource(name = "opeOrderDao")
    OpeOrderDao opeOrderDao;
    @Resource
    private OpeApplyOrderService opeApplyOrderService;
    @Resource
    private SysSequenceService sysSequenceService;
    @Resource
    private OpeApplyService opeApplyService;
    @Lazy
    @Resource
    private OpeReagentStatusService opeReagentStatusService;
    @Lazy
    @Resource
    private OpeWarehouseReserveService opeWarehouseReserveService;
    @Lazy
    @Resource
    private OpeUseFlowService opeUseFlowService;
    @Resource
    EmailStatusDao emailStatusDao;

    @Resource(name="baseMetaDao")
    BaseMetaDao baseMetaDao;

    @Transactional(propagation = Propagation.REQUIRED)
    public List<OpeOrder> getOpeOrderList(String orderCode, String orderName, Timestamp startTime, Timestamp endTime, Integer status, String orderUserName,
                                          Integer first, Integer pageSize) {
        try {
            Map<String, Object> params = new HashMap<String, Object>();
            if (StringUtils.isNotBlank(orderCode)) {
                params.put("orderCode", "%" + orderCode + "%");
            }
            if (StringUtils.isNotBlank(orderName)) {
                params.put("orderName", "%" + orderName + "%");
            }
            params.put("startTime", startTime);
            params.put("endTime", endTime);
            params.put("status", status);
            if (StringUtils.isNotBlank(orderUserName)) {
                params.put("orderUserName", "%" + orderUserName + "%");
            }
            params.put("first", first);
            params.put("pageSize", pageSize);
            return this.opeOrderDao.getOpeOrderList(params);
        } catch (DataAccessException e) {
            logger.error(e.getMessage(), e);
            throw new BusinessException(ExceptionEnumCode.DB_ERR, MessageUtil.getMessageByCode(ExceptionEnumCode.DB_ERR.getCode()), e);
        }
    }

    @Transactional(propagation = Propagation.REQUIRED)
    public int getOpeOrderTotalCount(String orderCode, String orderName, Timestamp startTime, Timestamp endTime, Integer status, String orderUserName) {
        try {
            Map<String, Object> params = new HashMap<String, Object>();
            if (StringUtils.isNotBlank(orderCode)) {
                params.put("orderCode", "%" + orderCode + "%");
            }
            if (StringUtils.isNotBlank(orderName)) {
                params.put("orderName", "%" + orderName + "%");
            }
            params.put("startTime", startTime);
            params.put("endTime", endTime);
            params.put("status", status);
            if (StringUtils.isNotBlank(orderUserName)) {
                params.put("orderUserName", "%" + orderUserName + "%");
            }
            return this.opeOrderDao.getOpeOrderTotalCount(params);
        } catch (DataAccessException e) {
            logger.error(e.getMessage(), e);
            throw new BusinessException(ExceptionEnumCode.DB_ERR, MessageUtil.getMessageByCode(ExceptionEnumCode.DB_ERR.getCode()), e);
        }
    }

    @Transactional(propagation = Propagation.REQUIRED)
    public OpeOrder getOpeOrder(String id) {
        try {
            return this.opeOrderDao.getOpeOrder(id);
        } catch (DataAccessException e) {
            logger.error(e.getMessage(), e);
            throw new BusinessException(ExceptionEnumCode.DB_ERR, MessageUtil.getMessageByCode(ExceptionEnumCode.DB_ERR.getCode()), e);
        }
    }

    @Transactional(propagation = Propagation.REQUIRED)
    public OpeOrder insertOpeOrder(OpeOrder opeOrder) {
        try {
            opeOrder.setId(IDUtils.uuid());
            this.opeOrderDao.insertOpeOrder(opeOrder);
            return opeOrder;
        } catch (DuplicateKeyException ex) {
            logger.warn(ex.getMessage(), ex);
            throw new AlarmException(AlarmCode.DATA_DUPLICATE, MessageUtil.getMessage(AlarmCode.DATA_DUPLICATE.getCode()));
        } catch (DataIntegrityViolationException ex) {
            logger.warn(ex.getMessage(), ex);
            throw new AlarmException(AlarmCode.DATA_CONFICT, MessageUtil.getMessage(AlarmCode.DATA_CONFICT.getCode()));
        } catch (DataAccessException ex) {
            logger.error(ex.getMessage(), ex);
            throw new BusinessException(ExceptionEnumCode.DB_ERR, MessageUtil.getMessageByCode(ExceptionEnumCode.DB_ERR.getCode()), ex);
        }
    }

    @Transactional(propagation = Propagation.REQUIRED)
    public boolean updateOpeOrder(OpeOrder opeOrder) {
        try {
            int row = this.opeOrderDao.updateOpeOrder(opeOrder);

            return row != 0;
        } catch (DuplicateKeyException ex) {
            logger.warn(ex.getMessage(), ex);
            throw new AlarmException(AlarmCode.DATA_DUPLICATE, MessageUtil.getMessage(AlarmCode.DATA_DUPLICATE.getCode()));
        } catch (DataIntegrityViolationException ex) {
            logger.warn(ex.getMessage(), ex);
            throw new AlarmException(AlarmCode.DATA_CONFICT, MessageUtil.getMessage(AlarmCode.DATA_CONFICT.getCode()));
        } catch (DataAccessException ex) {
            logger.error(ex.getMessage(), ex);
            throw new BusinessException(ExceptionEnumCode.DB_ERR, MessageUtil.getMessageByCode(ExceptionEnumCode.DB_ERR.getCode()), ex);
        }
    }

    @Transactional(propagation = Propagation.REQUIRED)
    public boolean deleteOpeOrder(List<OpeOrder> opeOrderList) {
        try {
            if (opeOrderList == null || opeOrderList.size() == 0) {
                return false;
            }

            List<String> ids = new ArrayList<String>();
            for (OpeOrder opeOrder : opeOrderList) {
                ids.add(opeOrder.getId());

                // 取消订单对应的申购
                this.cancelOrderApply(opeOrder.getId());
            }

            int row = this.opeOrderDao.deleteOpeOrder(ids);
            return row != 0;
        } catch (DataIntegrityViolationException ex) {
            logger.warn(ex.getMessage(), ex);
            throw new AlarmException(AlarmCode.DATA_CONFICT, MessageUtil.getMessage(AlarmCode.DATA_CONFICT.getCode()));
        } catch (DataAccessException ex) {
            logger.error(ex.getMessage(), ex);
            throw new BusinessException(ExceptionEnumCode.DB_ERR, MessageUtil.getMessageByCode(ExceptionEnumCode.DB_ERR.getCode()), ex);
        }
    }

    @Transactional(propagation = Propagation.REQUIRED)
    public void createOpeOrder(OpeOrder opeOrder, List<OpeApply> opeApplyList, SysUser orderUser) {
        if (opeOrder == null
                || opeApplyList == null
                || orderUser == null) {
            return;
        }

        opeOrder.setOrderCode(this.sysSequenceService.getOrderCode());
        opeOrder.setStatus(ApplyStatus.PENDING_PURCHASE);
        opeOrder.setConsigneeUserId(null);
        opeOrder.setOrderUserId(orderUser.getId());
        opeOrder.setArrivalTime(null);
        opeOrder.setSupplyId(opeApplyList.get(0).getReagent().getSupplierId());
        opeOrder.setSupplyName(opeApplyList.get(0).getReagent().getSupplierName());
        this.insertOpeOrder(opeOrder);

        OpeApplyOrder opeApplyOrder = null;
        for (OpeApply opeApply : opeApplyList) {
            opeApply.setStatus(ApplyStatus.PENDING_PURCHASE);
            this.opeApplyService.updateOpeApply(opeApply);

            opeApplyOrder = new OpeApplyOrder();
            opeApplyOrder.setOpeOrderId(opeOrder.getId());
            opeApplyOrder.setOpeApplyId(opeApply.getId());
            this.opeApplyOrderService.insertOpeApplyOrder(opeApplyOrder);
        }
    }

    @Transactional(propagation = Propagation.REQUIRED)
    public void rukuOpeOrder(OpeOrder opeOrder, List<OpeApply> opeApplyList) {
        if (opeOrder == null
                || opeApplyList == null) {
            return;
        }

        Integer applyNum = null;
        Integer arrivalNum = null;
        ApplyStatus flag = ApplyStatus.STORAGE;
        // 更新订单所对应的申购状态为已入库
        for (OpeApply opeApply : opeApplyList) {
        		applyNum = opeApply.getNum();
        		arrivalNum = opeApply.getArrivalNum();
        		if(applyNum > arrivalNum)
        		{
        			flag = ApplyStatus.UNCOMPLETED;
        			opeApply.setStatus(ApplyStatus.UNCOMPLETED);
        		}else
        		{
        			opeApply.setStatus(ApplyStatus.STORAGE);
        		}
            this.opeApplyService.updateOpeApply(opeApply);
        }

     // 更新订单状态为已入库
        opeOrder.setStatus(flag);
        this.updateOpeOrder(opeOrder);

        // 将入库的物品更新库存
        OpeReagentStatus opeReagentStatus = null;
        BigInteger startReagentCode = null;
        BigInteger endReagentCode = null;
        String reagentCode = null;
        OpeWarehouseReserve opeWarehouseReserve = null;
        OpeUseFlow opeUseFlow = null;
        for (OpeApply opeApply : opeApplyList) {
            if(StringUtils.isNotBlank(opeApply.getStartReagentCode()) && StringUtils.isNotBlank(opeApply.getEndReagentCode())){
                startReagentCode = new BigInteger(opeApply.getStartReagentCode());
                endReagentCode = new BigInteger(opeApply.getEndReagentCode());

                for (BigInteger i = startReagentCode; i.compareTo(endReagentCode) < 1; i = i.add(BigInteger.ONE)) {
                    reagentCode = String.valueOf(i);
                    if (this.opeReagentStatusService.isOpeReagentStatusExist(reagentCode)) {
                        throw new BusinessException(ExceptionEnumCode.REAGENT_CODE_EXIST, "申购编号：" + opeApply.getApplyCode() + "的试剂条形码[" + reagentCode + "]已存在。");
                    }

                    opeReagentStatus = new OpeReagentStatus();
                    opeReagentStatus.setReagentId(opeApply.getReagent().getId());
                    opeReagentStatus.setArticleNumber(opeApply.getArticleNumber());
                    opeReagentStatus.setReagentCode(reagentCode);
                    opeReagentStatus.setStatus(ArrivalStatus.WAREHOUSE);
                    opeReagentStatus.setHouseId(opeApply.getHouseId());
                    opeReagentStatus.setContainerId(opeApply.getContainerId());
                    opeReagentStatus.setUserId(opeOrder.getConsigneeUserId());
                    opeReagentStatus.setPlace(opeApply.getPlaceId());
                    opeReagentStatus.setRemainder(opeApply.getReagent().getMainMetering() != null ? (opeApply.getReagent().getMainMetering()) : new BigDecimal(0));
                    opeReagentStatus.setStoreType(StoreType.APPLY);
                    this.opeReagentStatusService.insertOpeReagentStatus(opeReagentStatus);

                    opeUseFlow = new OpeUseFlow();
                    opeUseFlow.setReagentCode(opeReagentStatus.getReagentCode());
                    opeUseFlow.setStatus(opeReagentStatus.getStatus());
                    opeUseFlow.setHouseId(opeReagentStatus.getHouseId());
                    opeUseFlow.setContainerId(opeReagentStatus.getContainerId());
                    opeUseFlow.setUserId(opeReagentStatus.getUserId());
                    opeUseFlow.setPlace(opeReagentStatus.getPlace());
                    opeUseFlow.setRemainder(opeApply.getReagent().getMainMetering()!=null?(opeApply.getReagent().getMainMetering()):new BigDecimal(0));
                    opeUseFlow.setStoreType(StoreType.APPLY);

                    Map<String, String> metaMap = new HashMap<>();
                    metaMap.put("groupId", "operate_status");
                    metaMap.put("metaKey", String.valueOf(OperateStatus.WAREHOUSEIN.getKey()));
                    List<BaseMeta> baseMetaList = baseMetaDao.getBaseMetaList(metaMap);
                    opeUseFlow.setOperateState(baseMetaList.get(0).getId());

                    this.opeUseFlowService.insertOpeUseFlow(opeUseFlow);
                }
            }

            opeWarehouseReserve = this.opeWarehouseReserveService.getOpeWarehouseReserve(opeApply.getReagent().getId(), opeApply.getArticleNumber());
            if (opeWarehouseReserve == null) {
                opeWarehouseReserve = new OpeWarehouseReserve();
                opeWarehouseReserve.setReagentId(opeApply.getReagent().getId());
                opeWarehouseReserve.setArticleNumber(opeApply.getArticleNumber());
                opeWarehouseReserve.setReserve(0);
            }
            opeWarehouseReserve.setReserve(opeWarehouseReserve.getReserve() + opeApply.getArrivalNum());
            if (StringUtils.isBlank(opeWarehouseReserve.getId())) {
                this.opeWarehouseReserveService.insertOpeWarehouseReserve(opeWarehouseReserve);
            } else {
                this.opeWarehouseReserveService.updateOpeWarehouseReserve(opeWarehouseReserve);
            }
        }

    }

    public List<OpeApply> getOpeApplyListByOrder(String orderId) {
        List<OpeApply> result = null;
        List<OpeApplyOrder> opeApplyOrderList = this.opeApplyOrderService.getOpeApplyOrderList(orderId, null);
        if (opeApplyOrderList != null && opeApplyOrderList.size() > 0) {
            result = new ArrayList<OpeApply>();
            for (OpeApplyOrder opeApplyOrder : opeApplyOrderList) {
                result.add(this.opeApplyService.getOpeApply(opeApplyOrder.getOpeApplyId()));
            }
        }
        return result;
    }

    public boolean isOrderPendingPurchase(OpeOrder opeOrder) {
        return opeOrder != null
                && opeOrder.getStatus() != null
                && opeOrder.getStatus().getKey() == ApplyStatus.PENDING_PURCHASE.getKey();

    }

    @Transactional(propagation = Propagation.REQUIRED)
    public void cancelOrderApply(String orderId) {
        List<OpeApply> opeApplyList = this.getOpeApplyListByOrder(orderId);
        if (opeApplyList != null && opeApplyList.size() > 0) {
            for (OpeApply opeApply : opeApplyList) {
                opeApply.setStatus(ApplyStatus.CANCEL);
                this.opeApplyService.updateOpeApply(opeApply);
            }
        }
    }

    @Transactional(propagation = Propagation.REQUIRED)
    public void emailStatusSave(OpeOrder opeOrder, List<OpeApply> opeApplyList) {

        EmailStatus emailStatus = null;

        for (OpeApply opeApply : opeApplyList) {

            emailStatus = new EmailStatus();
            emailStatus.setId(IDUtils.uuid());
            emailStatus.setOrderCode(opeOrder.getOrderCode());
            emailStatus.setApplyCode(opeApply.getApplyCode());
            emailStatus.setReagentId(opeApply.getReagent().getId());
            emailStatus.setNum(opeApply.getArrivalNum());
            emailStatus.setApplyUserId(opeApply.getApplyUserId());
            emailStatus.setStatus(EmailSendStatus.UN_SEND);

                // 待发送邮件保存
            this.emailStatusDao.insertEmailStatus(emailStatus);
        }
    }

    @Transactional(propagation = Propagation.REQUIRED)
    public List<EmailStatus> getUnsendEmailList() {
        try {
            Map<String, Object> params = new HashMap<String, Object>();
            params.put("status", EmailSendStatus.UN_SEND);
            return  this.emailStatusDao.getEmailStatusList(params);
        } catch (DataAccessException e) {
            logger.error(e.getMessage(), e);
            throw new BusinessException(ExceptionEnumCode.DB_ERR, MessageUtil.getMessageByCode(ExceptionEnumCode.DB_ERR.getCode()), e);
        }
    }

    @Transactional(propagation = Propagation.REQUIRED)
    public int getUnsendEmailCount() {
        try {
            Map<String, Object> params = new HashMap<String, Object>();
            params.put("status", EmailSendStatus.UN_SEND);
            return this.emailStatusDao.getEmailStatusTotalCount(params);
        } catch (DataAccessException e) {
            logger.error(e.getMessage(), e);
            throw new BusinessException(ExceptionEnumCode.DB_ERR, MessageUtil.getMessageByCode(ExceptionEnumCode.DB_ERR.getCode()), e);
        }
    }

    @Transactional(propagation = Propagation.REQUIRED)
    public boolean updateEmailStatus(EmailStatus emailStatus) {
        try {
            int row = this.emailStatusDao.updateEmailStatus(emailStatus);
            return row != 0;
        } catch (DuplicateKeyException ex) {
            logger.warn(ex.getMessage(), ex);
            throw new AlarmException(AlarmCode.DATA_DUPLICATE, MessageUtil.getMessage(AlarmCode.DATA_DUPLICATE.getCode()));
        } catch (DataIntegrityViolationException ex) {
            logger.warn(ex.getMessage(), ex);
            throw new AlarmException(AlarmCode.DATA_CONFICT, MessageUtil.getMessage(AlarmCode.DATA_CONFICT.getCode()));
        } catch (DataAccessException ex) {
            logger.error(ex.getMessage(), ex);
            throw new BusinessException(ExceptionEnumCode.DB_ERR, MessageUtil.getMessageByCode(ExceptionEnumCode.DB_ERR.getCode()), ex);
        }
    }

    /**
     * 由于修改条形码重新入库
     * @param opeOrder
     * @param opeOrderApplyList
     */
    @Transactional
    @Override
    public void reRukuInfo(OpeOrder opeOrder, List<OpeApply> opeOrderApplyList) {
        if (opeOrder == null
                || opeOrderApplyList == null) {
            return;
        }


        // 将之前入库的信息删除
        BigInteger startReagentCode = null;
        BigInteger endReagentCode = null;
        String reagentCode = null;
        OpeWarehouseReserve opeWarehouseReserve = null;
        //记录需要重新入库的信息LIST
        List<OpeApply> reRukuopeOrderApplyList = new ArrayList<>();
        for (OpeApply opeApply : opeOrderApplyList) {
            OpeApply opeApply1 = this.opeApplyService.selectOpeApplyByPrimaryKey(opeApply.getId());
            if(opeApply.getArrivalNum().equals(opeApply1.getArrivalNum())
                    && opeApply.getStartReagentCode().equals(opeApply1.getStartReagentCode())
                    && opeApply.getEndReagentCode().equals(opeApply1.getEndReagentCode())
                    && opeApply.getArticleNumber().equals(opeApply1.getArticleNumber())){ //如果到货数量、批号、条形码开始、条形码结束都跟之前填入的一致，就不需要重新入库
                continue;
            }
            reRukuopeOrderApplyList.add(opeApply);

            //删除入库信息
            if(StringUtils.isNotBlank(opeApply1.getStartReagentCode()) && StringUtils.isNotBlank(opeApply1.getEndReagentCode())){
                startReagentCode = new BigInteger(opeApply1.getStartReagentCode());
                endReagentCode = new BigInteger(opeApply1.getEndReagentCode());
                for (BigInteger i = startReagentCode; i.compareTo(endReagentCode) < 1; i = i.add(BigInteger.ONE)) {
                    reagentCode = String.valueOf(i);

                    this.opeReagentStatusService.deleteByReagentCode(reagentCode);

                    this.opeUseFlowService.deleteByReagentCode(reagentCode);
                }
            }

            opeWarehouseReserve = this.opeWarehouseReserveService.getOpeWarehouseReserve(opeApply.getReagent().getId(), opeApply.getArticleNumber());
            if (opeWarehouseReserve == null) {
                opeWarehouseReserve = new OpeWarehouseReserve();
                opeWarehouseReserve.setReagentId(opeApply.getReagent().getId());
                opeWarehouseReserve.setArticleNumber(opeApply.getArticleNumber());
                opeWarehouseReserve.setReserve(0);
            }
            opeWarehouseReserve.setReserve(opeWarehouseReserve.getReserve() - opeApply1.getArrivalNum());
            if (StringUtils.isBlank(opeWarehouseReserve.getId())) {
                this.opeWarehouseReserveService.insertOpeWarehouseReserve(opeWarehouseReserve);
            } else {
                this.opeWarehouseReserveService.updateOpeWarehouseReserve(opeWarehouseReserve);
            }
        }

        //进行重新入库操作
        if(!reRukuopeOrderApplyList.isEmpty()){
            rukuOpeOrder(opeOrder,reRukuopeOrderApplyList);
        }
    }

    @Override
    public List<EmailStatus> selectByReId(String id) {
        return this.emailStatusDao.selectByReId(id);
    }

    @Override
    public void updateByReId(String newReId, String oldReId) {
        Map<String, Object> params=new HashMap();
        params.put("newReId",newReId);
        params.put("oldReId",oldReId);
        this.emailStatusDao.updateByReId(params);
    }

    @Override
    public OpeOrder getOrder(String id) {
        return opeOrderDao.selectParentOrder(id);
    }

    @Override
    @Transactional
    public void updateOpeOrderStatus(OpeOrder oo) {
        opeOrderDao.updateOpeOrderStatus(oo);
    }

}