#!/usr/bin/env python
'''
Copyright (C) 2010-2014, Digium, Inc.
David Vossel <dvossel@digium.com>
Matt Jordan <mjordan@digium.com>

This program is free software, distributed under the terms of
the GNU General Public License Version 2.
'''

import sys
import os
import math
import logging

from twisted.application import service, internet
from twisted.internet import reactor, defer

sys.path.append("lib/python")
from asterisk.test_case import TestCase

LOGGER = logging.getLogger(__name__)

class BlondeTransferTest(TestCase):
    def __init__(self):
        super(BlondeTransferTest, self).__init__()
        self.passed = False
        self.alpha = False
        self.bravo = False
        self.charlie = False

        self.channels = []
        self.create_asterisk(count=2)

    def check_result(self):
        LOGGER.debug("Checking results...")
        if self.alpha is True and self.bravo is True and self.charlie is True:
            LOGGER.info("Test passed")
            for channel in self.channels:
                LOGGER.debug("Hanging up %s" % channel)
                self.ami[1].hangup(channel)
            self.stop_reactor()
            self.passed = True

    def launch_test(self):
        LOGGER.info("Starting test...")
        self.ast[1].cli_originate("Local/1000@transfertest extension a_dial@transfertest")

    def check_alpha(self, ami, event):
        if event.get("userevent").lower() != "alpha":
            return

        status = event.get("status")
        LOGGER.debug("Status of alpha is %s" % (status))
        if status != "SUCCESS":
            LOGGER.warn("Alpha failed")
            self.stop_reactor()
            return
        LOGGER.info("Alpha succeeded")
        self.alpha = True
        self.check_result()

    def check_bravo(self, ami, event):
        if event.get("userevent").lower() != "bravo":
            return

        status = event.get("status")
        LOGGER.debug("Status of bravo is %s" % (status))
        if status != "SUCCESS":
            LOGGER.warn("Bravo failed")
            self.stop_reactor()
            return
        LOGGER.info("Bravo succeeded")
        self.bravo = True
        self.check_result()

    def check_charlie(self, ami, event):
        if event.get("userevent").lower() != "charlie":
            return
        status = event.get("status")
        LOGGER.debug("Status of charlie is %s" % (status))
        if status != "SUCCESS":
            LOGGER.warn("Charlie failed")
            self.stop_reactor()
            return
        LOGGER.info("Charlie succeeded")
        self.charlie = True
        self.check_result()

    def new_channel_handler(self, ami, event):
        self.channels.append(event['channel'])

    def hangup_handler(self, ami, event):
        if event['channel'] in self.channels:
            self.channels.remove(event['channel'])

    def ami_connect(self, ami):
        """AMI Connection Handler"""

        if (ami.id == 0):
            ami.registerEvent("UserEvent", self.check_alpha)
            ami.registerEvent("UserEvent", self.check_charlie)
        else:
            ami.registerEvent("UserEvent", self.check_bravo)
            ami.registerEvent('Newchannel', self.new_channel_handler)
            ami.registerEvent('Hangup', self.hangup_handler)

        if len(self.ami) == 2:
            self.launch_test()

    def run(self):
        super(BlondeTransferTest, self).run()
        self.create_ami_factory(count=2)


def main():
     # Run Blonde Transfer Test
    test = BlondeTransferTest()
    reactor.run()
    if test.passed != True:
        return 1
    return 0

if __name__ == "__main__":
    sys.exit(main() or 0)

# vim:sw=4:ts=4:expandtab:textwidth=79
