#!/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 AttendedTransferTest(TestCase):
    def __init__(self):
        super(AttendedTransferTest, self).__init__()

        self.passed = False
        self.alpha = False
        self.bravo = False
        self.charlie = False
        self.charlie_alpha = False
        self.channels = []

        # Test timeout in seconds
        self.test_to = 45
        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
                and self.charlie_alpha 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 the 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_alpha(self, ami, event):
        if event.get("userevent").lower() != "charlie_alpha":
            return
        status = event.get("status")
        LOGGER.debug("Status of charlie_alpha is %s" % (status))
        if status != "SUCCESS":
            LOGGER.warn("Charlie_alpha failed")
            self.stop_reactor()
            return
        LOGGER.info("Charlie_alpha succeeded")
        self.charlie_alpha = 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)
            ami.registerEvent("UserEvent", self.check_charlie_alpha)
        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(AttendedTransferTest, self).run()

        self.create_ami_factory(count=2)

def main():

    test = AttendedTransferTest()
    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
