package com.uas.ps.inquiry.service.impl;

import com.alibaba.fastjson.JSONObject;
import com.uas.ps.core.logging.BufferedLoggerManager;
import com.uas.ps.core.util.CollectionUtils;
import com.uas.ps.core.util.ContextUtils;
import com.uas.ps.entity.Product;
import com.uas.ps.entity.Status;
import com.uas.ps.inquiry.AccessConfiguration;
import com.uas.ps.inquiry.dao.EnterpriseDao;
import com.uas.ps.inquiry.dao.InquiryEnRemindDao;
import com.uas.ps.inquiry.dao.InquiryRemindDao;
import com.uas.ps.inquiry.dao.ProductDao;
import com.uas.ps.inquiry.dao.PublicInquiryDao;
import com.uas.ps.inquiry.dao.PublicInquiryItemDao;
import com.uas.ps.inquiry.dao.PurcInquiryDao;
import com.uas.ps.inquiry.dao.PurcInquiryItemDao;
import com.uas.ps.inquiry.dao.PurcInquiryItemInfoDao;
import com.uas.ps.inquiry.entity.Constant;
import com.uas.ps.inquiry.entity.InquiryDetailInfo;
import com.uas.ps.inquiry.entity.InquiryProductInfo;
import com.uas.ps.inquiry.entity.InquirySource;
import com.uas.ps.inquiry.entity.MessageModel;
import com.uas.ps.inquiry.entity.OrderStatus;
import com.uas.ps.inquiry.model.Enterprise;
import com.uas.ps.inquiry.model.InquiryRemind;
import com.uas.ps.inquiry.model.PublicInquiry;
import com.uas.ps.inquiry.model.PublicInquiryItem;
import com.uas.ps.inquiry.model.PurcInquiry;
import com.uas.ps.inquiry.model.PurcInquiryItem;
import com.uas.ps.inquiry.model.PurcInquiryItemInfo;
import com.uas.ps.inquiry.page.PageInfo;
import com.uas.ps.inquiry.page.SearchFilter;
import com.uas.ps.inquiry.page.criteria.CriterionExpression;
import com.uas.ps.inquiry.page.criteria.LogicalExpression;
import com.uas.ps.inquiry.page.criteria.PredicateUtils;
import com.uas.ps.inquiry.page.criteria.SimpleExpression;
import com.uas.ps.inquiry.page.exception.IllegalOperatorException;
import com.uas.ps.inquiry.service.InquiryService;
import com.uas.ps.inquiry.service.PublicInquiryService;
import com.uas.ps.inquiry.support.InquiryBufferedLogger;
import com.uas.ps.inquiry.util.FlexJsonUtils;
import com.uas.ps.inquiry.util.HttpUtil;
import com.uas.ps.inquiry.util.ThreadUtils;
import javassist.NotFoundException;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.Sort;
import org.springframework.data.jpa.domain.Specification;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Service;
import org.springframework.util.StringUtils;

import javax.persistence.criteria.CriteriaBuilder;
import javax.persistence.criteria.CriteriaQuery;
import javax.persistence.criteria.Predicate;
import javax.persistence.criteria.Root;
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Date;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;

/**
 * 针对转询价报价单的数据查询操作
 *
 * Created by hejq on 2018-01-17.
 */
@Service
public class InquiryServiceImpl implements InquiryService {

    /**
     * 消息类型 （在B2B消息中拼接跳转单据详情url请求时需要）
     */
    private final String INQUIRY_TYPE = "公共询价";

    /**
     * 应用来源
     */
    private final String SOURCERAPP = "MALL";

    /**
     * 消息类型，公共询价的采纳结果
     */
    private final String INQUIRY_DECIDE_TYPE = "公共询价采纳结果";

    /**
     * 询价种类
     */
    private final String INQUIRYKIND = "publicInquiry";


    /**
     * 消息推送短信模板id
     */
    private final String SMS_TEMP_ID = "e6320a3c-89ac-4c77-a75f-62a727bce654";

    /**
     * 消息推送方式：邮件、短信、im
     */
    private final String SMS_TYPE = "MAIL_AND_SM_AND_IM";

    /**
     * 来源应用，ERP
     */
    private final String PRODUCERAPP = "ERP";

    /**
     * 消费类型： 多个，MULTI
     */
    private final String CUST_TYPE = "MULTI";

    /**
     * 接收应用
     */
    private final String CONSUMERAPP = "HIDE";

    /**
     * 消息类型 （在MALL消息中拼接求购询价待报价）
     */
    private final String INQUIRY_TYPE_SELLER_MALL = "MALL跳转卖家待报价页面";

    /**
     * 公共消息访问地址
     */
    private final String PS_MESSAGE_URL = ContextUtils.getBean(AccessConfiguration.class).getPsMessageUrl();

    /**
     * 询价统计通知发送人UU
     */
    private final Long MESSAGE_SENDERUU = ContextUtils.getBean(AccessConfiguration.class).getSenderuu();

    /**
     * 询价统计通知发送企业UU
     */
     private final Long MESSAGE_SENDERENUU = ContextUtils.getBean(AccessConfiguration.class).getSenderEnuu();

    @Autowired
    private PublicInquiryItemDao itemDao;

    @Autowired
    private PurcInquiryItemInfoDao inquiryItemDao;

    @Autowired
    private PurcInquiryDao purcInquiryDao;

    @Autowired
    private PublicInquiryDao inquiryDao;

    @Autowired
    private ProductDao productDao;

    @Autowired
    private PurcInquiryItemDao purcInquiryItemDao;

    @Autowired
    private PublicInquiryService inquiryService;

    @Autowired
    private InquiryRemindDao inquiryRemindDao;

    @Autowired
    private JdbcTemplate jdbcTemplate;

    @Autowired
    private EnterpriseDao enterpriseDao;

    @Autowired
    private PublicInquiryServiceImpl service;

    @Autowired
    private InquiryEnRemindDao inquiryEnRemindDao;


    /**
     * 公共物料访问地址
     */
    private final String PS_PRODUCT_URL = ContextUtils.getBean(AccessConfiguration.class).getPsProductUrl();

    /**
     * 日志
     */
    private final static InquiryBufferedLogger logger = BufferedLoggerManager.getLogger(InquiryBufferedLogger.class);

    /**
     * 查询公共询价列表信息
     *
     * @param info    分页新
     * @param filter  过滤条件
     * @param state   过滤状态
     * @param overdue 是否过期 1、已过期；0、未过期
     * @return
     */
    @Override
    public Page<PurcInquiryItemInfo> findTodoByPageInfo(final PageInfo info, SearchFilter filter, String state, Integer overdue) {
        Sort sort = new Sort(Sort.Direction.DESC, "date");
        if (info.getOffset() == 0) {
            info.setOffset(info.getPageSize() * (info.getPageNumber() - 1));
        }
        info.setSort(sort);
        if (null != filter.getUserUU()) {
            info.filter("userUU", filter.getUserUU());
            info.expression(PredicateUtils.isNull("inquiry.enUU"));
        } else if (null != filter.getEnUU()) {
            info.filter("inquiry.enUU", filter.getEnUU());
        } else {
            throw new IllegalAccessError("非法访问");
        }
        if (null != filter) {
            if (StringUtils.hasText(filter.getKeyword())) {
                SimpleExpression cmpCode = new SimpleExpression("cmpCode", filter.getKeyword(), CriterionExpression.Operator.LIKE);
                SimpleExpression brand = new SimpleExpression("inbrand", filter.getKeyword(), CriterionExpression.Operator.LIKE);
                SimpleExpression[] simpleExpressions = new SimpleExpression[]{cmpCode, brand};
                LogicalExpression logicalExpression = PredicateUtils.or(simpleExpressions);
                info.expression(logicalExpression);
            }
            if (filter.getFromDate() != null) {
                info.expression(PredicateUtils.gte("date", new Date(filter.getFromDate()), false));
            }
            if (filter.getEndDate() != null) {
                info.expression(PredicateUtils.lte("date", new Date(filter.getEndDate()), false));
            }
        }
        if (null != state) {
            // 待报价
            if (state.equals(OrderStatus.todo.name())) {
                SimpleExpression amount = new SimpleExpression("offerAmount", Constant.NO, CriterionExpression.Operator.EQ);
                SimpleExpression[] simpleExpressions = new SimpleExpression[]{amount};
                LogicalExpression logicalExpression = PredicateUtils.and(simpleExpressions);
                info.expression(logicalExpression);
            }
            // 已报价
            if (state.equals(OrderStatus.done.name())) {
                SimpleExpression amount = new SimpleExpression("offerAmount", Constant.YES, CriterionExpression.Operator.GTE);
                SimpleExpression[] simpleExpressions = new SimpleExpression[]{amount};
                LogicalExpression logicalExpression = PredicateUtils.and(simpleExpressions);
                info.expression(logicalExpression);
            }
            // 已超过截止日期
            if (state.equals(OrderStatus.end.name())) {
                SimpleExpression date = new SimpleExpression("endDate", new Date(System.currentTimeMillis()), CriterionExpression.Operator.LT);
                SimpleExpression[] simpleExpressions = new SimpleExpression[]{date};
                LogicalExpression logicalExpression = PredicateUtils.and(simpleExpressions);
                info.expression(logicalExpression);
            }
        }
        if (null != overdue) {
            // 已超过截止日期
            if (overdue.equals(Constant.YES)) {
                SimpleExpression date = new SimpleExpression("endDate", new Date(System.currentTimeMillis()), CriterionExpression.Operator.LT);
                SimpleExpression[] simpleExpressions = new SimpleExpression[]{date};
                LogicalExpression logicalExpression = PredicateUtils.and(simpleExpressions);
                info.expression(logicalExpression);
            }
        }
        return inquiryItemDao.findAll(new Specification<PurcInquiryItemInfo>() {
            public Predicate toPredicate(Root<PurcInquiryItemInfo> root, CriteriaQuery<?> query, CriteriaBuilder builder) {
                query.where(info.getPredicates(root, query, builder));
                return null;
            }
        }, info);
    }

    /**
     * 保存公共询价
     *
     * @param currentInquiry 询价信息
     */
    @Override
    public PurcInquiry saveInquiry(PurcInquiry currentInquiry) throws NotFoundException {
        //通过流水号和企业号找到公共询价单
        List<PurcInquiry> existInquiryList = purcInquiryDao.findByCodeAndEnUU(currentInquiry.getCode(), currentInquiry.getEnUU());
        if (!CollectionUtils.isEmpty(existInquiryList)) {
            throw new IllegalOperatorException("单号重复");
        } else {
            if (null != currentInquiry.getEnUU()) {
                Enterprise e = enterpriseDao.findOne(currentInquiry.getEnUU());
                if (null != e) {
                    currentInquiry.setEnName(e.getEnName());
                } else {
                    throw new NotFoundException("询价企业不存在");
                }
            }
            //保存询价单
            PurcInquiry inquiry = purcInquiryDao.save(currentInquiry);
            //判断询价明细单是否为空
            if (!CollectionUtils.isEmpty(currentInquiry.getInquiryItems())) {
                List<PurcInquiryItem> items = new ArrayList<PurcInquiryItem>();
                //给询价明细单属性设置初始值
                for (PurcInquiryItem item : currentInquiry.getInquiryItems()) {
                    item.setInquiry(inquiry);
                    item.setOfferAmount(0);
                    item.setStatus((short) Status.NOT_REPLY.value());
                    item.setIsOpen(Constant.YES);
                    if (null == item.getDate()) {
                        //设置提交时间
                        item.setDate(new Date(System.currentTimeMillis()));
                    }
                    // 这里设置物料信息的冗余字段
                    if (null != item.getProduct()) {
                        item.setProdTitle(item.getProduct().getTitle());
                        item.setProdCode(item.getProduct().getCode());
                        item.setSpec(item.getProduct().getSpec());
                        item.setInbrand(item.getProduct().getBrand());
                        item.setCmpCode(item.getProduct().getCmpCode());
                    }
                    if (null == item.getCmpCode() || item.getCmpCode().equals("无")) {
                        item.setCmpCode(item.getSpec());
                    }
                    if (null == item.getEndDate()) {
                        item.setEndDate(inquiry.getEndDate());
                    }
                    items.add(item);
                }
                //保存询价单明细表
                items = purcInquiryItemDao.save(items);

                final List<PurcInquiryItem> purcInquiryItems = items;
                final String sourceapp = inquiry.getSourceapp();
                final Long enuu = inquiry.getEnUU();
                if (null != inquiry.getSourceapp()) {
                    ThreadUtils.task(new Runnable() {
                        @Override
                        public void run() {
                            try {
                                //生成推荐询价表
                                inquiryService.notifyMessage(purcInquiryItems, sourceapp);
                                if (!StringUtils.isEmpty(enuu)) {
                                    saveProduct(purcInquiryItems, sourceapp);
                                }
                            } catch (Exception e) {
                                e.printStackTrace();
                            }
                        }
                    }).run();
                }
            }
            return inquiry;
        }
    }

    /**
     * 可配置的定时任务
     */
    public List<InquiryRemind> testMessage(Date startTime, Date endTime, Long useruu, Long enuu){
        logger.log("公共询价","9点定时统计询价单总数服务开启");
        List<InquiryRemind> list = inquiryRemindDao.findTestInfo(startTime,endTime,useruu,enuu);
        return list;
    }

    /**
     * 每早9点发送询价通知短信
     */
    @Scheduled(cron = "0 0 9 * * ?" )
    private void sendMessage() throws Exception {
            logger.log("公共询价","9点定时统计询价单总数服务开启");
            List<BigInteger> list1 = inquiryRemindDao.findvenduseruu();
            //找到询价推荐表中的所有公司
            List<BigInteger> list2 = inquiryRemindDao.findvenduu();
            for(BigInteger vendUserUU : list1){
                for(BigInteger enuu : list2){
                    //查出昨晚17点到今早九点的询价信息
                    List<InquiryRemind> reminds = inquiryRemindDao.findInquiryRemind(vendUserUU,enuu);
                    if(!CollectionUtils.isEmpty(reminds)){
                            sendMessage(reminds.size(),reminds);
                    }
                }
            }
            logger.log("公共询价","9点定时统计询价单总数服务结束");
    }


    /**
     * 发送消息推送
     *
     */
    public void sendMessage(final Integer count, final List<InquiryRemind> reminds) {
        ThreadUtils.task(new Runnable() {
            @Override
            public void run() {
                try {
                    List<MessageModel> models = new ArrayList<>();
                    MessageModel model = new MessageModel();
                    model.setType(INQUIRY_TYPE);
                    model.setType(INQUIRY_TYPE_SELLER_MALL);
                    model.setProducerApp("MALl");
                    model.setConsumerType(CUST_TYPE);
                    model.setConsumerApp(CONSUMERAPP);
                    model.setRemark(String.valueOf(count));
                    for(InquiryRemind remind : reminds){
                        model.setReceiverEnuu(remind.getVendUU());
                        model.setReceiverUu(remind.getVendUserUU());
                        model.setSenderEnuu(MESSAGE_SENDERENUU);
                        model.setSenderUu(MESSAGE_SENDERUU);
                    }
                    String company = "";
                    Enterprise enterprise = enterpriseDao.findOne(reminds.get(0).getVendUU());
                    if(null != enterprise){
                        company = enterprise.getEnName();
                    }
                    String content = company + "新增了"+ count +"张公共询价单，快登录优软商城查看详情吧！https://www.usoftmall.com/vendor#/seekPurchase";
                    model.setContent(content);
                    model.setSmsType(SMS_TYPE);
                    model.setSmTemplate(SMS_TEMP_ID);
                    models.add(model);
                    String res = HttpUtil.doPost(PS_MESSAGE_URL + "/messages", FlexJsonUtils.toJsonDeep(models));
                    System.out.println(FlexJsonUtils.toJsonDeep(models));
                    System.out.println(res);
                    logger.log("公共询价","此次"+company+"公司新增"+count+"张公共询价");
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }).run();
    }


    /**
     *  每天下午2点发送询价通知短信
     */
    @Scheduled(cron = "0 0 14 * * ?" )
    private void sendMessage2(){
        logger.log("公共询价","14点定时统计询价单总数服务开始");
        List<BigInteger> list1 = inquiryRemindDao.findvenduseruu();
        //找到询价推荐表中的所有公司
        List<BigInteger> list2 = inquiryRemindDao.findvenduu();
        for(BigInteger vendUserUU : list1){
            for(BigInteger enuu : list2){
                //查出昨晚17点到今早九点的询价信息
                List<InquiryRemind> reminds = inquiryRemindDao.findInquiryRemind1(vendUserUU,enuu);
                if(!CollectionUtils.isEmpty(reminds)){
                    sendMessage(reminds.size(),reminds);
                }
            }
        }
        logger.log("公共询价","14点定时统计询价单总数服务结束");
    }

    /**
     * 每天下午5点发送询价通知短信
     */
    @Scheduled(cron = "0 0 17 * * ?" )
    private void sendMessage3(){
        logger.log("公共询价","17点定时统计询价单总数服务结束");
        List<BigInteger> list1 = inquiryRemindDao.findvenduseruu();
        //找到询价推荐表中的所有公司
        List<BigInteger> list2 = inquiryRemindDao.findvenduu();
        for(BigInteger vendUserUU : list1){
            for(BigInteger enuu : list2){
                //查出昨晚17点到今早九点的询价信息
                List<InquiryRemind> reminds = inquiryRemindDao.findInquiryRemind2(vendUserUU,enuu);
                if(!CollectionUtils.isEmpty(reminds)){
                    sendMessage(reminds.size(),reminds);
                }
            }
        }
        logger.log("公共询价","17点定时统计询价单总数服务结束");
    }

    /**
     * 发布询价成功后加入当前用户的个人物料库
     * @param inquiryItems
     * @param sourceApp
     */
    public void saveProduct(List<PurcInquiryItem> inquiryItems, String sourceApp) {
        for (PurcInquiryItem item : inquiryItems) {
            Product product = new Product();
            // 需要哪些字段
            product.setEnUU(item.getInquiry().getEnUU());
            product.setUserUU(item.getInquiry().getRecorderUU());
            product.setCmpCode(item.getCmpCode());
            product.setBrand(item.getInbrand());
            product.setpCmpCode(item.getCmpCode());
            product.setpBrandEn(item.getInbrand());
            product.setStandard((short) 0);
            product.setCreateTime(new Date());
            product.setSourceApp(sourceApp);
            product.setSpec(StringUtils.isEmpty(item.getSpec()) ? item.getCmpCode() : item.getSpec());
            product.setKind(item.getProdTitle());
            product.setSpec((item.getSpec() == null || item.getSpec().equals("")) ? item.getCmpCode() : item.getSpec());
            // 调用公共物料服务的接口
            try {
                String url = PS_PRODUCT_URL + "/product/save/inquiry";
                String res = HttpUtil.doPost(url, FlexJsonUtils.toJsonDeep(product));
                JSONObject result = JSONObject.parseObject(res);
                Boolean success = (Boolean) result.get("success");
                if (success) {
                    logger.log("发布询价后保存到个人物料库", "保存询价明细id【" + item.getId() + "】到个人物料库成功", "保存成功", product.getUserUU(), product.getEnUU(), item.getSource());
                } else {
                    logger.log("发布询价后保存到个人物料库", "保存询价明细id【" + item.getId() + "】到个人物料库失败", result.get("message").toString(), product.getUserUU(), product.getEnUU(), item.getSource());
                }
            } catch (Exception e) {
                String reason = e.getMessage().length() > 10 ? e.getMessage().substring(0, 999).concat("") : e.getMessage();
                logger.log("报价成功后保存到个人物料库", "保存报价id【" + item.getId() + "】到个人物料库失败", reason, product.getUserUU(), product.getEnUU(), item.getSource());
            }
        }
    }


    /**
     * 通过报价明细id对供应商报价进行相关审核操作
     *
     * @param id     报价明细id
     * @param status 状态
     */
    @Override
    public void decideQuote(Long id, Short status) {
        PublicInquiryItem item = itemDao.findOne(id);
        // 验证是否重复操作
        validateInquiry(item);
        item.setAgreed(status);
        itemDao.save(item);
        // 更新询价推荐表相关信息
        if (status.equals(Constant.YES)) {
            inquiryRemindDao.updateStatus(item.getSourceId(), Status.ALLOW.value(), item.getVendUU());
            inquiryEnRemindDao.updateStatus(item.getSourceId(), Status.ALLOW.value(), item.getVendUU());
        } else if (status.equals(Constant.NO)) {
            inquiryRemindDao.updateStatus(item.getSourceId(), Status.NOTALLOW.value(), item.getVendUU());
            inquiryEnRemindDao.updateStatus(item.getSourceId(), Status.NOTALLOW.value(), item.getVendUU());
        }
        // 更新原公共询价单该条明细，设置为不可报价
        String sql = "update purc$puinquiryitems set id_overdue = 1 where id_id = " + item.getSourceId();
        jdbcTemplate.update(sql);
        inquiryService.notifyDecide(item, InquirySource.B2B.name());
    }


    /**
     * 商城通过报价明细id采纳对供应商报价
     *
     * @param id 报价明细id
     * @param status 状态
     */
    @Override
    public void adpotQuote(Long id, Short status) {
        PublicInquiryItem item = itemDao.findOne(id);
        // 验证是否重复操作
        validateInquiry(item);
        item.setAgreed(status);
        itemDao.save(item);
        // 更新询价推荐表相关信息
        if (status.equals(Constant.YES)) {
            inquiryRemindDao.updateStatus(item.getSourceId(), Status.ALLOW.value(), item.getVendUU());
            inquiryEnRemindDao.updateStatus(item.getSourceId(), Status.ALLOW.value(), item.getVendUU());
        } else if (status.equals(Constant.NO)) {
            inquiryRemindDao.updateStatus(item.getSourceId(), Status.NOTALLOW.value(), item.getVendUU());
            inquiryEnRemindDao.updateStatus(item.getSourceId(), Status.NOTALLOW.value(), item.getVendUU());
        }
        // 更新原公共询价单该条明细，设置为不可报价
        String sql = "update purc$puinquiryitems set id_overdue = 1 where id_id = " + item.getSourceId();
        jdbcTemplate.update(sql);
        inquiryService.adoptMessage(item, InquirySource.MALL.name());
    }

    /**
     * 验证是否已采纳或拒绝
     * @param item 报价单
     */
    private void validateInquiry(PublicInquiryItem item) {
        if (null != item.getAgreed()) {
            if (item.getAgreed().equals(Constant.YES)) {
                throw new IllegalOperatorException("该报价已被采纳，请勿重复处理");
            } else if (item.getAgreed().equals(Constant.NO)) {
                throw new IllegalOperatorException("该报价已被拒绝，请勿重复处理");
            }
        }
    }

    /**
     * 商城通过报价明细id拒绝对供应商报价
     *
     * @param id 报价明细id
     * @param status 状态
     */
    @Override
    public void refuseQuote(Long id, Short status,String refusereason) {
        PublicInquiryItem item = itemDao.findOne(id);
        // 验证是否重复操作
        validateInquiry(item);
        item.setAgreed(status);
        item.setRefusereason(refusereason);
        itemDao.save(item);
        if (status.equals(Constant.YES)) {
            inquiryRemindDao.updateStatus(item.getSourceId(), Status.ALLOW.value(), item.getVendUU());
            inquiryEnRemindDao.updateStatus(item.getSourceId(), Status.ALLOW.value(), item.getVendUU());
        } else if (status.equals(Constant.NO)) {
            inquiryRemindDao.updateStatus(item.getSourceId(), Status.NOTALLOW.value(), item.getVendUU());
            inquiryEnRemindDao.updateStatus(item.getSourceId(), Status.NOTALLOW.value(), item.getVendUU());
        }
        inquiryService.refuseMessage(item,InquirySource.MALL.name());
    }

    /**
     * 针对客户，查询供应商报价详情
     *
     * @param id   主表id
     * @param enuu 企业UU
     * @return
     */
    @Override
    public InquiryDetailInfo findById(Long id, Long enuu) {
        PublicInquiry inquiry = inquiryDao.findOne(id);
        InquiryDetailInfo inquiryInfo = new InquiryDetailInfo();
        if (inquiry != null) {
            inquiryInfo.setAttachs(inquiry.getAttachs());
            inquiryInfo.setAuditor(inquiry.getAuditor());
            inquiryInfo.setCheck(inquiry.getCheck());
            inquiryInfo.setCode(inquiry.getCode());
            inquiryInfo.setDate(inquiry.getDate());
            inquiryInfo.setEndDate(inquiry.getEndDate());
            inquiryInfo.setEnterprise(inquiry.getEnterprise());
            inquiryInfo.setEnUU(inquiry.getEnUU());
            inquiryInfo.setEnvironment(inquiry.getEnvironment());
            inquiryInfo.setId(inquiry.getId());
            inquiryInfo.setIsOpen(inquiry.getIsOpen());
            inquiryInfo.setOverdue(inquiry.getOverdue());
            inquiryInfo.setPriceType(inquiry.getPriceType());
            inquiryInfo.setRecorder(inquiry.getRecorder());
            inquiryInfo.setRecorderUU(inquiry.getRecorderUU());
            inquiryInfo.setRemark(inquiry.getRemark());
            inquiryInfo.setSourceApp(inquiry.getSourceApp());
            inquiryInfo.setSourceId(inquiry.getSourceId());
            inquiryInfo.setShip(inquiry.getShip());
            inquiryInfo.setInvoice(inquiry.getInvoice());
            inquiryInfo.setInquirytype(inquiry.getInquirytype());
            Set<Long> ids = new HashSet<Long>();
            List<Long> idList = new ArrayList<>();
            Set<InquiryProductInfo> products = new HashSet<InquiryProductInfo>();
            if (!CollectionUtils.isEmpty(inquiry.getInquiryItems())) {
                for (PublicInquiryItem item : inquiry.getInquiryItems()) {
                    if (item.getProductId() != null) {
                        idList.add(item.getProductId());
                        ids.addAll(idList);
                    } else {
                        InquiryProductInfo productInfo = new InquiryProductInfo();
                        Set<PublicInquiryItem> items = new HashSet<PublicInquiryItem>();
                        productInfo.setBrand(item.getBrand());
                        productInfo.setSpec(item.getSpec());
                        productInfo.setCode(item.getProdCode());
                        productInfo.setTitle(item.getProdTitle());
                        productInfo.setUnit(item.getUnit());
                        productInfo.setCmpCode(item.getCmpCode());
                        products.add(productInfo);
                        for (PublicInquiryItem item1 : inquiry.getInquiryItems()) {
                            if (item1.getCmpCode() != null && item1.getCmpCode().equals(productInfo.getCmpCode())) {
                                String sql = "select at_path,at_name from attachs a left join public$inquiryitems$attach p on a.at_id = p.at_id " +
                                        "left join public$inquiryitems i on p.id_id = i.id_id where i.id_id = " + item1.getId();
                                List<Map<String, Object>> maps = jdbcTemplate.queryForList(sql);
                                if (!org.springframework.util.CollectionUtils.isEmpty(maps)) {
                                    Map<String, Object> map = maps.get(0);
                                    item1.setAttachUrl(map.get("at_path").toString());
                                    item1.setAttachName(map.get("at_name").toString());
                                }
                                items.add(item1);
                            }
                        }
                        productInfo.setInquiryItems(items);
                        inquiryInfo.setProducts(products);
                    }
                }
            }
            if (!CollectionUtils.isEmpty(ids)) {
                for (Long idInfo : ids) {
                    InquiryProductInfo productInfo = new InquiryProductInfo();
                    Set<PublicInquiryItem> items = new HashSet<PublicInquiryItem>();
                    Product product = productDao.findOne(idInfo);
                    productInfo.setBrand(product.getBrand());
                    productInfo.setId(product.getId());
                    productInfo.setSpec(product.getSpec());
                    productInfo.setCode(product.getCode());
                    productInfo.setTitle(product.getTitle());
                    productInfo.setUnit(product.getUnit());
                    productInfo.setCmpCode(product.getCmpCode());
                    for (PublicInquiryItem item : inquiry.getInquiryItems()) {
                        if (item.getProductId().equals(idInfo)) {
                            String sql = "select at_path,at_name from attachs a left join public$inquiryitems$attach p on a.at_id = p.at_id " +
                                    "left join public$inquiryitems i on p.id_id = i.id_id where i.id_id = " + item.getId();
                            List<Map<String, Object>> maps = jdbcTemplate.queryForList(sql);
                            if (!org.springframework.util.CollectionUtils.isEmpty(maps)) {
                                Map<String, Object> map = maps.get(0);
                                item.setAttachUrl(map.get("at_path").toString());
                                item.setAttachName(map.get("at_name").toString());
                            }
                            items.add(item);
                        }
                    }
                    productInfo.setInquiryItems(items);
                    products.add(productInfo);
                    inquiryInfo.setProducts(products);
                }
            }
        }
        return inquiryInfo;
    }

    /**
     * 通过企业UU和分页信息等查询已发布信息
     *
     * @param info   分页信息
     * @param filter 过滤条件
     * @return
     */
    @Override
    public Page<PurcInquiry> findByPageInfo(final PageInfo info, SearchFilter filter) {
        if (info.getOffset() == 0) {
            info.setOffset(info.getPageSize() * (info.getPageNumber() - 1));
        }
        Sort sort = new Sort(Sort.Direction.DESC, "date");
        if (info.getPageNumber() == 0) {
            info.setPageNumber(1);
        }
        if (info.getPageSize() == 0) {
            info.setPageSize(5);
        }
        info.setSort(sort);
        if (null != filter.getUserUU()) {
            info.filter("recorderUU", filter.getUserUU());
        } else if (null != filter.getEnUU()) {
            info.filter("enUU", filter.getEnUU());
        } else {
            throw new IllegalAccessError("非法访问");
        }
        if (null != filter) {
            if (!StringUtils.isEmpty(filter.getKeyword())) {
                SimpleExpression code = new SimpleExpression("remark", filter.getKeyword(), CriterionExpression.Operator.LIKE);
                SimpleExpression[] simpleExpressions = new SimpleExpression[]{code};
                LogicalExpression logicalExpression = PredicateUtils.or(simpleExpressions);
                info.expression(logicalExpression);
            }
            if (filter.getFromDate() != null) {
                info.expression(PredicateUtils.gte("date", new Date(filter.getFromDate()), false));
            }
            if (filter.getEndDate() != null) {
                info.expression(PredicateUtils.lte("date", new Date(filter.getEndDate()), false));
            }
        }
        SimpleExpression amount = new SimpleExpression("amount", Constant.YES, CriterionExpression.Operator.GT);
        SimpleExpression[] simpleExpressions = new SimpleExpression[]{amount};
        LogicalExpression logicalExpression = PredicateUtils.and(simpleExpressions);
        info.expression(logicalExpression);
        return purcInquiryDao.findAll(new Specification<PurcInquiry>() {
            public Predicate toPredicate(Root<PurcInquiry> root, CriteriaQuery<?> query, CriteriaBuilder builder) {
                query.where(info.getPredicates(root, query, builder));
                return null;
            }
        }, info);
    }

    /**
     * 针对客户，查询单个物料的报价情况
     *
     * @param id   明细id
     * @param enuu 当前企业UU
     * @return
     */
    @Override
    public InquiryProductInfo findInquiryDetailById(Long id, Long enuu) {
        List<PublicInquiryItem> items = itemDao.findBySourceId(id);
        InquiryProductInfo productInfo = new InquiryProductInfo();
        if (!CollectionUtils.isEmpty(items)) {
            Long prId = items.get(0).getProductId();
            if (null != prId) {
                Product product = productDao.findOne(prId);
                productInfo.setBrand(product.getBrand());
                productInfo.setCode(product.getCode());
                productInfo.setTitle(product.getTitle());
                productInfo.setSpec(product.getSpec());
                productInfo.setUnit(product.getUnit());
                productInfo.setCmpCode(product.getCmpCode());
            } else {
                productInfo.setCmpCode(items.get(0).getCmpCode());
                productInfo.setBrand(items.get(0).getInbrand());
            }
            productInfo.setInquiryItems(new HashSet<PublicInquiryItem>(items));
        }
        return productInfo;
    }

    /**
     * 针对客户查询供应商报价信息
     *
     * @param pageInfo 分页信息
     * @param filter   过滤条件
     * @return
     */
    @Override
    public Page<PurcInquiryItemInfo> findQuotationsByPage(final PageInfo pageInfo, final SearchFilter filter, Long enUU, Long userUU) {
        if (enUU == null && userUU == null) {
            throw new IllegalAccessError("非法访问");
        }
        Sort sort = new Sort(Sort.Direction.DESC, "date");
        if (pageInfo.getOffset() == 0) {
            pageInfo.setOffset(pageInfo.getPageSize() * (pageInfo.getPageNumber() - 1));
        }
        pageInfo.setSort(sort);
        if (enUU != null) {
            pageInfo.filter("inquiry.enUU", enUU);
        } else {
            if (userUU != null) {
                pageInfo.filter("inquiry.recorderUU", userUU);
                pageInfo.expression(PredicateUtils.isNull("inquiry.enUU"));
            }
        }
        if (StringUtils.hasText(filter.getKeyword())) {
            SimpleExpression cmpCode = new SimpleExpression("cmpCode", filter.getKeyword(), CriterionExpression.Operator.LIKE);
            SimpleExpression inbrand = new SimpleExpression("inbrand", filter.getKeyword(), CriterionExpression.Operator.LIKE);
            SimpleExpression[] simpleExpressions = new SimpleExpression[]{inbrand, cmpCode};
            LogicalExpression logicalExpression = PredicateUtils.or(simpleExpressions);
            pageInfo.expression(logicalExpression);
        }
        if (filter.getFromDate() != null) {
            pageInfo.expression(PredicateUtils.gte("date", new Date(filter.getFromDate()), false));
        }
        if (filter.getEndDate() != null) {
            pageInfo.expression(PredicateUtils.lte("date", new Date(filter.getEndDate()), false));
        }
        pageInfo.expression(PredicateUtils.gt("offerAmount", Constant.NO, false));
        Page<PurcInquiryItemInfo> items = inquiryItemDao.findAll(new Specification<PurcInquiryItemInfo>() {
            public Predicate toPredicate(Root<PurcInquiryItemInfo> root, CriteriaQuery<?> query, CriteriaBuilder builder) {
                query.where(pageInfo.getPredicates(root, query, builder));
                return null;
            }
        }, pageInfo);
        if (!CollectionUtils.isEmpty(items.getContent())) {
            for (PurcInquiryItemInfo itemInfo : items.getContent()) {
                List<PublicInquiryItem> itemList = itemDao.findBySourceIdOrderByOfferTimeDesc(itemInfo.getId());
                itemInfo.setQutations(itemList);
                itemInfo.setQuotation(itemList.get(0));
                itemInfo.setAgreed(Constant.NO);
                if (!CollectionUtils.isEmpty(itemList)) {
                    for (PublicInquiryItem i : itemList) {
                        if (i.getAgreed() != null && i.getAgreed().equals(Constant.YES)) {
                            itemInfo.setAgreed(Constant.YES);
                            break;
                        }
                    }
                }
                if (null != itemInfo.getInquiry().getEndDate()) {
                    itemInfo.setRemainingTime(itemInfo.getInquiry().getEndDate().getTime() - System.currentTimeMillis());
                }
                if (null == itemInfo.getProductId()) {
                    Product product = new Product();
                    product.setTitle(itemInfo.getProdTitle());
                    product.setCmpCode(itemInfo.getCmpCode());
                    product.setBrand(itemInfo.getInbrand());
                    product.setSpec(itemInfo.getSpec());
                    itemInfo.setProduct(product);
                }
            }
        }
        return items;
    }

    /**
     * 针对客户单个公共询价，查询供应商报价信息
     *
     * @param id
     * @return
     */
    @Override
    public PurcInquiryItemInfo findQuotationById(Long id) {
        PurcInquiryItemInfo itemInfo = inquiryItemDao.findOne(id);
        List<PublicInquiryItem> itemList = itemDao.findBySourceId(itemInfo.getId());
        itemInfo.setQutations(itemList);

        itemInfo.setAgreed(Constant.NO);
        if (!CollectionUtils.isEmpty(itemList)) {
            for (PublicInquiryItem i : itemList) {
                if (i.getAgreed() != null && i.getAgreed().equals(Constant.YES)) {
                    itemInfo.setAgreed(Constant.YES);
                    break;
                }
            }
        }
        if (null != itemInfo.getInquiry().getEndDate()) {
            itemInfo.setRemainingTime(itemInfo.getInquiry().getEndDate().getTime() - System.currentTimeMillis());
        }
        if (null == itemInfo.getProductId()) {
            Product product = new Product();
            product.setTitle(itemInfo.getProdTitle());
            product.setCmpCode(itemInfo.getCmpCode());
            product.setBrand(itemInfo.getInbrand());
            product.setSpec(itemInfo.getSpec());
            itemInfo.setProduct(product);
        }
        return itemInfo;
    }
}