#!/usr/bin/python2.7
#
# Copyright (c) 2014-2015, Intel Corporation
# All rights reserved.
#
# Redistribution and use in source and binary forms, with or without modification,
# are permitted provided that the following conditions are met:
#
# 1. Redistributions of source code must retain the above copyright notice, this
# list of conditions and the following disclaimer.
#
# 2. Redistributions in binary form must reproduce the above copyright notice,
# this list of conditions and the following disclaimer in the documentation and/or
# other materials provided with the distribution.
#
# 3. Neither the name of the copyright holder nor the names of its contributors
# may be used to endorse or promote products derived from this software without
# specific prior written permission.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
# ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
# ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
# ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
# SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

import PyPfw

import logging
from decimal import Decimal
from math import log10

class PfwLogger(PyPfw.ILogger):
    def __init__(self):
        super(PfwLogger, self).__init__()
        self.__logger = logging.root.getChild("parameter-framework")

    def log(self, is_warning, message):
        log_func = self.__logger.warning if is_warning else self.__logger.info
        log_func(message)

class FixedPointTester():
    """ Made for testing a particular Qn.m number

    As a convention, we use:
        * n is the fractional part
        * m is the integral part

    This class computes several specific numbers for a given Qn.m number.

    For each of those numbers, we run 4 checks:
        * Bound check
        * Sanity check
        * Consistency check
        * Bijectivity check
    Which are documented below.
    """
    def __init__(self, pfwClient, size, integral, fractional):
        self._pfwClient = pfwClient
        self._paramPath = '/Test/test/%d/q%d.%d' % (size, integral, fractional)

        # quantum is the step we have between two numbers
        # encoded in Qn.m format
        self._quantum = 2 ** -fractional

        # The maximum value we can encode for a given Qn.m.
        # Since we also need to encode the 0, we have one quantum missing on
        # the positive maximum
        self._upperAllowedBound = (2 ** integral) - self._quantum

        # The minimum value that we can encode for a given Qn.m.
        # This one does not need a quantum substraction since we already did
        # that on the maximum
        self._lowerAllowedBound = -(2 ** integral)

        self._shouldWork = [
                Decimal(0),
                Decimal(self._lowerAllowedBound),
                Decimal(self._upperAllowedBound)
                ]

        # bigValue is to be sure a value far out of range is refused
        bigValue = (2 * self._quantum)
        # little is to be sure a value just out of range is refused
        littleValue = 10 ** -(int(fractional * log10(2)))
        self._shouldBreak = [
                Decimal(self._lowerAllowedBound) - Decimal(bigValue),
                Decimal(self._upperAllowedBound) + Decimal(bigValue),
                Decimal(self._lowerAllowedBound) - Decimal(littleValue),
                Decimal(self._upperAllowedBound) + Decimal(littleValue)
                ]

        self._chainingTests = [
                ('Bound', self.checkBounds),
                ('Sanity', self.checkSanity),
                ('Consistency', self.checkConsistency),
                ('Bijectivity', self.checkBijectivity)]


    def run(self):
        """ Runs the test suite for a given Qn.m number
        """

        runSuccess = True

        for value in self._shouldWork:
            value = value.normalize()
            print('Testing %s for %s' % (value, self._paramPath))

            for testName, testFunc in self._chainingTests:
                value, success = testFunc(value)
                if not success:
                    runSuccess = False
                    print("%s ERROR for %s" % (testName, self._paramPath))
                    break

        for value in self._shouldBreak:
            value = value.normalize()
            print('Testing invalid value %s for %s' % (value, self._paramPath))
            value, success = self.checkBounds(value)
            if success:
                runSuccess = False
                print("ERROR: This test should have failed but it has not")

        return runSuccess

    def checkBounds(self, valueToSet):
        """ Checks if we are able to set valueToSet via the parameter-framework

        valueToSet -- the value we are trying to set

        returns: the value we are trying to set
        returns: True if we are able to set, False otherwise
        """
        (success, errorMsg) = self._pfwClient.set(self._paramPath, str(valueToSet))

        return valueToSet, success


    def checkSanity(self, valuePreviouslySet):
        """ Checks if the value we get is still approximately the same
        as we attempted to set. The value can have a slight round error which
        is tolerated.

        valuePreviouslySet -- the value we had previously set

        returns: the value the parameter-framework returns us after the get
        returns: True if we are able to set, False otherwise
        """
        firstGet = self._pfwClient.get(self._paramPath)

        try:
            returnValue = Decimal(firstGet)
        except ValueError:
            print("ERROR: Can't convert %s to a decimal" % firstGet)
            return firstGet, False

        upperAllowedValue = Decimal(valuePreviouslySet) + (Decimal(self._quantum) / Decimal(2))
        lowerAllowedValue = Decimal(valuePreviouslySet) - (Decimal(self._quantum) / Decimal(2))

        if not (lowerAllowedValue <= returnValue <= upperAllowedValue):
            print('%s <= %s <= %s is not true' %
                    (lowerAllowedValue, returnValue, upperAllowedValue))
            return firstGet, False

        return firstGet, True

    def checkConsistency(self, valuePreviouslyGotten):
        """ Checks if we are able to set the value that the parameter framework
        just returned to us.

        valuePreviouslyGotten -- the value we are trying to set

        valueToSet -- the value we are trying to set
        returns: True if we are able to set, False otherwise
        """
        (success, errorMsg) = pfw.set(self._paramPath, valuePreviouslyGotten)

        return valuePreviouslyGotten, success

    def checkBijectivity(self, valuePreviouslySet):
        """ Checks that the second get value is strictly equivalent to the
        consistency set. This ensures that the parameter-framework behaves as
        expected.

        valuePreviouslySet -- the value we had previously set

        returns: value the parameter-framework returns us after the second get
        returns: True if we are able to set, False otherwise
        """
        secondGet = pfw.get(self._paramPath)

        if secondGet != valuePreviouslySet:
            return secondGet, False

        return secondGet, True

class PfwClient():

    def __init__(self, configPath):
        self._instance = PyPfw.ParameterFramework(configPath)

        self._logger = PfwLogger()
        self._instance.setLogger(self._logger)
        # Disable the remote interface because we don't need it and it might
        # get in the way (e.g. the port is already in use)
        self._instance.setForceNoRemoteInterface(True)

        self._instance.start()
        self._instance.setTuningMode(True)

    def set(self, parameter, value):
        print('set %s <--- %s' % (parameter, value))
        (success, _, errorMsg) = self._instance.accessParameterValue(parameter, str(value), True)
        return success, errorMsg

    def get(self, parameter):
        (success, value, errorMsg) = self._instance.accessParameterValue(parameter, "", False)
        if not success:
            raise Exception("A getParameter failed, which is unexpected. The"
                            "parameter-framework answered:\n%s" % errorMsg)

        print('get %s ---> %s' % (parameter, value))
        return value

if __name__ == '__main__':
    # It is necessary to add a ./ in front of the path, otherwise the parameter-framework
    # does not recognize the string as a path.
    pfw = PfwClient('./ParameterFrameworkConfiguration.xml')

    success = True

    for size in [8, 16, 32]:
        for integral in range(0,  size):
            for fractional in range (0,  size - integral):
                tester = FixedPointTester(pfw, size, integral, fractional)
                success = tester.run() and success

    exit(0 if success else 1)