import os
import sys
import time
import logging
import argparse
import unittest
import requests
import xml.dom.minidom as md
from xml.etree import ElementTree as ET
from netaddr import IPNetwork
from string import lower

import mininet.node
import mininet.topo
import mininet.net
import mininet.util

from mininet.node import RemoteController
from mininet.node import OVSKernelSwitch

def create_network(controller_ip, controller_port):
    """Create topology and mininet network."""
    topo = mininet.topo.Topo()

    topo.addSwitch('s1')
    topo.addHost('h1')
    topo.addHost('h2')

    topo.addLink('h1', 's1')
    topo.addLink('h2', 's1')

    switch=mininet.util.customConstructor(
        {'ovsk':OVSKernelSwitch}, 'ovsk,protocols=OpenFlow13')

    controller=mininet.util.customConstructor(
        {'remote': RemoteController}, 'remote,ip=%s:%s' % (controller_ip,
                                                           controller_port))


    net = mininet.net.Mininet(topo=topo, switch=switch, controller=controller)

    return net


def get_flows(net):
    """Get list of flows from network's first switch.

    Return list of all flows on switch, sorted by duration (newest first)
    One flow is a dictionary with all flow's attribute:value pairs. Matches
    are stored under 'matches' key as another dictionary.
    Example:

        {
            'actions': 'drop',
            'cookie': '0xa,',
            'duration': '3.434s,',
            'hard_timeout': '12,',
            'idle_timeout': '34,',
            'matches': {
                'ip': None,
                'nw_dst': '10.0.0.0/24'
            },
            'n_bytes': '0,',
            'n_packets': '0,',
            'priority': '2',
            'table': '1,'
        }

    """
    log = logging.getLogger(__name__)
    def parse_matches(flow, matches):
        flow['matches'] = {}

        for match in matches:
            split_match = match.split('=', 1)
            if len(split_match) == 1:
                flow['matches'][split_match[0]] = None
            else:
                flow['matches'][split_match[0]] = split_match[1].rstrip(',')

    switch = net.switches[0]
    output = switch.cmdPrint(
        'ovs-ofctl -O OpenFlow13 dump-flows %s' % switch.name)
#    output = switch.cmdPrint(
#        'ovs-ofctl -F openflow10 dump-flows %s' % switch.name)

    log.debug('switch flow table: {}'.format(output))

    flows = []

    for line in output.splitlines()[1:]:
        flow = {}
        for word in line.split():
            word.rstrip(',')
            try:
                key, value = word.split('=', 1)
            except ValueError:
                #TODO: need to figure out what to do here?
                continue

            if key == 'priority':
                values = value.split(',')
                flow[key] = values[0]
                parse_matches(flow, values[1:])
            else:
                flow[key] = value.rstrip(',')

        flows.append(flow)

    # sort by duration 
    return sorted(flows, key=lambda x: x['duration'].rstrip('s'))


def translate_to_flow(flow, name, dictionary):
    switch_flow_name = dictionary[name]

    key_err = '{} needs to be present in flow definition. Flow definition ' \
              'was: {}.'.format(switch_flow_name, flow)
    assert switch_flow_name in flow, key_err
    return switch_flow_name


def get_text_value(element):
    return element.childNodes[0].nodeValue


def fallback_comparator(xml_element, switch_flow, kw):
    # print 'fallback_comparator-xml_element', xml_element.toxml()
    # print 'fallback_comparator: switch_flow', switch_flow
    # print 'fallback_comparator: kw', kws

    name = translate_to_flow(switch_flow, xml_element.nodeName, kw)

    actual = switch_flow[name]
    expected = xml_element.childNodes[0].nodeValue

    data = xml_element.toxml(), name, actual
    # print 'fallback_comparator: data', data

    assert expected == actual, 'xml part: %s && switch %s=%s' % data


def default_comparator(xml_element, switch_flow):
    fallback_comparator(xml_element, switch_flow, keywords)


def cookie_comparator(cookie, switch_flow):
    name = translate_to_flow(switch_flow, cookie.nodeName, keywords)

    actual = int(switch_flow[name], 0)
    expected = int(cookie.childNodes[0].nodeValue)
    data = cookie.toxml(), name, actual

    assert expected == actual, 'xml part: %s && switch %s=%s' % data


def ethernet_address_comparator(child, actual_match, kw):
    expected_address = child.getElementsByTagName("address")[0].childNodes[0].data
    actual_address = actual_match[kw.get(child.nodeName)]

    data = child.toxml(), kw.get(child.nodeName), actual_address

    assert lower(expected_address) == lower(actual_address), \
        'xml address: %s && actual address %s=%s' % data


def ethernet_match_comparator(expected_match, actual_match, kw):
    def compare_etype(child, actual_match, kw):
        expected_etype = int(child.getElementsByTagName("type")[0].childNodes[0].data)
        name = kw.get(child.nodeName)
        data = child.toxml(), name, actual_match

        if expected_etype == 2048: # IP
            assert ((actual_match.get('ip', 'IP Not-present') is None) or \
                    (actual_match.get('tcp', 'TCP Not-present') is None) or \
                    (actual_match.get('sctp', 'SCTP Not-present') is None) or \
                    (actual_match.get('udp', 'UDP Not-present') is None)), \
                     'Expected etype %s && actual etype %s=%s' % data
 
        elif expected_etype == 2054: #ARP
            assert actual_match.get('arp', 'ARP Not-present') is None, \
                     'Expected etype %s && actual etype %s=%s' % data

        else:
            actual_etype = int(actual_match[name], 16)

            assert expected_etype == actual_etype, 'xml etype: %s && actual etype %s=%s' % data


    ETH_COMPARATORS = {
        'ethernet-type': compare_etype, 
        'ethernet-source': ethernet_address_comparator,
        'ethernet-destination': ethernet_address_comparator,
    }    

    # print 'ethernet_match_comparator-expected_match:', expected_match.toxml()
    # print 'ethernet_match_comparator-actual_match:', actual_match
    # print 'ethernet_match_comparator-keywords:', keywords

    for child in expected_match.childNodes:
        if child.nodeType is expected_match.TEXT_NODE:
            continue
      
        comparator = ETH_COMPARATORS.get(child.nodeName)
        comparator(child, actual_match, kw)
            

def ip_v4_comparator(expected_match, actual_match, kw):
    # print 'ip_v4_comparator:', expected_match.toxml(), actual_match
    # print 'ip_v4_comparator-actual_match:', actual_match

    expected_value = expected_match.childNodes[0].data
    actual_value = actual_match[kw.get(expected_match.nodeName)]

    data = expected_match.toxml(), kw.get(expected_match.nodeName), actual_value

    assert IPNetwork(expected_value) == IPNetwork(actual_value), 'xml part: %s && address %s=%s' % data


def ip_match_comparator(expected_match, actual_match, kw):
    def compare_proto(child, actual_match, kw):
        print 'compare_proto:', child.toxml(), actual_match
        expected_proto = int(child.childNodes[0].data)

        name = child.nodeName
        data = expected_match.toxml(), name, actual_match

        if expected_proto == 6: # TCP
            assert actual_match.get('tcp', 'TCP Not-present') is None, \
                   'ip protocol type: expected %s, actual %s=%s' % data

        elif expected_proto == 17: #UDP
            assert actual_match.get('udp', 'UDP Not-present') is None, \
                   'ip protocol type: expected %s, actual %s=%s' % data

        elif expected_proto == 132: #SCTP
            assert actual_match.get('sctp', 'SCTP Not-present') is None, \
                   'ip protocol type: expected %s, actual %s=%s' % data

        else:
            fallback_comparator(child, actual_match, kw)


    def compare_dscp(child, actual_match, kw):
        # print 'compare_dscp:', child.toxml(), actual_match

        expected_dscp = int(child.childNodes[0].data)
        name = kw.get(child.nodeName)
        actual_dscp = int(actual_match[name])
        
        data = child.toxml(), name, actual_match

        assert (expected_dscp * 4) == actual_dscp, 'dscp: expected %s, actual %s=%s' % data


    IP_MATCH_COMPARATORS = {
        'ip-protocol': compare_proto, 
        'ip-dscp': compare_dscp,
        'ip-ecn': fallback_comparator,
    }    

    # print 'ip_match_comparator:', expected_match.toxml(), actual_match

    for child in expected_match.childNodes:
        if child.nodeType is expected_match.TEXT_NODE:
            continue
      
        comparator = IP_MATCH_COMPARATORS.get(child.nodeName)
        comparator(child, actual_match, kw)


def match_comparator(expected_match, switch_flow):
    MATCH_COMPARATORS = {
        'arp-source-hardware-address': ethernet_address_comparator,
        'arp-target-hardware-address': ethernet_address_comparator,
        'ethernet-match': ethernet_match_comparator,
        'ip-match': ip_match_comparator,
        'ipv4-destination': ip_v4_comparator,
        'ipv4-source': ip_v4_comparator,
        'default': fallback_comparator,
    }

    actual_match = switch_flow['matches']

    # print 'match_comparator-expected_match:', expected_match.toxml()
    # print 'match_comparator-actual_match:', actual_match
    # print 'match_comparator: keywords', keywords

    for child in expected_match.childNodes:
        if child.nodeType is expected_match.TEXT_NODE:
            continue
        
        comparator = MATCH_COMPARATORS.get(child.nodeName,
                                           MATCH_COMPARATORS['default'])
        comparator(child, actual_match, match_keywords)


def actions_comparator(actions, switch_flow):
    # print 'actions_comparator:', actions, switch_flow

    actual_actions = switch_flow['actions'].split(",")
    # print 'actions_comparator:', actual_actions

    for action in actions.childNodes:
        if action.nodeType is actions.TEXT_NODE:
            continue

        action_name = action.childNodes[3].nodeName
        expected_action = action_keywords.get(action_name)

        data = action.toxml(), expected_action
        # print 'actions_comparator:', data

        assert expected_action in actual_actions, 'xml part:\n%s\n expected action: %s' % data


def null_comparator(element, switch_flow):
    pass


def instructions_comparator(instructions_element, switch_flow):
    INSTRUCTION_COMPARATORS = {
        'apply-actions': actions_comparator,
        'default': null_comparator,
    }
    # print 'instructions_comparator:', instructions_element, switch_flow

    instructions = instructions_element.childNodes

    for instruction in instructions_element.childNodes:
        if instruction.nodeType is instructions_element.TEXT_NODE:
            continue
        
        for itype in instruction.childNodes:
            if itype.nodeType is itype.TEXT_NODE:
                continue

            comparator = INSTRUCTION_COMPARATORS.get(itype.nodeName,
                                                     INSTRUCTION_COMPARATORS['default'])
            comparator(itype, switch_flow)


COMPARATORS = {
    'cookie': cookie_comparator,
    'instructions': instructions_comparator,
    'match': match_comparator,
    'default': default_comparator,
}

def all_nodes(xml_root):
    """
    Generates every non-text nodes.
    """
    current_nodes = [xml_root]
    next_nodes = []

    while len(current_nodes) > 0:
        for node in current_nodes:
            if node.nodeType != xml_root.TEXT_NODE:
                yield node
                next_nodes.extend(node.childNodes)

        current_nodes, next_nodes = next_nodes, []


def check_elements(xmlstr, keywords):
    # namespace = 'urn:opendaylight:flow:inventory'
    tree = md.parseString(xmlstr)

    for element in all_nodes(tree.documentElement):
        # switch flow object contains only some data from xml
        if element.nodeName not in keywords:
            # print 'check_elements: element.nodeName', element.nodeName, 'NOT in keywords'
            continue

        yield element

    raise StopIteration()


class TestOpenFlowXMLs(unittest.TestCase):
    @classmethod
    def setUpClass(cls):
        cls.net = create_network(cls.host, cls.mn_port)
        cls.net.start()
        time.sleep(15)

    @classmethod
    def tearDownClass(cls):
        cls.net.stop()


def get_values(node, *tags):
    result = {tag: None for tag in tags}
    for node in all_nodes(node):
        if node.nodeName in result and len(node.childNodes) > 0:
            result[node.nodeName] = node.childNodes[0].nodeValue
    return result


def generate_tests_from_xmls(path, xmls=None):
    # generate test function from path to request xml
    def generate_test(path_to_xml):
        xml_string = ''
        with open(path_to_xml) as f:
            xml_string = f.read()

        tree = md.parseString(xml_string)
        ids = get_values(tree.documentElement, 'table_id', 'id')

        def new_test(self):
            log = logging.getLogger(__name__)
            # send request throught RESTCONF
            data = (self.host, self.port, ids['table_id'], ids['id'])
            url = 'http://%s:%d/restconf/config/opendaylight-inventory:nodes' \
                  '/node/openflow:1/table/%s/flow/%s' % data
            headers = {
                'Content-Type': 'application/xml',
                'Accept': 'application/xml',
            }
            log.info('sending request to url: {}'.format(url))
            rsp = requests.put(url, auth=('admin', 'admin'), data=xml_string,
                               headers=headers)
            log.info('received status code: {}'.format(rsp.status_code))
            log.debug('received content: {}'.format(rsp.text))
            assert rsp.status_code == 204 or rsp.status_code == 200, 'Status' \
                    ' code returned %d' % rsp.status_code

            # check request content against restconf's datastore
            response = requests.get(url, auth=('admin', 'admin'),
                                    headers={'Accept': 'application/xml'})
            assert response.status_code == 200
            req = ET.tostring(ET.fromstring(xml_string))
            res = ET.tostring(ET.fromstring(response.text))
            assert req == res, 'uploaded and stored xml, are not the same\n' \
                'uploaded: %s\nstored:%s' % (req, res)

            # collect flow table state on switch
            switch_flows = get_flows(self.net)
            assert len(switch_flows) > 0

            # compare requested object and flow table state
            for important_element in check_elements(xml_string, keywords):
                # log.info('important element: {}'.format(important_element.nodeName))
                comparator = COMPARATORS.get(important_element.nodeName,
                                             COMPARATORS['default'])

                comparator(important_element, switch_flows[0])

        return new_test

    # generate list of available xml requests
    xmlfiles = None
    if xmls is not None:
        xmlfiles = ('f%d.xml' % fid for fid in xmls)
    else:
        xmlfiles = (xml for xml in os.listdir(path) if xml.endswith('.xml'))

    # define key getter for sorting
    def get_test_number(test_name):
        return int(test_name[1:-4])

    for xmlfile in xmlfiles:
        test_name = 'test_xml_%04d' % get_test_number(xmlfile)
        setattr(TestOpenFlowXMLs,
                test_name,
                generate_test(os.path.join(path, xmlfile)))


if __name__ == '__main__':
    # set up logging
    logging.basicConfig(level=logging.DEBUG)

    # parse cmdline arguments
    parser = argparse.ArgumentParser(description='Run switch <-> ODL tests '
                                     'defined by xmls.')
    parser.add_argument('--odlhost', default='127.0.0.1', help='host where '
                        'odl controller is running')
    parser.add_argument('--odlport', type=int, default=8080, help='port on '
                        'which odl\'s RESTCONF is listening')
    parser.add_argument('--mnport', type=int, default=6653, help='port on '
                        'which odl\'s controller is listening')
    parser.add_argument('--xmls', default=None, help='generete tests only '
                        'from some xmls (i.e. 1,3,34) ')
    args = parser.parse_args()

    # set host and port of ODL controller for test cases
    TestOpenFlowXMLs.port = args.odlport
    TestOpenFlowXMLs.host = args.odlhost
    TestOpenFlowXMLs.mn_port = args.mnport

    keywords = None
    with open('keywords.csv') as f:
        keywords = dict(line.strip().split(';') for line in f
                        if not line.startswith('#'))

    match_keywords = None
    with open('match-keywords.csv') as f:
        match_keywords = dict(line.strip().split(';') for line in f
                              if not line.startswith('#'))

    action_keywords = None
    with open('action-keywords.csv') as f:
        action_keywords = dict(line.strip().split(';') for line in f
                                    if not line.startswith('#'))

    # fix arguments for unittest
    del sys.argv[1:]

    # generate tests for TestOpenFlowXMLs
    if args.xmls is not None:
        xmls = map(int, args.xmls.split(','))
        generate_tests_from_xmls('xmls', xmls)
    else:
        generate_tests_from_xmls('xmls')

    # run all tests
    unittest.main()