from daemonize import Daemonize
#from apns import APNs, Payload
import redis
import time
import signal
import sys
import os
import logging
import socket

import ssl
import struct
import binascii



def sigint_handler(signal, frame):
    sys.exit(0)
    os._exit(0)

def redisLoop(apns, logger):
    r = redis.StrictRedis(host='localhost', port=6379, db=0)
    while 1:
        #logger.info("Checking queue for messages to send...")
        time.sleep(0)
        data = r.brpop("apns_push", 10)
        if data:
            info = data[1].split('|')
            logger.info("Token: " + info[0] + " message: " + info[1])
            try:
                apns.sendNotification(info[0], info[1])
            except TypeError:
                logger.info("Invalid token: " + info[0])


def sigint_handler(signal, frame):
    sys.exit(0)

def get_logger():
    logger = logging.getLogger("apns_logger")
    logger.setLevel(logging.INFO)

    fh = logging.FileHandler("/tmp/apns_sender.log")
    fmt = '%(asctime)s - %(threadName)s - %(levelname)s - %(message)s'
    formatter = logging.Formatter(fmt)
    fh.setFormatter(formatter)

    logger.addHandler(fh)
    return logger

class APNSClient():
    def __init__(self, host, port, cert_file, logger):
        self.host = host
        self.port = port
        self.cert_file = cert_file
        self.logger = logger
        self.is_connected = False

    def setupConnection(self):
        # socket
        sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        wsock = ssl.wrap_socket(sock, ssl_version=ssl.PROTOCOL_TLSv1_2, certfile=self.cert_file)
        wsock.connect((self.host, self.port))

        self.is_connected = True
        self.conn = wsock

        return wsock

    def connect(self):
        if not self.is_connected:
            self.setupConnection()

    def sendNotification(self, token, message):
        # connect
        self.connect()

        # apns packet
        payload = '{"aps": {"alert" : "%s", "sound": "bingbong.aiff"}}' % message
        bin_token = binascii.unhexlify(token)
        fmt = "!cH32sH%ds" % len(payload)
        cmd = '\x00'
        packet = struct.pack(fmt, cmd, len(bin_token), bin_token, len(payload), payload)

        # send packet
        self.conn.send(packet)

        # TODO: figure out how to make this connection persistent
        self.conn.close()
        self.is_connected = False



def main():
    logger = get_logger()
    logger.info("Starting apns_sender")

    #apns = APNs(use_sandbox=False, cert_file=cert_file)
    #apns = setup_apns()

    # TODO: load from config file
    cert_file = "/root/ios_push_test/ios_prod.pem"
    host = 'gateway.push.apple.com'
    port = 2195
    apns = APNSClient(host, port, cert_file, logger)

    logger.info("Starting redis loop")
    redisLoop(apns, logger)

    signal.signal(signal.SIGINT, sigint_handler)



pid = "/tmp/apns_sender.pid"
#daemon = Daemonize(app="apns_sender", pid=pid, action=main)
#daemon.start()
main()