#
# 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 re
import os
import sys
import logging
import xml.parsers.expat
import codecs
from hcrplugin.hcr_exceptions import *
from hcrplugin.hcrrepository import HcrRecord, HcrRepository
from hcrplugin.hcr_writer import HcrWriter
from hcrplugin.header_writer import *
try:
    from cElementTree import ElementTree
except ImportError:
    try:    
        from elementtree import ElementTree
    except ImportError:
        try:
            from xml.etree import cElementTree as ElementTree
        except ImportError:
            from xml.etree import ElementTree

import __init__

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

class HcrmlImpl(plugin.ImplBase):
    """
    <class description>
    """
    
    IMPL_TYPE_ID = "hcrml"

    def __init__(self, resource_ref, configuration):
        plugin.ImplBase.__init__(self, resource_ref, configuration)
        self.logger = logging.getLogger('cone.hcrml(%s)' % resource_ref)
        self.configuration = configuration
        self.hcrml_file = resource_ref


    def generate(self, context=None):
        """
        Generate the given implementation. 
        @return: 
        """
        outputfile = self.__get_output_filename()
        if outputfile != None:
            # Create the path to the output file
            output_path = os.path.dirname(outputfile)
            if output_path != '' and not os.path.exists(output_path):
                os.makedirs(output_path)
        
        # For output type 'hcr', write the binary repository file
        if self.output_obj.type == 'hcr':
            self.logger.info("Generating binary repository to '%s'" % outputfile)
            writer = HcrWriter()
            repo = self.output_obj.get_hcr_repository()
            data = writer.get_repository_bindata(repo)
            f = open(outputfile,'wb')
            try:        f.write(data)
            finally:    f.close()
        elif self.output_obj.type == 'header':
            self.logger.info("Generating header file to '%s'" % outputfile)
            writer = HeaderWriter(outputfile, self.output_obj)
            writer.write()
        elif self.output_obj.type == None:
            # The HCRML file contains no <output> element, so no output should
            # be generated
            pass

    def get_refs(self):
        return self.refs
    
    def list_output_files(self):
        """
        Return a list of output files as an array. 
        """
        fname = self.__get_output_filename()
        return [fname] if fname else []
    
    def __get_output_filename(self):
        if self.output_obj.file != None:
            return os.path.normpath(os.path.join(self.output, self.output_obj.file))
        else:
            return None


class HcrmlReader(plugin.ReaderBase):
    NAMESPACE = 'http://www.symbianfoundation.org/xml/hcrml/1'
    FILE_EXTENSIONS = ['hcrml']
    
    def __init__(self, resource_ref, configuration):
        self.configuration = configuration
        self.hcrml_file = resource_ref
        self.refs = []
        self.namespaces = [self.NAMESPACE]
        self.doc = None
    
    @classmethod
    def read_impl(cls, resource_ref, configuration, etree):
        reader = HcrmlReader(resource_ref, configuration)
        reader.doc = etree
        
        impl = HcrmlImpl(resource_ref, configuration)
        impl.output_obj = reader.read_hcrml_output()
        impl.refs = reader.refs
        return impl

    def read_hcrml_output(self, ignore_includes=False):
        output = Output()
        
        # There should only be one <output> element, so use find()
        out_elem = self.doc.find("{%s}output" % self.namespaces[0])
        if out_elem != None:
            version = out_elem.get('version')
            read_only = out_elem.get('readOnly')
            file = out_elem.get('file')
            type = out_elem.get('type')
            
            if type == None or type == '':
                raise NoTypeDefinedInOutPutTagError("Type attribute missing in hcrml file")
            
            if type not in ('hcr', 'header'): 
               raise InvalidTypeDefinedInOutPutTagError("Type attribute invalid in hcrml file: %s" % type)
           
            output.version = version
            output.read_only = read_only
            output.file = file
            output.type = type
         
            # An <output> element may contain <include> elements for including other
            # HCRML files, so read and include categories from those
            if not ignore_includes:
                included_files = self.read_hcrml_includes(out_elem)
                read_categories = self.read_categories_from_hcrml_files(included_files)
                output.categories.extend(read_categories)
            
         
        """ output tag is not mandatory, but there should be some categories included """
        for cat_elem in self.doc.getiterator("{%s}category" % self.namespaces[0]):
            category = self.read_hrcml_category(cat_elem)
            output.categories.append(category)
        return output 
    
    def read_hcrml_includes(self, output_elem):
        """
        Read all <include> elements under an <output> element.
        @return: List of other HCRML files to include.
        """
        result = []
        
        include_refs = []
        for include_elem in output_elem.findall("{%s}include" % self.namespaces[0]):
            ref = include_elem.get('ref')
            if ref != None: include_refs.append(ref)
        
        if include_refs:
            # There are include refs, construct the list of files that should
            # be included
            all_files = self.configuration.list_resources()
            included_files = []
            for ref in include_refs:
                files_by_ref = self.filter_file_list_by_include_ref(all_files, ref)
                result.extend(files_by_ref)
        
        # Make sure that no file is in the list more than once
        result = list(set(result))
        return result
        
    def read_categories_from_hcrml_files(self, files):
        """
        Read all categories from the list of the given HCRML files.
        """
        categories = []
        
        for file in files:
            # Skip the current file
            if os.path.normpath(file) == os.path.normpath(self.hcrml_file):
                continue
            
            # Read the <output> element and append its categories to the result list
            reader = HcrmlReader(file, self.configuration)
            reader.doc = self._read_xml_doc_from_resource(file, self.configuration)
            # Read the output element, but ignore includes, since we are
            # currently reading from inside an include
            output_obj = reader.read_hcrml_output(ignore_includes=True)
            categories.extend(output_obj.categories)
            
        return categories
            
    def read_hrcml_category(self,cat_elem):
        category_uid = cat_elem.get('uid')
        if category_uid == None or category_uid == '':
           raise NoCategoryUIDInHcrmlFileError("No category uid attribute implemented in hcrml file!")
        name = cat_elem.get('name')
        if name == None or name == '':
           raise NoCategoryNameInHcrmlFileError("No category name attribute implemented in hcrml file!")
        category = Category()
        category.name = name
        try:
            category.category_uid = long(category_uid)
        except ValueError:
            category.category_uid = long(category_uid, 16)
        category.xml_elem = cat_elem  
        for setting_elem in cat_elem.getiterator("{%s}setting" % self.namespaces[0]):
             setting = self.read_hcrml_setting(setting_elem)
             category.settings.append(setting)
        return category
            

    def read_hcrml_setting(self,setting_elem):
        
        ref = setting_elem.get('ref')
        if ref == None or ref == '':
            raise NoRefInHcrmlFileError("No ref in setting tag attribute implemented in hcrml file!")
        else:
            self.refs.append(ref)
        type = setting_elem.get('type')
        if type == None or type == '':
            raise NoTypeAttributeInSettingHcrmlFileError("No type in setting tag attribute implemented in hcrml file ref: %s" % ref )
        name = setting_elem.get('name')
        if name == None or name == '':
            raise NoNameAttributeInSettingHcrmlFileError("No type in setting tag attribute implemented in hcrml file ref: %s" % ref )
        id = setting_elem.get('id')
        if id == None or id == '':
            raise NoIdAttributeInSettingHcrmlFileError("No id in setting tag attribute implemented in hcrml file ref: %s" % ref )

        comment = setting_elem.get('comment')
        if comment == None:
            comment = ''
            
        
        setting = Setting(self.configuration)
        setting.comment = comment
        setting.name = name
        setting.ref = ref
        try:
            setting.id = long(id)
        except ValueError:
            setting.id = long(id, 16)
        setting.type = type
        setting.xml_elem = setting_elem
        for flag_elem in setting_elem.getiterator("{%s}flags" % self.namespaces[0]):
             flag = self.read_hrcml_flags(setting_elem)
             setting.flag = flag
        return setting

    def read_hrcml_flags(self,flag_elem):
         Uninitialised = flag_elem.get('Uninitialised') 
         Modifiable = flag_elem.get('Modifiable')
         Persistent = flag_elem.get('Persistent')
         flag = Flag()
         flag.Uninitialised = Uninitialised
         flag.Modifiable = Modifiable
         flag.Persistent = Persistent
         return flag
     
    def filter_file_list_by_include_ref(self, files, ref):
        pattern = ref + '$'
        pattern = pattern.replace('.', r'\.')
        pattern = pattern.replace('*', '.*')
        pattern = '(^|.*/)' + pattern
        result = []
        for file in files:
            if re.match(pattern, file.replace('\\', '/')) != None:
                result.append(file)
        return result


class Flag(object):
    def __init__(self):
        self.Uninitialised = 0
        self.Modifiable    = 0
        self.Persistent    = 0

class Setting(object):
    def __init__(self,configuration):
        self.name   = None
        self.ref    = None
        self.type   = None
        self.id = None
        self.flag = None
        self.comment = ''
        self.configuration = configuration
        
    @property
    def value(self):
        dview = self.configuration.get_default_view()
        feature = dview.get_feature(self.ref)
        value = feature.get_value()
        
        if self.type in (HcrRecord.VALTYPE_ARRAY_INT32, HcrRecord.VALTYPE_ARRAY_UINT32):
            # Convert string values to numbers
            value = map(lambda x: self.__str_to_long(x), value)
        elif self.type == HcrRecord.VALTYPE_BIN_DATA and feature.get_type() == 'string':
            value = self.__hex_to_bindata(value)
        return value
    
    def __str_to_long(self, str_value):
        try:
            return long(str_value)
        except ValueError:
            return long(str_value, 16)
    
    def __hex_to_bindata(self, hexdata):
        orig_hexdata = hexdata
        hexdata = hexdata.replace(' ', '').replace('\r', '').replace('\n', '').replace('\t', '')
        if len(hexdata) % 2 != 0:
            raise ValueError("Failed to convert %r into binary data: String length %d (whitespace stripped) is not divisible by 2", orig_hexdata, len(hexdata))
        for c in hexdata:
            if c not in "0123456789abcdefABCDEF":
                raise ValueError("Failed to convert %r into binary data: Not a valid hex string", hexdata)
        
        temp = []
        for i in xrange(len(hexdata) / 2):
            start = i * 2
            end   = start + 2 
            temp.append(chr(int(hexdata[start:end], 16)))
        return ''.join(temp)

class Category(object):
    def __init__(self):
        self.name   = None
        self.category_uid    = None
        self.settings = []
    
    def get_hcr_records(self):
        """
        Return a list of HcrRecord objects created based on this category's settings.
        """
        result = []
        for setting in self.settings:
            record = HcrRecord(setting.type, setting.value, self.category_uid, setting.id)
            flag = setting.flag
            if flag:
                record.flags = 0
                if flag.Uninitialised == '1':   record.flags |= HcrRecord.FLAG_UNINITIALIZED
                if flag.Modifiable == '1':      record.flags |= HcrRecord.FLAG_MODIFIABLE
                if flag.Persistent == '1':      record.flags |= HcrRecord.FLAG_PERSISTENT
            result.append(record)
        return result 
        

class Output(object):
    def __init__(self):
        self.file = None
        self.type = None
        self.version = None
        self.read_only = None
        self.categories = []
    
    def get_hcr_records(self):
        """
        Return a list of HcrRecord objects created based on this output object's categories.
        """
        result = []
        for category in self.categories:
            result.extend(category.get_hcr_records())
        return result
    
    def get_hcr_repository(self):
        """
        Return a HcrRepository object created based on this output.
        
        The type of this Output object should be 'hcr', otherwise and an exception is raised.
        """
        if self.type != 'hcr':
            raise RuntimeError("get_hcr_repository() called on an Output object with type '%s' (should be 'hcr')" % self.type)
        
        return HcrRepository(self.get_hcr_records())