package com.xxx.pushmsg.service.ios.impl;

import com.xxx.common.constant.CacheConstant;
import com.xxx.common.utils.RedisUtils;
import com.xxx.common.utils.StringUtil;
import com.xxx.pushmsg.service.ios.IosPushMsgService;
import com.notnoop.apns.APNS;
import com.notnoop.apns.ApnsDelegate;
import com.notnoop.apns.ApnsService;
import 
 
com.notnoop.apns.PayloadBuilder;
import com.notnoop.exceptions.NetworkIOException;
import javapns.notification.transmission.NotificationProgressListener;
import javapns.notification.transmission.NotificationThread;
import javapns.notification.transmission.NotificationThreads;
import org.apache.commons.collections.MapUtils;
import 
 
org.apache.commons.lang.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;

import javax.annotation.PostConstruct;
import javax.annotation.Resource;
import java.util.Date;
import 
 
java.util.Iterator;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

@Service
public class IosPushMsgServiceImpl implements IosPushMsgService {
   private static final Logger log = LoggerFactory.getLogger(IosPushMsgServiceImpl.class);
    private static final Logger logPush = LoggerFactory.getLogger("push_arrival_rate");
   public static final ConcurrentHashMap<Long, Integer> msgStateMap = new ConcurrentHashMap<Long, Integer>();
    @Value("${priest.pushmsg.production}")

    //是否是生產環境
    private boolean production;

    @Value("${priest.pushmsg.certificate.file.name}")

    //證書檔案地址
    private String certificateName;

    ApnsService service = null;
    @Resource
private RedisUtils redisUtils;

    //連線池大小
    private int capacity = 20;
    @Resource
private ApnsDelegate delegate;
    @PostConstruct
public void init() {
        String password = "123456"; // 證書密碼
try {

    //初始化服務型別為基本訊息處理型別，並且連線設定為連線池
            service = APNS.newService().withCert(certificateName, password)
                    .asPool(capacity).withDelegate(delegate).withAppleDestination(production).build();
        } catch (Exception e) {
            log.error("Init error Class::IosPushMsgServiceImpl Method::init", e);
        }

    }

   public void stopPush(Long msgId){
      
   }

    public boolean pushOffLineMessageNotnoop(Map<String, String> tokenMessgae, Map<String, Object> mapCustom) {

        if (MapUtils.isEmpty(tokenMessgae)) {
            return true;
        }

        //鈴音，微信等應用實現語音呼叫時使用的方式是將此鈴音設定為30秒的長鈴音，最大限制為30秒。

    //傳送方法
    private void send(Map<String, String> tokenMessage, String launchImage, String sound, Map<String, Object> mapCustom) {

        try {
            Long nowStart = System.currentTimeMillis();
            Map<String, String> mapCount = this.redisUtils.hGetAll(CacheConstant.CACHE_PREFIX_IOS_GROUP_PUSHMSG_COUNT);
            //傳送訊息
Iterator<String> it = tokenMessage.keySet().iterator();
            while (it.hasNext()) {
                Long nowStart111 = System.currentTimeMillis();
                String token = it.next();

                //因為標準的Token大小為64位，因此如果Token不符合規範則不推
                if (token.length() < 64) {
                    continue;
                }
                String alert = tokenMessage.get(token);

                //構造Payload
                PayloadBuilder payloadBuilder = APNS.newPayload();
                //拼裝訊息
payloadBuilder = payloadBuilder.alertBody(alert);

                if (!StringUtils.isEmpty(launchImage)) {
                    payloadBuilder = payloadBuilder.launchImage(launchImage);
                }
                if (!StringUtils.isEmpty(sound)) {
                    payloadBuilder = payloadBuilder.sound(sound);
                }
                //裁剪訊息
if (payloadBuilder.isTooLong()) {
                    payloadBuilder = payloadBuilder.shrinkBody();
                }
                payloadBuilder = payloadBuilder.forNewsstand();
                //增加額外的資訊
if(null != mapCustom)
                    payloadBuilder.customFields(mapCustom);
                Integer count = 1;
                if (mapCount.containsKey(token)) {
                    String countStr = mapCount.get(token);
                    count = StringUtil.isEmpty(countStr) ? 0 : Integer.valueOf(countStr);
                    if (count < 99) {
                        count = count + 1;
                    } else {
                        count = 99;
                    }
                }

                //設定小紅圈上面的數字
                payloadBuilder.badge(count);
                //組裝成json
String payload = payloadBuilder.build();

                //傳送訊息
                service.push(token, payload, new Date(System.currentTimeMillis() + 1000 * 1000));
                Long nowEnd111 = System.currentTimeMillis();

                //重組訊息體，去除其中的Emoji，否則傳送訊息體會出現問題
                String logContent = StringUtil.filterEmoji(alert).replaceAll("\r","").replaceAll("\n","");
                this.redisUtils.hPut(CacheConstant.CACHE_PREFIX_IOS_GROUP_PUSHMSG_COUNT, token, count);
                StringBuffer sb = new StringBuffer();
                sb.append("{\"token\":");
                sb.append("\"");
                sb.append(token);
                sb.append("\"");
                sb.append(",\"content\":");
                sb.append("{");
                sb.append("\"content\":");
                sb.append("\"");
                sb.append(logContent);
                sb.append("\"");
                sb.append(",\"createTime\":");
                sb.append(nowEnd111);
                sb.append("}");
                sb.append(",\"ret\":");
                sb.append("{\"ret_code\":0}");
                sb.append("}");
                logPush.info(sb.toString());
            }
            Long nowEnd = System.currentTimeMillis();
            log.info("IOSPushMsgSend Cost:" + (nowEnd - nowStart));
        } catch (NetworkIOException e) {
            log.error("Send Multi Error NetworkIOException At Class::IosPushMsgServiceImpl Method::send"
+ " Param::tokenMessage:" + tokenMessage, e);
            if (e.toString().contains("certificate")) {
                //shortMessageService.sendMessage(Long.MAX_VALUE, null, "15001257920", e.toString());
}
        } catch (Exception ex) {
            log.error("Send Multi Error Exception At Class::IosPushMsgServiceImpl Method::send"
+ " Param::tokenMessage:" + tokenMessage, ex);
        } finally  {
        }
    }

   public static final NotificationProgressListener DEBUGGING_PROGRESS_LISTENER = new NotificationProgressListener() {
      public void eventThreadStarted(NotificationThread notificationThread) {
         log.info("EventThreadStarted [EVENT]: thread #" + notificationThread.getThreadNumber() + " started with "
+ " devices beginning at message id #" + notificationThread.getFirstMessageIdentifier()
                    + " At Class::NotificationProgressListener Method::eventThreadStarted" + notificationThread.getFailedNotifications());
      }

      public void eventThreadFinished(NotificationThread thread) {
         log.info("EventThreadFinished [EVENT]: thread #" + thread.getThreadNumber() + " finished: pushed messages #"
+ thread.getFirstMessageIdentifier() + " to " + thread.getLastMessageIdentifier() + " toward " + " devices"
+ " At Class::NotificationProgressListener Method::eventThreadFinished" + thread.getFailedNotifications());
      }

      public void eventConnectionRestarted(NotificationThread thread) {
            log.info("EventConnectionRestarted [EVENT]: connection restarted in thread #" + thread.getThreadNumber()
                    + " because it reached " + thread.getMaxNotificationsPerConnection() + " notifications per connection"
+ " At Class::NotificationProgressListener Method::eventConnectionRestarted" + thread.getFailedNotifications());
      }

      public void eventAllThreadsStarted(NotificationThreads notificationThreads) {
            log.info("EventAllThreadsStarted [EVENT]: all threads started: " + notificationThreads.getThreads().size()
            + " At Class::NotificationProgressListener Method::eventAllThreadsStarted" + notificationThreads.getFailedNotifications());
      }

      public void eventAllThreadsFinished(NotificationThreads notificationThreads) {
            log.info("EventAllThreadsFinished [EVENT]: all threads finished: " + notificationThreads.getThreads().size()
                    + " At Class::NotificationProgressListener Method::eventAllThreadsFinished" + notificationThreads.getFailedNotifications());
      }

      public void eventCriticalException(NotificationThread notificationThread, Exception exception) {
            log.info("EventCriticalException [EVENT]: critical exception occurred: " + exception
                    + " At Class::NotificationProgressListener Method::eventCriticalException" + notificationThread.getFailedNotifications());
        }
   };

    public void setCapacity(int capacity) {
        this.capacity = capacity;
    }

}