#

# Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).

# All rights reserved.

# This component and the accompanying materials are made available

# under the terms of "Eclipse Public License v1.0"

# which accompanies this distribution, and is available

# at the URL "http://www.eclipse.org/legal/epl-v10.html".

#

# Initial Contributors:

# Nokia Corporation - initial contribution.

#

# Contributors:

#

# Description: 

#

import logging

import __init__

from struct import pack, unpack

from cone.public import exceptions,plugin,utils,api

from hcrplugin.hcrrepository import HcrRecord

from hcrplugin.hcr_exceptions import *

from hcrplugin.hcr_header import HcrHeader

# Dictionary for mapping the HCRML value types to their

# implementation values

VALUE_TYPE_MAP = {

    HcrRecord.VALTYPE_INT32         : 0x00000001,

    HcrRecord.VALTYPE_INT16         : 0x00000002,

    HcrRecord.VALTYPE_INT8          : 0x00000004,

    HcrRecord.VALTYPE_BOOL          : 0x00000008,

    HcrRecord.VALTYPE_UINT32        : 0x00000010,

    HcrRecord.VALTYPE_UINT16        : 0x00000020,

    HcrRecord.VALTYPE_UINT8         : 0x00000040,

    HcrRecord.VALTYPE_LIN_ADDR      : 0x00000100,

    HcrRecord.VALTYPE_BIN_DATA      : 0x00010000,

    HcrRecord.VALTYPE_TEXT8         : 0x00020000,

    HcrRecord.VALTYPE_ARRAY_INT32   : 0x00040000,

    HcrRecord.VALTYPE_ARRAY_UINT32  : 0x00080000,

    HcrRecord.VALTYPE_INT64         : 0x01000000,

    HcrRecord.VALTYPE_UINT64        : 0x02000000,

    }

VALUE_TYPES_WITH_LSD = [

    HcrRecord.VALTYPE_BIN_DATA,

    HcrRecord.VALTYPE_TEXT8,

    HcrRecord.VALTYPE_ARRAY_INT32,

    HcrRecord.VALTYPE_ARRAY_UINT32,

    HcrRecord.VALTYPE_INT64,

    HcrRecord.VALTYPE_UINT64

    ]

VALUE_TYPES_UNSIGNED_INT = [

    HcrRecord.VALTYPE_UINT32,

    HcrRecord.VALTYPE_UINT16,

    HcrRecord.VALTYPE_UINT8,

    HcrRecord.VALTYPE_LIN_ADDR,

    HcrRecord.VALTYPE_UINT64,

    ]

NUMERIC_VALUE_RANGES = {

    HcrRecord.VALTYPE_INT32         : (-2**31,  2**31-1),

    HcrRecord.VALTYPE_INT16         : (-2**15,  2**15-1),

    HcrRecord.VALTYPE_INT8          : (-2**7,   2**7-1),

    HcrRecord.VALTYPE_UINT32        : (0,       2**32-1),

    HcrRecord.VALTYPE_UINT16        : (0,       2**16-1),

    HcrRecord.VALTYPE_UINT8         : (0,       2**8-1),

    HcrRecord.VALTYPE_LIN_ADDR      : (0,       2**32-1),

    HcrRecord.VALTYPE_INT64         : (-2**63,  2**63-1),

    HcrRecord.VALTYPE_UINT64        : (0,       2**64-1),

    HcrRecord.VALTYPE_ARRAY_INT32   : (-2**31,  2**31-1),

    HcrRecord.VALTYPE_ARRAY_UINT32  : (0,       2**32-1),

}

class HcrWriter(object):

    # Maximum size of LSD section data for one record

    LSD_MAX_SIZE_PER_RECORD = 512

    def get_record_setting_id(self, record):

        """

        Return the setting ID value used for sorting the records in the repository.

        """

        return (record.category_id, record.element_id)

    def get_repository_bindata(self, repository):

        """

        @return: The binary data to write into a file for the given repository.

        """

        dup_ids = repository.get_duplicate_record_ids()

        if len(dup_ids) > 0:

            raise DuplicateRecordError("The repository contains the following duplicate records (category ID, element ID): %r" % dup_ids)

        header_data   = None

        header_size   = 32

        record_data   = []

        records_size  = 0

        lsd_data      = []

        lsd_size      = 0

        lsd_offset    = None

        # Generate the record and LSD section data

        records = sorted(repository.records, key=self.get_record_setting_id)

        for record in records:

            lsd_pos = None

            lsd = self.get_record_lsd_bindata(record)

            if lsd != None:

                # Store the position before adding the padding,

                # because it shouldn't include the padding bytes

                lsd_pos = (lsd_size, len(lsd))

                lsd += self._get_padding(len(lsd))

                lsd_data.append(lsd)

                lsd_size += len(lsd)

            rdata = self.get_record_bindata(record, lsd_pos)

            record_data.append(rdata)

            records_size += len(rdata)

        lsd_offset = header_size + records_size

        header = HcrHeader()

        header.version = repository.version

        header.flags = repository.flags

        header.nrecords = len(repository.records)

        header.lsd_offset = lsd_offset

        header.lsd_size = lsd_size

        header_data = header.dumps()

        if len(header_data) != header_size:

            raise RuntimeError("Internal logic error! Header size is %d and not %d as it should be!" % (len(header_data), header_size))

        output = []

        output.append(header_data)

        output.extend(record_data)

        output.extend(lsd_data)

        output = ''.join(output)

        if len(output) % 4 != 0:

            raise RuntimeError("Internal logic error! Output size is not divisible by 4 (%d)" % (len(output)))

        return output

    def _get_padding(self, size, padding_char='\x00'):

        if size % 4 == 0:   amount = 0

        else:               amount = 4 - (size % 4)

        return amount * padding_char

    def get_record_bindata(self, record, lsd_pos=None):

        """

        @param lsd_pos: The position of the record's data in the Large

            Setting Data section. Should be a tuple: (offset, size).

        @return: The binary data to write for the given record object.

        """

        self._check_value_range(record)

        if record.type in VALUE_TYPES_WITH_LSD:

            RECORD_FMT = "<IIIHHI"

            return pack(RECORD_FMT,record.category_id,record.element_id,VALUE_TYPE_MAP[record.type],record.flags,lsd_pos[1],lsd_pos[0])

        else:

            if record.type in VALUE_TYPES_UNSIGNED_INT:

                RECORD_FMT = "<IIIHHI"

            else:

                RECORD_FMT = "<IIIHHi"

            return pack(RECORD_FMT,record.category_id,record.element_id,VALUE_TYPE_MAP[record.type],record.flags,0,record.value)

    def get_record_lsd_bindata(self, record):

        """

        @return: The binary data to write into the Large Setting Data

            section for the given setting, or None if an entry in the

            LSD section is not necessary.

        """

        result = None

        if record.type == HcrRecord.VALTYPE_TEXT8:

            result = record.value.encode("utf-8")

        elif record.type == HcrRecord.VALTYPE_BIN_DATA:

            result = record.value 

        elif record.type == HcrRecord.VALTYPE_ARRAY_INT32:

            result = pack("<%di"%len(record.value),*record.value)

        elif record.type == HcrRecord.VALTYPE_ARRAY_UINT32:

            result = pack("<%dI"%len(record.value),*record.value)

        elif record.type == HcrRecord.VALTYPE_INT64:

            result = pack("<q",record.value)

        elif record.type == HcrRecord.VALTYPE_UINT64:

            result = pack("<Q",record.value)

        if result != None:

            if len(result) > self.LSD_MAX_SIZE_PER_RECORD:

                msg = "Data size for value in record (category=%d, element=%d) is too large: size %d bytes, but maximum is %d bytes" \

                    % (record.category_id, record.element_id, len(result), self.LSD_MAX_SIZE_PER_RECORD)

                raise TooLargeLsdDataError(msg)

        return result

    def _check_value_range(self, record):

        if record.type in NUMERIC_VALUE_RANGES:

            range = NUMERIC_VALUE_RANGES[record.type]

            values = record.value

            if not isinstance(values, list): values = [values]

            for val in values:

                if val < range[0] or val > range[1]:

                    msg = "Value in record (category=%d, element=%d) is invalid for its type ('%s'): %d is not in the range %d-%d" \

                        % (record.category_id, record.element_id, record.type, val, range[0], range[1])

                    raise ValueNotInRangeError(msg)