##############################################################################
# Copyright (c) 2015 Huawei Technologies Co.,Ltd and others.
#
# All rights reserved. This program and the accompanying materials
# are made available under the terms of the Apache License, Version 2.0
# which accompanies this distribution, and is available at
# http://www.apache.org/licenses/LICENSE-2.0
##############################################################################


import time
from spirent import stcPython


class Spirent_Tools(object):
    baseAPI = stcPython()

    def __init__(self):
        """This class provide API of Spirent

        """
        super(Spirent_Tools, self).__init__()

    def send_packet(self, flow):
        try:
            #import pdb
            # pdb.set_trace()
            flow = eval(flow)
            # stc init action
            self.baseAPI.stc_perform(' ResetConfig -config system1')
            self.baseAPI.stc_init()
            # create project
            project = self.baseAPI.stc_create_project()
            # create port
            port_handle = self.baseAPI.stc_create_port(project)
            # config port
            slot = flow['send_port'].split('/')[0]
            port = flow['send_port'].split('/')[1]
            self.baseAPI.stc_config_port_location(
                port_handle, flow['tester_ip'], slot, port)
            # create streamblock
            streamblock_handle = self.baseAPI.stc_create_streamblock(
                port_name=port_handle,
                ExpectedRxPort='',
                vlan_tag=flow['vlan'],
                srcMac=flow['src_mac'],
                dstMac=flow['dst_mac'],
                sourceAddr=flow['src_ip'],
                destAddr=flow['dst_ip']
            )
            # attach port
            port_list = [port_handle]
            self.baseAPI.stc_attach_ports(port_list)
            # start streamblock
            streamblock_list = [streamblock_handle]
            flag = self.baseAPI.stc_streamblock_start(streamblock_list)
            return str(streamblock_list).strip('[]')
        except:
            print("[ERROR]create stream block and send packet failed.")
            return False

    def mac_learning(self, flowA, flowB):
        try:
            #import pdb
            # pdb.set_trace()
            flowA = eval(flowA)
            flowB = eval(flowB)
            port_list = []
            streamblock_list = []
            # stc init action
            self.baseAPI.stc_perform(' ResetConfig -config system1')
            self.baseAPI.stc_init()
            # create project
            project = self.baseAPI.stc_create_project()
            # create port and config port
            for flow in [flowA, flowB]:
                flow['port_handle'] = self.baseAPI.stc_create_port(project)
                tmp_test_ip = flow['tester_ip']
                tmp_slot = flow['send_port'].split('/')[0]
                tmp_port = flow['send_port'].split('/')[1]
                self.baseAPI.stc_config_port_location(
                    flow['port_handle'], tmp_test_ip, tmp_slot, tmp_port)
                # create streamblock
                flow['streamblock'] = self.baseAPI.stc_create_streamblock(
                    port_name=flow['port_handle'],
                    ExpectedRxPort='',
                    vlan_tag=flow['vlan'],
                    srcMac=flow['src_mac'],
                    dstMac=flow['dst_mac'],
                    sourceAddr=flow['src_ip'],
                    destAddr=flow['dst_ip'])
                # create port and stream block list
                port_list.append(flow['port_handle'])
                streamblock_list.append(flow['streamblock'])

            # attach port
            self.baseAPI.stc_attach_ports(port_list)
            # start streamblock
            flag = self.baseAPI.stc_streamblock_start(streamblock_list)
            # mac learning
            time.sleep(2)
            # stop stream block
            self.baseAPI.stc_streamblock_stop(streamblock_list)
            # delete streamblock and release port
            for flow in [flowA, flowB]:
                tmp_test_ip = flow['tester_ip']
                tmp_slot = flow['send_port'].split('/')[0]
                tmp_port = flow['send_port'].split('/')[1]
                self.baseAPI.stc_delete(flow['streamblock'])
                self.baseAPI.stc_release(
                    '%s/%s/%s' %
                    (tmp_test_ip, tmp_slot, tmp_port))
            # delete project
            self.baseAPI.stc_delete('project1')
            ret = self.baseAPI.stc_perform('ResetConfig -config system1')
            return True
        except:
            print("[ERROR]mac learning failed")
            return False

    def stop_flow(self, streamblock_list, flow):
        flow = eval(flow)
        streamblock_list = streamblock_list.strip('\'').split(',')
        # stop streamblock list
        try:
            ret = self.baseAPI.stc_streamblock_stop(streamblock_list)
        except:
            print("[ERROR]Stop the streamblock list failed.")
            return False
        # delete streamblock
        try:
            for streamblock in streamblock_list:
                ret = self.baseAPI.stc_delete(streamblock)
        except:
            print("[ERROR]delete stream block.")
            return False
        # release port
        try:
            slot = flow['send_port'].split('/')[0]
            port = flow['send_port'].split('/')[1]
            ret = self.baseAPI.stc_release(
                '%s/%s/%s' %
                (flow['tester_ip'], slot, port))
        except:
            print("[ERROR]Release port failed")
            return False
        # delete project
        try:
            ret = self.baseAPI.stc_delete('project1')
            ret = self.baseAPI.stc_perform('ResetConfig -config system1')
            return True
        except:
            print("[ERROR]Delete project1 failed.")
            return False

    def run_rfc2544_throughput(self, forward_init_flows, reverse_init_flows):
        #import pdb
        # pdb.set_trace()
        # rebuild the flows
        forward_init_flows = eval(forward_init_flows)
        reverse_init_flows = eval(reverse_init_flows)
        # stc init action
        self.baseAPI.stc_perform(' ResetConfig -config system1')
        self.baseAPI.stc_init()
        # create project
        project = self.baseAPI.stc_create_project()
        # create sequencer
        seq_handle = self.baseAPI.stc_create('Sequencer -under %s' % (project))
        # create port handle
        forward_port_handle = self.baseAPI.stc_create_port(project)
        reverse_port_handle = self.baseAPI.stc_create_port(project)
        # create forward flow streamblock
        for key in forward_init_flows.keys():
            forward_init_flows[key]['port_handle'] = forward_port_handle
            tmp_test_ip = forward_init_flows[key]['tester_ip']
            tmp_slot = forward_init_flows[key]['send_port'].split('/')[0]
            tmp_port = forward_init_flows[key]['send_port'].split('/')[1]
            self.baseAPI.stc_config_port_location(
                forward_init_flows[key]['port_handle'], tmp_test_ip, tmp_slot, tmp_port)
            # create streamblock
            forward_init_flows[key]['streamblock'] = self.baseAPI.stc_create_streamblock(
                port_name=forward_init_flows[key]['port_handle'],
                vlan_tag=forward_init_flows[key]['vlan'],
                ExpectedRxPort=reverse_port_handle,
                srcMac=forward_init_flows[key]['src_mac'],
                dstMac=forward_init_flows[key]['dst_mac'],
                sourceAddr=forward_init_flows[key]['src_ip'],
                destAddr=forward_init_flows[key]['dst_ip'])
        # create reverse flow streamblock
        for key in reverse_init_flows.keys():
            reverse_init_flows[key]['port_handle'] = reverse_port_handle
            tmp_test_ip = reverse_init_flows[key]['tester_ip']
            tmp_slot = reverse_init_flows[key]['send_port'].split('/')[0]
            tmp_port = reverse_init_flows[key]['send_port'].split('/')[1]
            self.baseAPI.stc_config_port_location(
                reverse_init_flows[key]['port_handle'], tmp_test_ip, tmp_slot, tmp_port)
            # create streamblock
            reverse_init_flows[key]['streamblock'] = self.baseAPI.stc_create_streamblock(
                port_name=reverse_init_flows[key]['port_handle'],
                vlan_tag=reverse_init_flows[key]['vlan'],
                ExpectedRxPort=forward_port_handle,
                srcMac=reverse_init_flows[key]['src_mac'],
                dstMac=reverse_init_flows[key]['dst_mac'],
                sourceAddr=reverse_init_flows[key]['src_ip'],
                destAddr=reverse_init_flows[key]['dst_ip'])
        # Create the RFC 2544 throughput test
        throughput_config = self.baseAPI.stc_create(
            'Rfc2544ThroughputConfig -under ',
            project,
            '-AcceptableFrameLoss 0.01',
            '-NumOfTrials 1',
            '-DurationSeconds 60',
            '-SearchMode BINARY',
            '-RateLowerLimit 1',
            '-RateUpperLimit 100',
            '-RateInitial 10',
            '-UseExistingStreamBlocks True',
            '-EnableLearning False',
            '-FrameSizeIterationMode CUSTOM',
            '-CustomFrameSizeList "70 128 256 512 1024 1280 1518"',
            '-LatencyType LIFO',
            '-EnableJitterMeasurement TRUE')
        #import pdb
        # pdb.set_trace()
        # list streamblocks
        streamblock_list = '" '
        for key in forward_init_flows.keys():
            streamblock_list = streamblock_list + \
                forward_init_flows[key]['streamblock'] + ' '
        for key in reverse_init_flows.keys():
            streamblock_list = streamblock_list + \
                reverse_init_flows[key]['streamblock'] + ' '
        streamblock_list = streamblock_list + '"'

        throughput_sbProfile = self.baseAPI.stc_create(
            'Rfc2544StreamBlockProfile -under ' +
            throughput_config +
            ' -Active TRUE -LocalActive TRUE')
        self.baseAPI.stc_config(
            throughput_sbProfile,
            '-StreamBlockList ' +
            streamblock_list)
        self.baseAPI.stc_perform(
            'ExpandBenchmarkConfigCommand',
            '-config ',
            throughput_config)

        # attach the port before testing
        port_list = [forward_port_handle, reverse_port_handle]
        self.baseAPI.stc_attach_ports(port_list)

        # stc apply and begin to sequence test
        self.baseAPI.stc_apply()
        self.baseAPI.stc_perform("SequencerStart")

        # wait until complete
        self.baseAPI.stc_waituntilcomplete()

        # get result db
        resultsdb = self.baseAPI.stc_get(
            "system1.project.TestResultSetting",
            "-CurrentResultFileName")
        results_dict = self.baseAPI.stc_perform(
            'QueryResult',
            '-DatabaseConnectionString',
            resultsdb,
            '-ResultPath RFC2544ThroughputTestResultDetailedSummaryView')
        # print results_dict
        return True, results_dict

    def run_rfc2544_frameloss(self, forward_init_flows, reverse_init_flows):
        #import pdb
        # pdb.set_trace()
        # rebuild the flows
        forward_init_flows = eval(forward_init_flows)
        reverse_init_flows = eval(reverse_init_flows)
        # stc init action
        self.baseAPI.stc_perform(' ResetConfig -config system1')
        self.baseAPI.stc_init()
        # create project
        project = self.baseAPI.stc_create_project()
        # create sequencer
        seq_handle = self.baseAPI.stc_create('Sequencer -under %s' % (project))
        # create port handle
        forward_port_handle = self.baseAPI.stc_create_port(project)
        reverse_port_handle = self.baseAPI.stc_create_port(project)
        # create forward flow streamblock
        for key in forward_init_flows.keys():
            forward_init_flows[key]['port_handle'] = forward_port_handle
            tmp_test_ip = forward_init_flows[key]['tester_ip']
            tmp_slot = forward_init_flows[key]['send_port'].split('/')[0]
            tmp_port = forward_init_flows[key]['send_port'].split('/')[1]
            self.baseAPI.stc_config_port_location(
                forward_init_flows[key]['port_handle'], tmp_test_ip, tmp_slot, tmp_port)
            # create streamblock
            forward_init_flows[key]['streamblock'] = self.baseAPI.stc_create_streamblock(
                port_name=forward_init_flows[key]['port_handle'],
                vlan_tag=forward_init_flows[key]['vlan'],
                ExpectedRxPort=reverse_port_handle,
                srcMac=forward_init_flows[key]['src_mac'],
                dstMac=forward_init_flows[key]['dst_mac'],
                sourceAddr=forward_init_flows[key]['src_ip'],
                destAddr=forward_init_flows[key]['dst_ip'])
        # create reverse flow streamblock
        for key in reverse_init_flows.keys():
            reverse_init_flows[key]['port_handle'] = reverse_port_handle
            tmp_test_ip = reverse_init_flows[key]['tester_ip']
            tmp_slot = reverse_init_flows[key]['send_port'].split('/')[0]
            tmp_port = reverse_init_flows[key]['send_port'].split('/')[1]
            self.baseAPI.stc_config_port_location(
                reverse_init_flows[key]['port_handle'], tmp_test_ip, tmp_slot, tmp_port)
            # create streamblock
            reverse_init_flows[key]['streamblock'] = self.baseAPI.stc_create_streamblock(
                port_name=reverse_init_flows[key]['port_handle'],
                vlan_tag=reverse_init_flows[key]['vlan'],
                ExpectedRxPort=forward_port_handle,
                srcMac=reverse_init_flows[key]['src_mac'],
                dstMac=reverse_init_flows[key]['dst_mac'],
                sourceAddr=reverse_init_flows[key]['src_ip'],
                destAddr=reverse_init_flows[key]['dst_ip'])
        # Create the RFC 2544 frameloss test
        frameloss_config = self.baseAPI.stc_create(
            'Rfc2544FrameLossConfig -under ',
            project,
            '-NumOfTrials 1 ',
            '-DurationSeconds 60 ',
            '-LoadUnits PERCENT_LINE_RATE ',
            '-LoadType CUSTOM '
            '-CustomLoadList 100 '
            '-UseExistingStreamBlocks True ',
            '-EnableLearning False ',
            '-FrameSizeIterationMode CUSTOM ',
            '-CustomFrameSizeList "70 128 256 512 1024 1280 1518"',
            '-LatencyType LIFO',
            '-EnableJitterMeasurement TRUE')
        #import pdb
        # pdb.set_trace()
        # list streamblocks
        streamblock_list = '" '
        for key in forward_init_flows.keys():
            streamblock_list = streamblock_list + \
                forward_init_flows[key]['streamblock'] + ' '
        for key in reverse_init_flows.keys():
            streamblock_list = streamblock_list + \
                reverse_init_flows[key]['streamblock'] + ' '
        streamblock_list = streamblock_list + '"'

        frameloss_sbProfile = self.baseAPI.stc_create(
            'Rfc2544StreamBlockProfile -under ' +
            frameloss_config +
            ' -Active TRUE -LocalActive TRUE')
        self.baseAPI.stc_config(
            frameloss_sbProfile,
            '-StreamBlockList ' +
            streamblock_list)
        self.baseAPI.stc_perform(
            'ExpandBenchmarkConfigCommand',
            '-config ',
            frameloss_config)

        # attach the port before testing
        port_list = [forward_port_handle, reverse_port_handle]
        self.baseAPI.stc_attach_ports(port_list)

        # stc apply and begin to sequence test
        self.baseAPI.stc_apply()
        self.baseAPI.stc_perform("SequencerStart")

        # wait until complete
        self.baseAPI.stc_waituntilcomplete()

        # get result db
        resultsdb = self.baseAPI.stc_get(
            "system1.project.TestResultSetting",
            "-CurrentResultFileName")
        results_dict = self.baseAPI.stc_perform(
            'QueryResult',
            '-DatabaseConnectionString',
            resultsdb,
            '-ResultPath RFC2544FrameLossTestResultDetailedSummaryView')
        #import pdb
        # pdb.set_trace()
        return True, results_dict

    def run_rfc2544_latency(self, forward_init_flows, reverse_init_flows):
        pass