#
# 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 hcrplugin.hcrrepository import HcrRecord, HcrRepository
from struct import pack, unpack
from hcrplugin.hcr_writer import VALUE_TYPE_MAP,VALUE_TYPES_WITH_LSD,VALUE_TYPES_UNSIGNED_INT
from hcrplugin.hcr_header import HcrHeader
from hcrplugin.hcr_exceptions import *


class HcrReader(object):
    
    def parse_repository_from_bindata(self, data):
        """
        @return: HcrRepository object constructed from the given binary data.
        """
        header_data = data[:32]
        header = HcrHeader()
        header.loads(header_data)
        
        expected_len = 32 + header.nrecords * 20 + header.lsd_size
        if len(data) < expected_len:
            raise InvalidHcrDataSizeError("File size is %d, expected at least %d based on header" \
                                          % (len(data), expected_len))
        
        expected_lsd_offset = 32 + header.nrecords * 20
        if header.lsd_offset != expected_lsd_offset: 
            raise InvalidLsdSectionOffsetError("LSD offset is %d, expected %d" \
                                               % (header.lsd_offset, expected_lsd_offset))
        
        records = []
        for i in xrange(header.nrecords):
            record_offset =  32 + i * 20
            record_data = data[record_offset:record_offset+20]
            record,lsd_pos = self.parse_record_from_bindata(record_data)
            if lsd_pos != None:
                if lsd_pos[0] > header.lsd_size or (lsd_pos[0] + lsd_pos[1]) > header.lsd_size:
                    raise InvalidRecordLsdPositionError(
                        "LSD offset of record %d (category=%d, element=%d) is %r, but LSD section size is %d" \
                        % (i, record.category_id, record.element_id, lsd_pos, header.lsd_size))
                lsd_offset = lsd_pos[0] + header.lsd_offset
                lsd_data = data[lsd_offset:lsd_offset+lsd_pos[1]]
                record.value = self.parse_record_value_from_lsd_bindata(record.type,lsd_data)
            records.append(record)
                
        return HcrRepository(records,header.version,header.flags)

    def parse_record_from_bindata(self, data):
        """
        @return: Tuple: (record, lsd_pos) where
            record  = HcrRecord object constructed from the given binary data.
            lsd_pos = The position of the record's data in the LSD section in the
                      form of a tuple (offset, size), or None if the record does
                      not have any data in the LSD section.
        """
        
        if len(data) != 20:
            raise HcrReaderError("Invalid record length: %d, expected 20" % len(data))
        
        result = unpack("<IIIHH",data[:16])
        
        category_id = result[0]
        element_id = result[1]
        value_type = result[2]
        flag = result[3]
        lsd_len = result[4]
        
        
        
        for key,val in VALUE_TYPE_MAP.iteritems():
            if val == value_type:
                value_type = key
                break
        if value_type not in VALUE_TYPE_MAP:
            raise InvalidRecordValueTypeError("Invalid value type:%X" % value_type)
        
        value = None
        lsd_pos = None
        if value_type in VALUE_TYPES_WITH_LSD:
            lsd_offset = unpack("<I",data[16:])[0]
            lsd_pos = (lsd_offset,lsd_len)
        else:
            if value_type in VALUE_TYPES_UNSIGNED_INT:
                format = "<I"
            elif value_type == HcrRecord.VALTYPE_INT8:
                format = "<bxxx"
            elif value_type == HcrRecord.VALTYPE_INT16:
                format = "<hxx"
            else:
                format = "<i"
            
            value = unpack(format, data[16:])[0]
                
            if value_type == HcrRecord.VALTYPE_BOOL:
                value = bool(value)
                
            
        
        record = HcrRecord(value_type,value,category_id,element_id,flag)

        return record,lsd_pos
        
    
    def parse_record_value_from_lsd_bindata(self, record_type, data):
        """
        @return: The record value parsed from the given binary data in the LSD section.
        @param type: The HCRML type of the record whose LSD data is to be parsed.
        """
        if record_type == HcrRecord.VALTYPE_TEXT8:
            return data.decode("utf-8")
        
        elif record_type == HcrRecord.VALTYPE_BIN_DATA:
            return data 

        elif record_type == HcrRecord.VALTYPE_ARRAY_INT32:
            if len(data) % 4 != 0:
                raise InvalidRecordLsdPositionError("Int32 array requires an amount of LSD data that is divisible by 4 (data with size %d was given)" % len(data))
            return list(unpack("<%di"%(len(data)/4), data))

        elif record_type == HcrRecord.VALTYPE_ARRAY_UINT32:
            if len(data) % 4 != 0:
                raise InvalidRecordLsdPositionError("Uint32 array requires an amount of LSD data that is divisible by 4 (data with size %d was given)" % len(data))
            return list(unpack("<%dI"%(len(data)/4), data))

        elif record_type == HcrRecord.VALTYPE_INT64:
            if len(data) != 8:
                raise InvalidRecordLsdPositionError("Int64 requires LSD data size to be 8 bytes (%d given)" % len(data))
            return unpack("<q",data)[0]

        elif record_type == HcrRecord.VALTYPE_UINT64:
            if len(data) != 8:
                raise InvalidRecordLsdPositionError("Uint64 requires LSD data size to be 8 bytes (%d given)" % len(data))
            return unpack("<Q",data)[0]
        
        else:
            return None