#!/usr/bin/python 
from datetime import datetime, timedelta
from sfa.rspecs.xml_interface import XMLInterface, XpathFilter
from sfa.rspecs.version_manager import VersionManager
from sfa.util.xrn import *
from sfa.util.plxrn import hostname_to_urn
from sfa.rspecs.rspec_elements import RSpecElement, RSpecElements 
from sfa.util.faults import SfaNotImplemented, InvalidRSpec, InvalidRSpecElement

class RSpec(XMLInterface):
 
    def __init__(self, rspec="", version=None, user_options={}):
        self.header = '<?xml version="1.0"?>\n'
        self.template = """<RSpec></RSpec>"""
        self.version = None
        self.xml = None
        self.version_manager = VersionManager()
        self.user_options = user_options
        self.elements = {}
        if rspec:
            self.parse_xml(rspec)
        else:
            self.create(version)

    def create(self, version=None):
        """
        Create root element
        """
        self.version = self.version_manager.get_version(version)
        self.namespaces = self.version.namespaces
        self.parse_xml(self.version.template) 
        # eg. 2011-03-23T19:53:28Z 
        date_format = '%Y-%m-%dT%H:%M:%SZ'
        now = datetime.utcnow()
        generated_ts = now.strftime(date_format)
        expires_ts = (now + timedelta(hours=1)).strftime(date_format) 
        self.xml.set('expires', expires_ts)
        self.xml.set('generated', generated_ts)


    def parse_xml(self, xml):
        XMLInterface.parse_xml(self, xml)
        # determine rspec version
        # look for schema first
        schema = None
        self.version = None
        for key in self.xml.attrib.keys():
            if key.endswith('schemaLocation'):
                # schema location should be at the end of the list
                schema_parts  = self.xml.attrib[key].split(' ')
                namespace, schema  = schema_parts[0], schema_parts[1]                 
                break

        if schema:
            self.version = self.version_manager.get_version_by_schema(schema)
        else:
            #raise InvalidRSpec('unknown rspec schema: %s' % schema)
            # TODO: probably isn't safe to assume use default version here
            # should probably fault if we arent certain  
            self.version = self.version_manager.get_version()
        self.version.xml = self.xml    
        self.namespaces = self.version.namespaces
    
    def load_rspec_elements(self, rspec_elements):
        self.elements = {}
        for rspec_element in rspec_elements:
            if isinstance(rspec_element, RSpecElement):
                self.elements[rspec_element.type] = rspec_element

    def register_rspec_element(self, element_type, element_name, element_path):
        if element_type not in RSpecElements:
            raise InvalidRSpecElement(element_type, extra="no such element type: %s. Must specify a valid RSpecElement" % element_type)
        self.elements[element_type] = RSpecElement(element_type, element_name, element_path)

    def get_rspec_element(self, element_type):
        if element_type not in self.elements:
            msg = "ElementType %s not registerd for this rspec" % element_type
            raise InvalidRSpecElement(element_type, extra=msg)
        return self.elements[element_type]

    def get(self, element_type, filter={}, depth=0):
        elements = self.get_elements(element_type, filter)
        elements = [self.get_element_attributes(element, depth=depth) for element in elements]
        return elements

    def get_elements(self, element_type, filter={}):
        """
        search for a registered element
        """
        if element_type not in self.elements:
            msg = "Unable to search for element %s in rspec, expath expression not found." % \
                   element_type
            raise InvalidRSpecElement(element_type, extra=msg)
        rspec_element = self.get_rspec_element(element_type)
        xpath = rspec_element.path + XpathFilter.xpath(filter)
        return self.xpath(xpath)

    def merge(self, in_rspec):
        pass

    def _process_slivers(self, slivers):
        """
        Creates a dict of sliver details for each sliver host
        
        @param slivers a single hostname, list of hostanmes or list of dicts keys on hostname,
        Returns a list of dicts 
        """
        if not isinstance(slivers, list):
            slivers = [slivers]
        dicts = []
        for sliver in slivers:
            if isinstance(sliver, dict):
                dicts.append(sliver)
            elif isinstance(sliver, basestring):
                dicts.append({'hostname': sliver}) 
        return dicts

if __name__ == '__main__':
    rspec = RSpec('/tmp/resources.rspec')
    print rspec
    rspec.register_rspec_element(RSpecElements.NETWORK, 'network', '//network')
    rspec.register_rspec_element(RSpecElements.NODE, 'node', '//node')
    print rspec.get(RSpecElements.NODE)[0]
    print rspec.get(RSpecElements.NODE, depth=1)[0]