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


import com.alibaba.fastjson.JSONObject;
import com.uas.account.entity.User;
import com.uas.account.util.AccountUtils;
import com.uas.account.util.FlexJsonUtil;
import com.uas.ps.message.dao.AppDao;
import com.uas.ps.message.dao.MessageDao;
import com.uas.ps.message.domain.App;
import com.uas.ps.message.domain.Message;
import com.uas.ps.message.domain.SmsMessage;
import com.uas.ps.message.exception.IllegalOperatorException;
import com.uas.ps.message.exception.ParameterMissingException;
import com.uas.ps.message.service.MessageService;
import com.uas.ps.message.util.Constant;
import com.uas.ps.message.util.ConsumeType;
import com.uas.ps.message.util.FastjsonUtils;
import com.uas.ps.message.util.SMSType;
import com.uas.ps.message.util.SplitChar;
import com.uas.ps.message.util.account.HttpUtil;
import com.uas.ps.message.util.account.HttpUtil.ResponseWrap;
import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import org.apache.log4j.Logger;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpHeaders;
import org.springframework.http.MediaType;
import org.springframework.stereotype.Service;
import org.springframework.util.CollectionUtils;
import org.springframework.util.StringUtils;
import org.springframework.web.client.RestTemplate;

/**
 * Created by wangyc on 2018/1/13.
 *
 * @version 2018/1/13 15:44 wangyc
 */
@Service
public class MessageServiceImpl implements MessageService {

    private final MessageDao messageDao;

    private final AppDao appDao;

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

    private RestTemplate restTemplate;

    private static final String EMAIL_REGEX = "\\w[-\\w.+]*@([A-Za-z0-9][-A-Za-z0-9]+\\.)+[A-Za-z]{2,14}";

    private static final String TEL_REGEXP = "^((\\(\\d{3}\\))|(\\d{3}\\-))?(13|15|18|17)\\d{9}$";

    private static final String PROD_URL = "http://113.105.74.140:8092/tigase/baiduPush";
    /**
     * 邮件服务主机地址
     */
//    @Value("#{sys.messageServiceIp ?: 'http://message.ubtob.com/'}")
    private static final String MAIL_CONSOLE_HOST = "http://message.ubtob.com/";

    /**
     * 发送邮件给单个人url
     */
    private static final String MAIL_SEND_URL = "mail/send";

    /**
     * 发送邮件给多个人 url
     */
    private static final String MAIL_SEND_MANY_URL = "mail/send/o2m";
    /**
     * 短信接口
     */
    private final String messageUrl = "http://message.ubtob.com/sms/send";

    @Autowired
    public MessageServiceImpl(MessageDao messageDao, AppDao appDao) {
        this.messageDao = messageDao;
        this.appDao = appDao;
    }

    @Override
    public List<Message> getMessages(String receiverUu, String receiverEnuu, String consumerApp) {
        List<Message> messages = new ArrayList<>();
        if (StringUtils.isEmpty(receiverUu) || StringUtils.isEmpty(receiverEnuu)) {
            throw new ParameterMissingException("接收人信息为空");
        }
        App consumerAppExists = appDao.findByName(consumerApp);
        if (consumerApp == null) {
            throw new IllegalOperatorException("接收应用不存在");
        }

        messages = messageDao.findByReceiverUuAndReceiverEnuuAndConsumerAppId(Long.valueOf(receiverUu),
            Long.valueOf(receiverEnuu), consumerAppExists.getId());
        return messages;
    }

    @Override
    public List<Message> saveMessages(String messages) {
        List<JSONObject> jsonObjects = FastjsonUtils.fromJsonArray(messages, JSONObject.class);
        List<Message> messageList = convertFromJsonObj(jsonObjects);
        return messageDao.save(messageList);
    }

    @Override
    public Map<String, Object> sendMessage(String consumerApp) {
        JSONObject consumer = FastjsonUtils.parseObject(consumerApp);
        Object consumerAppObj = consumer.get("consumerApp");
        if (consumerAppObj != null && !StringUtils.isEmpty(String.valueOf(consumerAppObj))) {
            App consumerAppExists = appDao.findByName(String.valueOf(consumerAppObj));
            if (consumerAppExists == null) {
                throw new IllegalOperatorException("接收应用不存在");
            }

            // 获取改应用应接收的未读、未发送的需要推送的消息
            List<Message> messages = messageDao.findByConsumerAppIdAndIsReadAndIsSentNeedToSend(consumerAppExists.getId(),
                Constant.NO, Constant.NO);

            Map<String, Object> resultMap = sendMessageByAPI(messages, consumerApp);
            resultMap.put("success", "success");
            return resultMap;
        } else {
            throw new ParameterMissingException("接收应用信息为空");
        }
    }

    /**
     * jsonObject转换为Message
     * @param jsonObjects jsonObjects
     * @return messages
     */
    private List<Message> convertFromJsonObj(List<JSONObject> jsonObjects) {
        List<Message> messages = new ArrayList<>();
        for (JSONObject jsonObject : jsonObjects) {
            Message message = new Message();

            // 消息内容
            Object content = jsonObject.get("content");
            if (StringUtils.isEmpty(content)) {
                throw new ParameterMissingException("消息内容为空");
            } else {
                message.setContent(String.valueOf(content));
            }

            // 发送人
            Object senderUu = jsonObject.get("senderUu");
            Object senderEnuu = jsonObject.get("senderEnuu");
            if (StringUtils.isEmpty(senderUu) || StringUtils.isEmpty(senderEnuu)) {
                throw new ParameterMissingException("发送人信息为空");
            } else {
                message.setSenderUu(Long.valueOf(String.valueOf(senderUu)));
                message.setSenderEnuu(Long.valueOf(String.valueOf(senderEnuu)));
            }

            // 接收人
            Object receiverUu = jsonObject.get("receiverUu");
            Object receiverEnuu = jsonObject.get("receiverEnuu");
            if (StringUtils.isEmpty(receiverUu) || StringUtils.isEmpty(receiverEnuu)) {
                throw new ParameterMissingException("接收人信息为空");
            } else {
                message.setReceiverUu(Long.valueOf(String.valueOf(receiverUu)));
                message.setReceiverEnuu(Long.valueOf(String.valueOf(receiverEnuu)));
            }

            // 发送应用
            Object producerApp = jsonObject.get("producerApp");
            if (StringUtils.isEmpty(producerApp)) {
                throw new ParameterMissingException("发送应用为空");
            } else {
                App app = appDao.findByName(String.valueOf(producerApp));
                if (app == null) {
                    throw new IllegalOperatorException("发送应用不存在");
                }
                message.setProducerApp(app.getId());
            }

            // 接收应用
            Object consumerType = jsonObject.get("consumerType");
            if (StringUtils.isEmpty(consumerType)) {
                throw new ParameterMissingException("接收应用类型为空");
            } else {
                String type = String.valueOf(consumerType);
                // 消息接收类型为公共，即所有子应用共享
                if (ConsumeType.PUBLIC.equals(type)) {
                    List<App> apps = appDao.findAll();
                    message.setConsumerApp(new HashSet<>(apps));
                    message.setConsumeType(type);
                } else {
                    Object consumerApp = jsonObject.get("consumerApp");
                    if (consumerApp == null) {
                        throw new ParameterMissingException("接收应用为空");
                    } else {
                        // 取出通过逗号拼接的接收应用
                        String[] consumers = String.valueOf(consumerApp).split(SplitChar.COMMA);
                        if (consumers.length < 1) {
                            throw new ParameterMissingException("接收应用为空");
                        }

                        Set<App> consumerApps = new HashSet<>();
                        for (String consumer : consumers) {
                            App app = appDao.findByName(consumer);
                            if (app == null) {
                                throw new IllegalOperatorException("接收应用不存在");
                            }
                            consumerApps.add(app);
                        }

                        message.setConsumerApp(consumerApps);
                        message.setConsumeType(consumers.length > 1 ? ConsumeType.MULTI : ConsumeType.SINGLE);
                    }
                }
            }

            // 消息类型（暂时未定）
            Object type = jsonObject.get("type");
            if (!StringUtils.isEmpty(type)) {
                message.setType(String.valueOf(type));
            }

            // 推送类型
            Object smsType = jsonObject.get("smsType");
            if (StringUtils.isEmpty(smsType)) {
                message.setSmsType(SMSType.DONT_SEND);
            } else {
                message.setSmsType(String.valueOf(smsType));
            }

            // 备注
            Object remark = jsonObject.get("remark");
            if (!StringUtils.isEmpty(remark)) {
                message.setRemark(String.valueOf(remark));
            }

            // 邮件模板
            Object mailTemplate = jsonObject.get("mailTemplate");
            if (!StringUtils.isEmpty(mailTemplate)) {
                message.setMailTemplate(String.valueOf(mailTemplate));
            }

            // 短信模板
            Object smTemplate = jsonObject.get("smTemplate");
            if (!StringUtils.isEmpty(mailTemplate)) {
                message.setSmTemplate(String.valueOf(smTemplate));
            }

            message.setIsRead(Constant.NO);
            message.setCreateTime(new Date());
            message.setIsSent(Constant.NO);

            messages.add(message);
        }
        return messages;
    }

    /**
     * 推送消息（调用邮件、短信、IM接口）
     * @param messages 消息
     * @param consumerApp 消费app
     * @return resultMap
     */
    private Map<String, Object> sendMessageByAPI(List<Message> messages, String consumerApp) {
        Map<String, Object> resultMap = new HashMap<>();

        if (!CollectionUtils.isEmpty(messages)) {
            for (Message message : messages) {
                try {
                    User receiver = AccountUtils.getImUserByUserUU(message.getReceiverUu());
                    // 发送邮件
                    if (message.getSmsType().contains(SMSType.MAIL)) {
                        sendMail(message, receiver);
                    }

                    // 发送短息
                    if (message.getSmsType().contains(SMSType.SM)) {
                        sendSM(message, receiver);
                    }

                    // 发送IM
                    if (message.getSmsType().contains(SMSType.IM)) {
                        sendIM(message, receiver, consumerApp);
                    }
                    message.setIsSent(Constant.YES);
                } catch (Exception e) {
                    System.err.println(e.getMessage());
                }
            }
            messageDao.save(messages);
        }
        return resultMap;
    }

    /**
     * 发送邮件
     * @param message 消息
     * @param receiver 接收人
     */
    private void sendMail(Message message, User receiver) {
        if (message.getMailTemplate() != null && receiver.getSecondUID() != null) {
            HttpHeaders headers = new HttpHeaders();
            MediaType type = MediaType.parseMediaType("application/json; charset=UTF-8");
            headers.setContentType(type);
            headers.add("Accept", MediaType.APPLICATION_JSON.toString());

            JSONObject object = new JSONObject();
            object.put("templateId", message.getMailTemplate());
            object.put("receiver", receiver.getSecondUID());
            object.put("params", message.getContent());

//            HttpEntity<String> formEntity = new HttpEntity<String>(, headers);
            try {
                ResponseWrap responseWrap = HttpUtil.doPost(MAIL_CONSOLE_HOST + MAIL_SEND_URL,
                    FlexJsonUtil.toJson(object));
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

    /**
     * 发送短信
     * @param message 消息
     * @param receiver 接收人
     */
    private void sendSM(Message message, User receiver) {
        if (!StringUtils.isEmpty(message.getSmTemplate()) && !StringUtils.isEmpty(receiver.getUid())) {
            if (receiver.getUid() != null) {
                try {
                    SmsMessage sms = new SmsMessage();
                    List<Object> obj = new ArrayList<Object>();
                    obj.add(receiver.getName());
                    obj.add(receiver.getName());

                    User sender = AccountUtils.getImUserByUserUU(message.getSenderUu());
                    if (sender != null) {
                        obj.add(sender.getName() + "("
                            + sender.getName() + ")");
                        sms.setParams(obj);
                        sms.setReceiver(receiver.getUid());
                        sms.setTemplateId(message.getSmTemplate());
                        String response = com.uas.ps.message.util.HttpUtil.sendPost(messageUrl, FastjsonUtils.toJson(sms));
                        logger.info("发送短信：" + response);
                    }
                } catch (Exception e) {
                    logger.info("发送短信异常：" + e.getMessage());
                    e.printStackTrace();
                }
            }
        }
    }

    /**
     * 发送IM
     * @param message 消息
     * @param receiver 接收人
     * @param consumerApp 消费app
     */
    private void sendIM(Message message, User receiver, String consumerApp) {
        Map<String, Object> params = new HashMap<>();
        if (!StringUtils.isEmpty(receiver.getDialectUID())) {
// TODO           params.put("master", enterprise.getEnName()); // 账套 公司名称
            params.put("userid", receiver.getDialectUID()); // 推送目标用户
//  TODO          String title = "";
//            params.put("title", message.getType()); // 推送标题
            params.put("content", message.getContent()); // 正文
            params.put("enUU", message.getReceiverEnuu()); // UU号
            params.put("url", ""); // 跳转链接地址
            // TODO
            params.put("platform", consumerApp); // 系统名称，ERP或
            try {
                ResponseWrap res = HttpUtil.doPost(PROD_URL, params);
                if (!res.isSuccess()) {
                    throw new Exception(res.getContent());
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
}