import re
from DataVaultGenerator.Components import DataVaultEntity, DataVaultEntityAttribute, ErrorCollection


class Bridge(DataVaultEntity):
    def __init__(self, model, filename, definition: dict = None):
        DataVaultEntity.__init__(self, model, filename, definition)

        self.updatemode = self._definition.get('updatemode', 'full') 

    @property
    def snapshotattribute(self):
        return DataVaultEntityAttribute(self, self._definition['snapshotattribute'])

    @property
    def snapshotquery(self, include_db=True):
        parsed_result = self.rawquery

        for alias, entity in self.get_query_entities().items():
            if entity:
                replacement = self.model.basetemplates.get('query_entity_alias').render(entity=entity, includeDB=include_db, alias=str(alias))
                parsed_result = parsed_result.replace('{' + str(entity.name) + ':' + str(alias) + '}', replacement) 
                parsed_result = parsed_result.replace('{' + str(entity.name) + '}', replacement) 

        return parsed_result

    def get_query_entities(self):
        """ Parses Querystrings like: Select * from {entityname1:alias1} join {entityname2:alias2} and returns a list
        of entity instances. """
        regex = r"\{(.*?):(.*?)?\}"

        entities = {}

        matches = re.finditer(regex, self.rawquery, re.MULTILINE)
        for matchNum, match in enumerate(matches):
            for groupNum in range(0, len(match.groups())):
                entities[match.group(2)] = self.model.get_entity(match.group(1))

        #regex101.com
        regex = r"\{(.[^:]*?)\}"
        matches = re.finditer(regex, self.rawquery, re.MULTILINE)
        for matchNum, match in enumerate(matches):
            for groupNum in range(0, len(match.groups())):
                entities[match.group(1)] = self.model.get_entity(match.group(1))

        return entities

    @property
    def rawquery(self):
        return self._definition.get('snapshotquery', '')

    def get_linked_entities(self): #FIXME: in docu aufnehmen?, überhaupt relevant?
        """returns a list of linked entities."""
        return [self.model.get_entity(le) for le in self._definition['hubs'] + self._definition.get('links',[])]

   
    def has_attributes(self):
        return True if self._definition.get('bridgeattributes') else False

    def get_bridgeattributes(self):
        return [DataVaultEntityAttribute(self, attrdef) for attrdef in self._definition.get('bridgeattributes', [])]

    def validate(self):
        
        errors = ErrorCollection()

        for attr in self.attributes.values():
            spec = self.layer.sys_specification
            errors.append(attr.validate(spec))

        # Validating entity references:
        if self._definition.get('snapshotquery'):
            for name, e in self.get_query_entities().items():
                if e is None:
                   errors.add("VALIDATION ERROR",
                              (self.filename, "Bridge", "<" + self.name + ">"),
                              f'query-entity <{name}> not found.')
        return errors

    def get_component_entities(self):
        return [{'entity': self, 'component': c, 'type': c.type} for c in self.get_query_entities().values() if self != c ]