"""
Copyright 2016 Open Networking Foundation (ONF)

Please refer questions to either the onos test mailing list at <onos-test@onosproject.org>,
the System Testing Plans and Results wiki page at <https://wiki.onosproject.org/x/voMg>,
or the System Testing Guide page at <https://wiki.onosproject.org/x/WYQg>

    TestON is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 2 of the License, or
    (at your option) any later version.

    TestON is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with TestON.  If not, see <http://www.gnu.org/licenses/>.
"""

"""
    SCPFhostLat
    This test will test the host found latency.
    Host will arping a ip address, tshark will caputure the package time, then compare with the topology event timestamp.
    Test will run with 1 node from start, and scale up to 7 nodes.
    The event timestamp will only greb the latest one, then calculate average and standar dev.

    yunpeng@onlab.us
"""
class SCPFhostLat:

    def __init__( self ):
        self.default = ''

    def CASE0( self, main ):
        import sys
        import json
        import time
        import os
        import imp
        try:
            from tests.dependencies.ONOSSetup import ONOSSetup
            main.testSetUp = ONOSSetup()
        except ImportError:
            main.log.error( "ONOSSetup not found. exiting the test" )
            main.exit()
        main.testSetUp.envSetupDescription()
        stepResult = main.FALSE
        try:

            # Test variables
            main.cellName = main.params[ 'ENV' ][ 'cellName' ]
            main.apps = main.params[ 'ENV' ][ 'cellApps' ]
            main.scale = ( main.params[ 'SCALE' ] ).split( "," )
            main.ONOSport = main.params[ 'CTRL' ][ 'port' ]
            main.startUpSleep = int( main.params[ 'SLEEP' ][ 'startup' ] )
            main.installSleep = int( main.params[ 'SLEEP' ][ 'install' ] )
            main.measurementSleep = int( main.params[ 'SLEEP' ][ 'measurement' ] )
            main.timeout = int( main.params[ 'SLEEP' ][ 'timeout' ] )
            main.dbFileName = main.params[ 'DATABASE' ][ 'file' ]

            # Tshark params
            main.tsharkResultPath = main.params[ 'TSHARK' ][ 'tsharkPath' ]
            main.tsharkPacketIn = main.params[ 'TSHARK' ][ 'tsharkPacketIn' ]

            main.numlter = main.params[ 'TEST' ][ 'numIter' ]
            main.iterIgnore = int( main.params[ 'TEST' ][ 'iterIgnore' ] )
            main.hostTimestampKey = main.params[ 'TEST' ][ 'hostTimestamp' ]
            main.thresholdStr = main.params[ 'TEST' ][ 'singleSwThreshold' ]
            main.thresholdObj = main.thresholdStr.split( ',' )
            main.thresholdMin = int( main.thresholdObj[ 0 ] )
            main.thresholdMax = int( main.thresholdObj[ 1 ] )
            main.threadID = 0

            main.maxNumBatch = 0
            main.setupSkipped = False

            main.nic = main.params[ 'DATABASE' ][ 'nic' ]
            node = main.params[ 'DATABASE' ][ 'node' ]
            stepResult = main.TRUE

            main.log.info( "Cresting DB file" )
            with open( main.dbFileName, "w+" ) as dbFile:
                dbFile.write( "" )
            stepResult = main.testSetUp.envSetup()
        except Exception as e:
            main.testSetUp.envSetupException( e )
        main.testSetUp.evnSetupConclusion( stepResult )

        main.commit = main.commit.split( " " )[ 1 ]

    def CASE2( self, main ):
        """
        - Uninstall ONOS cluster
        - Verify ONOS start up
        - Install ONOS cluster
        - Connect to cli
        """
        main.testSetUp.ONOSSetUp( main.Mininet1, main.Cluster, True,
                                  cellName=main.cellName, killRemoveMax=False )

    def CASE11( self, main ):
        main.log.info( "set and configure Application" )
        import json
        import time
        time.sleep( main.startUpSleep )
        main.step( "Activating org.onosproject.proxyarp" )
        appStatus = utilities.retry( main.Cluster.active( 0 ).REST.activateApp,
                                     main.FALSE,
                                     [ 'org.onosproject.proxyarp' ],
                                     sleep=3,
                                     attempts=3 )
        utilities.assert_equals( expect=main.TRUE,
                                 actual=appStatus,
                                 onpass="Successfully activated proxyarp",
                                 onfail="Failed to activated proxyarp" )

        main.step( "Set up Default Topology Provider" )
        appStatus = main.TRUE
        configName = 'org.onosproject.net.topology.impl.DefaultTopologyProvider'
        configParam = 'maxEvents'
        appStatus = appStatus and main.Cluster.active( 0 ).CLI.setCfg( configName, configParam, '1' )
        configParam = 'maxBatchMs'
        appStatus = appStatus and main.Cluster.active( 0 ).CLI.setCfg( configName, configParam, '0' )
        configParam = 'maxIdleMs'
        appStatus = appStatus and main.Cluster.active( 0 ).CLI.setCfg( configName, configParam, '0' )
        utilities.assert_equals( expect=main.TRUE,
                                 actual=appStatus,
                                 onpass="Successfully set DefaultTopologyProvider",
                                 onfail="Failed to set DefaultTopologyProvider" )

        time.sleep( main.startUpSleep )
        main.step( 'Starting mininet topology' )
        mnStatus = main.Mininet1.startNet( args='--topo=linear,1' )
        utilities.assert_equals( expect=main.TRUE,
                                 actual=mnStatus,
                                 onpass="Successfully started Mininet",
                                 onfail="Failed to activate Mininet" )
        main.step( "Assinging masters to switches" )
        switches = main.Mininet1.getSwitches()
        swStatus = main.Mininet1.assignSwController( sw=switches.keys(),
                                                     ip=main.Cluster.active( 0 ).ipAddress )
        utilities.assert_equals( expect=main.TRUE,
                                 actual=swStatus,
                                 onpass="Successfully assigned switches to masters",
                                 onfail="Failed assign switches to masters" )

        time.sleep( main.startUpSleep )

    def CASE20( self, main ):
        """
        host1 send arping package and measure latency

        There are only 1 levels of latency measurements to this test:
        1 ) ARPING-to-device measurement: Measurement the time from host1
        send apring package to onos processing the host event

        """
        import time
        import subprocess
        import json
        import requests
        import os
        import numpy
        try:
            from tests.dependencies.utils import Utils
        except ImportError:
            main.log.error( "Utils not found exiting the test" )
            main.exit()
        try:
            main.Utils
        except ( NameError, AttributeError ):
            main.Utils = Utils()
        # Host adding measurement
        assertion = main.TRUE

        main.log.report( 'Latency of adding one host to ONOS' )
        main.log.report( 'First ' + str( main.iterIgnore ) + ' iterations ignored' + ' for jvm warmup time' )
        main.log.report( 'Total iterations of test: ' + str( main.numlter ) )

        addingHostTime = []
        metricsResultList = []
        for i in range( 0, int( main.numlter ) ):
            main.log.info( 'Clean up data file' )
            with open( main.tsharkResultPath, "w" ) as dbFile:
                dbFile.write( "" )

            main.log.info( 'Starting tshark capture' )
            main.ONOSbench.tsharkGrep( main.tsharkPacketIn, main.tsharkResultPath )
            time.sleep( main.measurementSleep )

            main.log.info( 'host 1 arping...' )
            main.Mininet1.arping( srcHost='h1', dstHost='10.0.0.2' )

            time.sleep( main.measurementSleep )

            main.log.info( 'Stopping all Tshark processes' )
            main.ONOSbench.tsharkStop()

            time.sleep( main.measurementSleep )

            # Get tshark output
            with open( main.tsharkResultPath, "r" ) as resultFile:
                resultText = resultFile.readline()
                main.log.info( 'Capture result:' + resultText )
                resultText = resultText.split( ' ' )
                if len( resultText ) > 1:
                    tsharkResultTime = float( resultText[ 1 ] ) * 1000.0
                else:
                    main.log.error( 'Tshark output file for packet_in' + ' returned unexpected results' )
                    hostTime = 0
                    caseResult = main.FALSE
                resultFile.close()
            # Compare the timestemps, and get the lowest one.
            temp = 0;
            # Get host event timestamps from each nodes
            for ctrl in main.Cluster.active():
                metricsResult = json.loads( ctrl.CLI.topologyEventsMetrics() )
                metricsResult = metricsResult.get( main.hostTimestampKey ).get( "value" )
                main.log.info( "ONOS topology event matrics timestemp: {}".format( str( metricsResult ) ) )

                if temp < metricsResult:
                    temp = metricsResult
                metricsResult = temp

            addingHostTime.append( float( metricsResult ) - tsharkResultTime )
            main.log.info( "Result of this iteration: {}".format( str( float( metricsResult ) - tsharkResultTime ) ) )
            # gethost to remove
            gethost = main.Cluster.active( 0 ).REST.hosts()
            HosttoRemove = []
            HosttoRemove.append( json.loads( gethost[ 1:len( gethost )-1 ] ).get( 'id' ) )
            main.Cluster.active( 0 ).CLI.removeHost( HosttoRemove )

        main.log.info( "Result List: {}".format( addingHostTime ) )

        # calculate average latency from each nodes
        averageResult = numpy.average( addingHostTime )
        main.log.info( "Average Latency: {}".format( averageResult ) )

        # calculate std
        stdResult = numpy.std( addingHostTime )
        main.log.info( "std: {}".format( stdResult ) )

        # write to DB file
        main.log.info( "Writing results to DS file" )
        with open( main.dbFileName, "a" ) as dbFile:
            temp = "'" + main.commit + "',"
            temp += "'" + main.nic + "',"
            # Scale number
            temp += str( main.Cluster.numCtrls )
            temp += ",'" + "baremetal1" + "'"
            # average latency
            temp += "," + str( averageResult )
            # std of latency
            temp += "," + str( stdResult )
            temp += "\n"
            dbFile.write( temp )

        assertion = main.TRUE

        utilities.assert_equals( expect=main.TRUE, actual=assertion,
                onpass='Host latency test successful',
                onfail='Host latency test failed' )

        main.Utils.mininetCleanup( main.Mininet1 )