"""
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/>.
"""
"""
    Wrapper function for SCPFswitchLat test
    Assign switch and capture openflow package
    remove switch and caputer openflow package
    calculate latency
"""
import time
import json


def getTimestampFromLog( index, searchTerm ):
    """
    Get timestamp value of the search term from log.
    Args:
        index: the index of cli
        searchTerm: the key term of timestamp

    """
    lines = main.Cluster.active( index ).CLI.logSearch( mode='last', searchTerm=searchTerm )
    try:
        assert lines is not None
        logString = lines[ len( lines ) - 1 ]
        # get the target value
        line = logString.split( "time = " )
        key = line[ 1 ].split( " " )
        return int( key[ 0 ] )
    except IndexError:
        main.log.warn( "Index Error!" )
        return 0
    except AssertionError:
        main.log.warn( "Search Term Not Found" )
        return 0


def processPackage( package ):
    """
    split package information to dictionary
    Args:
        package: Package String

    """
    pacakge = package.strip().split( " " )
    dic = {}
    for s in pacakge:
        try:
            [ key, value ] = s.split( "=" )
            dic[ key ] = value
        except:
            continue
    return dic


def findSeqBySeqAck( seq, packageList ):
    """
    Find specific Seq of package in packageList
    Args:
        seq: seq from last TCP package
        packageList: find package in packageList

    """
    for l in packageList:
        temp = processPackage( l )
        tA = temp[ 'Ack' ]
        if int( seq ) + 1 == int( tA ):
            return temp[ 'Seq' ]


def arrangeTsharkFile( switchStatus, keyTerm ):
    """
    Arrange different tshark messeage from overall file to different specific files
    Args:
        switchStatus: switch up or down
        keyTerm: A dictionary that store the path name as value and the searchTerm as key

    """
    with open( main.tsharkResultPath[ switchStatus ][ 'ALL' ], 'r' ) as resultFile:
        resultText = resultFile.readlines()
        resultFile.close()

    for line in resultText:
        for term in keyTerm:
            if term in line:
                # Exclude non-openflow FIN packets
                if term == "[FIN, ACK]" and "6653" not in line:
                    continue
                path = '/tmp/Tshark_' + str( keyTerm[ term ] )
                with open( path, 'a' ) as outputfile:
                    outputfile.write( line )
                    outputfile.close()


def checkResult( result1, result2, result3 ):
    """
    Check if the inputs meet the requirement
    Returns:
            1 means the results are right, 0 means the results are wrong

    """
    result = check( result1 ) + check( result2 ) + check( result3 )
    if result < 3:
        # if any result is wrong, increase the main wrong number
        main.wrong[ 'checkResultIncorrect' ] += 1
        main.wrong[ 'totalWrong' ] += 1
        checkTotalWrongNum()
        return 0
    return 1


def check( result ):
    """
    Check the single input.
    Returns:
            1 means the input is good, 0 means the input is wrong

    """
    if result < int( main.resultRange[ 'Min' ] ) or result > int( main.resultRange[ 'Max' ] ):
        main.log.warn( str( result ) + " is not meet the requirement" )
        return 0
    return 1


def checkTotalWrongNum():
    """
    Check if the total wrong number is bigger than the max wrong number. If it is, then exit the
    test.

    """
    # if there are too many wrongs in this test, then exit
    if main.wrong[ 'totalWrong' ] > main.maxWrong:
        main.log.error( "The total wrong number exceeds %d, test terminated" % main.maxWrong )
        main.cleanAndExit()


def captureOfPack( main, deviceName, ofPack, switchStatus, resultDict, warmup, tsharkInterface ):
    """
    Args:
        main: TestON class
        deviceName: device name
        ofPack: openflow package key word
        switchStatus: Up -- assign, down -- remove
        resultDict: dictionary to contain result
        warmup: warm up boolean

    """
    main.log.debug( "TOTAL WRONG: " + str( main.wrong ) )
    for d in ofPack[ switchStatus ]:
        main.log.info( "Clean up Tshark" )
        with open( main.tsharkResultPath[ switchStatus ][ d ], "w" ) as tshark:
            tshark.write( "" )
    # use one tshark to grep everything
    # Get the grep string
    grepString = ''
    keyTerm = {}
    for d in ofPack[ switchStatus ]:
        grepString = grepString + ofPack[ switchStatus ][ d ] + '|'
        # get rid of regular experssion format
        cleanTerm = ofPack[ switchStatus ][ d ].replace( '\\', '' )
        keyTerm[ cleanTerm ] = d
    # Delete the last '|'
    grepString = grepString[ :-1 ]
    # open tshark
    main.log.info( "starting tshark capture" )
    main.ONOSbench.tsharkGrep( grepString, main.tsharkResultPath[ switchStatus ][ 'ALL' ], interface=tsharkInterface, grepOptions='-E' )
    if switchStatus == 'up':
        # if up, assign switch to controller
        time.sleep( main.measurementSleep )
        main.log.info( 'Assigning {} to controller'.format( deviceName ) )
        main.Mininet1.assignSwController( sw=deviceName, ip=main.Cluster.active( 0 ).ipAddress )
        time.sleep( main.measurementSleep )
    if switchStatus == 'down':
        # if down, remove switch from topology
        time.sleep( main.measurementSleep )
        main.step( 'Remove switch from controler' )
        main.Mininet1.deleteSwController( deviceName )
        time.sleep( main.deleteSwSleep )
    main.log.info( "Stopping all Tshark processes" )
    main.ONOSbench.tsharkStop()
    tempResultDict = {}
    arrangeTsharkFile( switchStatus, keyTerm )

    if switchStatus == 'up':
        for d in main.tsharkResultPath[ 'up' ]:
            with open( main.tsharkResultPath[ switchStatus ][ d ], "r" ) as resultFile:
                # grep tshark result timestamp
                resultText = resultFile.readlines()
                if not resultText:
                    main.log.warn( "Empty tshark result!" )
                    main.wrong[ 'TsharkValueIncorrect' ] += 1
                    main.wrong[ 'totalWrong' ] += 1
                    checkTotalWrongNum()
                    return
                if d == "TCP":
                    # if TCP package, we should use the latest one package
                    resultText = resultText[ len( resultText ) - 1 ]
                else:
                    resultText = resultText[ 0 ]
                main.log.info( "Capture result:" + resultText )
                resultText = resultText.strip()
                resultText = resultText.split( " " )
                if len( resultText ) > 1:
                    tempResultDict[ d ] = int( ( float( resultText[ 1 ] ) * 1000 ) )
                resultFile.close()
    elif switchStatus == 'down':
        # if state is down, we should capture Fin/Ack and ACK package
        # Use seq number in FIN/ACK package to located ACK package
        with open( main.tsharkResultPath[ 'down' ][ 'FA' ], 'r' ) as resultFile:
            resultText = resultFile.readlines()
            FinAckText = resultText.pop( 0 )
            resultFile.close()
        FinAckSeq = processPackage( FinAckText )[ 'Seq' ]
        FinAckOFseq = findSeqBySeqAck( FinAckSeq, resultText )
        if FinAckOFseq is None:
            main.log.warn( "Tshark Result was incorrect!" )
            main.log.warn( resultText )
            main.wrong[ 'TsharkValueIncorrect' ] += 1
            main.wrong[ 'totalWrong' ] += 1
            checkTotalWrongNum()
            return
        with open( main.tsharkResultPath[ 'down' ][ 'ACK' ], "r" ) as resultFile:
            ACKlines = resultFile.readlines()
            resultFile.close()
        AckPackage = ""
        for l in ACKlines:
            temp = processPackage( l )
            finSeq = findSeqBySeqAck( FinAckOFseq, ACKlines )
            if temp[ 'Seq' ] == finSeq:
                AckPackage = l
        if len( AckPackage ) > 0:
            FinAckText = FinAckText.strip()
            FinAckText = FinAckText.split( " " )
            AckPackage = AckPackage.strip()
            AckPackage = AckPackage.split( " " )
            tempResultDict[ 'ACK' ] = int( float( AckPackage[ 1 ] ) * 1000 )
            tempResultDict[ 'FA' ] = int( float( FinAckText[ 1 ] ) * 1000 )
        else:
            main.wrong[ 'skipDown' ] += 1
            main.wrong[ 'totalWrong' ] += 1
            checkTotalWrongNum()
            return

    # calculate latency
    if switchStatus == "up":
        # up Latency
        for d in resultDict[ switchStatus ]:
            T_Ftemp = 0
            try:
                T_Ftemp = tempResultDict[ 'Feature' ] - tempResultDict[ 'TCP' ]
            except KeyError:
                main.log.warn( "Tshark Result was incorrect!" )
                main.log.warn( tempResultDict )
                main.wrong[ 'TsharkValueIncorrect' ] += 1
                main.wrong[ 'totalWrong' ] += 1
                checkTotalWrongNum()
                return
            if not warmup:
                resultDict[ switchStatus ][ d ][ 'T_F' ].append( T_Ftemp )

            main.log.info( "{} TCP to Feature: {}".format( d, str( T_Ftemp ) ) )

        for i in range( 1, main.Cluster.numCtrls + 1 ):
            F_Dtemp = 0
            D_Gtemp = 0
            E_Etemp = 0
            main.log.info( "================================================" )
            # get onos metrics timestamps
            try:
                response = json.loads( main.Cluster.active( i - 1 ).CLI.topologyEventsMetrics() )

                # Just to show the other event times.
                main.log.info( "ONOS{} device Event timestamp: {}".format(
                    i, int( response.get( "topologyDeviceEventTimestamp" ).get( "value" ) ) ) )
                main.log.info( "ONOS{} graph reason Event timestamp: {}".format(
                    i, int( response.get( "topologyGraphReasonsEventTimestamp" ).get( "value" ) ) ) )

                DeviceTime = getTimestampFromLog( i - 1, searchTerm=main.searchTerm[ switchStatus ] )
                main.log.info( "ONOS{} device from karaf log: {}".format( i, DeviceTime ) )
                GraphTime = int( response.get( "topologyGraphEventTimestamp" ).get( "value" ) )
                main.log.info( "ONOS{} Graph Event timestamp: {}".format( i, GraphTime ) )
            except TypeError:
                main.log.warn( "TypeError" )
                main.wrong[ 'TypeError' ] += 1
                main.wrong[ 'totalWrong' ] += 1
                checkTotalWrongNum()
                break
            except ValueError:
                main.log.warn( "Error to decode Json object!" )
                main.wrong[ 'decodeJasonError' ] += 1
                main.wrong[ 'totalWrong' ] += 1
                checkTotalWrongNum()
                break
            if DeviceTime != 0:
                try:
                    F_Dtemp = DeviceTime - tempResultDict[ 'Feature' ]
                    D_Gtemp = GraphTime - DeviceTime
                    E_Etemp = GraphTime - tempResultDict[ 'TCP' ]
                    check = checkResult( F_Dtemp, D_Gtemp, E_Etemp )
                    if check == 1:
                        main.log.info( "Feature to Device:{}".format( F_Dtemp ) )
                        main.log.info( "Device to Graph:{}".format( D_Gtemp ) )
                        main.log.info( "End to End:{}".format( E_Etemp ) )
                        main.log.info( "================================================" )
                except KeyError:
                    main.log.warn( "Tshark Result was incorrect!" )
                    main.log.warn( tempResultDict )
                    main.wrong[ 'TsharkValueIncorrect' ] += 1
                    main.wrong[ 'totalWrong' ] += 1
                    checkTotalWrongNum()
                    return
                except TypeError:
                    main.log.warn( "TypeError" )
                    main.wrong[ 'TypeError' ] += 1
                    main.wrong[ 'totalWrong' ] += 1
                    checkTotalWrongNum()
                    break
                except ValueError:
                    main.log.warn( "Error to decode Json object!" )
                    main.wrong[ 'decodeJasonError' ] += 1
                    main.wrong[ 'totalWrong' ] += 1
                    checkTotalWrongNum()
                    break
                if not warmup and check == 1:
                    resultDict[ switchStatus ][ 'node' + str( i ) ][ 'F_D' ].append( F_Dtemp )
                    resultDict[ switchStatus ][ 'node' + str( i ) ][ 'D_G' ].append( D_Gtemp )
                    resultDict[ switchStatus ][ 'node' + str( i ) ][ 'E_E' ].append( E_Etemp )
            else:
                main.wrong[ 'checkResultIncorrect' ] += 1
                main.wrong[ 'totalWrong' ] += 1
                checkTotalWrongNum()
                main.log.debug( "Skip this iteration due to the None Devicetime" )

    if switchStatus == "down":
        # down Latency
        for d in resultDict[ switchStatus ]:
            FA_Atemp = 0
            try:
                FA_Atemp = tempResultDict[ 'ACK' ] - tempResultDict[ 'FA' ]
            except KeyError:
                main.log.warn( "Tshark Result was incorrect!" )
                main.log.warn( tempResultDict )
                main.wrong[ 'TsharkValueIncorrect' ] += 1
                main.wrong[ 'totalWrong' ] += 1
                checkTotalWrongNum()
                return
            if not warmup:
                resultDict[ switchStatus ][ d ][ 'FA_A' ].append( FA_Atemp )
            main.log.info( "{} FIN/ACK TO ACK {}:".format( d, FA_Atemp ) )
        for i in range( 1, main.Cluster.numCtrls + 1 ):
            A_Dtemp = 0
            D_Gtemp = 0
            E_Etemp = 0
            main.log.info( "================================================" )
            # get onos metrics timestamps
            try:
                response = json.loads( main.Cluster.active( i - 1 ).CLI.topologyEventsMetrics() )
                # Just to show the other event times.
                main.log.info( "ONOS{} device Event timestamp: {}".format(
                    i, int( response.get( "topologyDeviceEventTimestamp" ).get( "value" ) ) ) )
                main.log.info( "ONOS{} graph reason Event timestamp: {}".format(
                    i, int( response.get( "topologyGraphReasonsEventTimestamp" ).get( "value" ) ) ) )

                DeviceTime = getTimestampFromLog( i - 1, searchTerm=main.searchTerm[ switchStatus ] )
                main.log.info( "ONOS{} device from karaf log: {}".format( i, DeviceTime ) )
                GraphTime = int( response.get( "topologyGraphEventTimestamp" ).get( "value" ) )
                main.log.info( "ONOS{} Graph Event timestamp: {}".format( i, GraphTime ) )
            except TypeError:
                main.log.warn( "TypeError" )
                main.wrong[ 'TypeError' ] += 1
                main.wrong[ 'totalWrong' ] += 1
                checkTotalWrongNum()
                break
            except ValueError:
                main.log.warn( "Error to decode Json object!" )
                main.wrong[ 'decodeJasonError' ] += 1
                main.wrong[ 'totalWrong' ] += 1
                checkTotalWrongNum()
                break
            if DeviceTime != 0:
                main.log.info( "================================================" )
                try:
                    A_Dtemp = DeviceTime - tempResultDict[ 'ACK' ]
                    D_Gtemp = GraphTime - DeviceTime
                    E_Etemp = GraphTime - tempResultDict[ 'FA' ]
                    check = checkResult( A_Dtemp, D_Gtemp, E_Etemp )
                    if check == 1:
                        main.log.info( "ACK to device: {}".format( A_Dtemp ) )
                        main.log.info( "Device to Graph: {}".format( D_Gtemp ) )
                        main.log.info( "End to End: {}".format( E_Etemp ) )
                        main.log.info( "================================================" )
                except KeyError:
                    main.log.warn( "Tshark Result was incorrect!" )
                    main.log.warn( tempResultDict )
                    main.wrong[ 'TsharkValueIncorrect' ] += 1
                    main.wrong[ 'totalWrong' ] += 1
                    checkTotalWrongNum()
                    return
                except TypeError:
                    main.log.warn( "TypeError" )
                    main.wrong[ 'TypeError' ] += 1
                    main.wrong[ 'totalWrong' ] += 1
                    checkTotalWrongNum()
                    break
                except ValueError:
                    main.log.warn( "Error to decode Json object!" )
                    main.wrong[ 'decodeJasonError' ] += 1
                    main.wrong[ 'totalWrong' ] += 1
                    checkTotalWrongNum()
                    break
                if not warmup and check == 1:
                    resultDict[ switchStatus ][ 'node' + str( i ) ][ 'A_D' ].append( A_Dtemp )
                    resultDict[ switchStatus ][ 'node' + str( i ) ][ 'D_G' ].append( D_Gtemp )
                    resultDict[ switchStatus ][ 'node' + str( i ) ][ 'E_E' ].append( E_Etemp )

            else:
                main.wrong[ 'checkResultIncorrect' ] += 1
                main.wrong[ 'totalWrong' ] += 1
                checkTotalWrongNum()
                main.log.debug( "Skip this iteration due to the None Devicetime" )