from DataVaultGenerator.Components import DataVaultEntity, DataVaultEntityAttribute, ErrorCollection


class Link(DataVaultEntity):

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

        self.drivingkeys = self._definition.get('drivingkeys',[])
        key = DataVaultEntityAttribute(self, self.model.config.datavault.keyattribute)
        key.name = self.key_columnname
        self.add_attribute(key)

    def get_drivingkey_entities(self):
        return [self.model.get_entity(d) for d in self.drivingkeys]

    def get_foreign_attribute(self, name: str):
        for e in self._definition['hubs']:
            if self.model.get_entity(e).key_attribute.name == name:
                return self.model.get_entity(e).key_attribute

    def get_foreign_attributes(self):
        fa = []
        for e in self._definition['hubs']:
            fa.append(DataVaultEntityAttribute(self, definition=dict(name=self.model.get_entity(e).key_attribute.name,
                                                                     datatype=self.model.get_entity(e).key_attribute.datatype,
                                                                     role='fk')
                                               ))
        return fa

    @property
    def key_columnname(self):
        """returns name of the primary Key Attribute. If no name was defined in its definition, a template applies."""
        return self._definition.get('key', self.model.basetemplates.get('entity_key_name').render(entity=self))

    @property
    def key_attribute(self):
        return self.get_role_attribute(self.model.config.datavault.keyattribute.get('role','sk'))

    def get_linked_entities(self):
        """returns a list of linked entities."""
        return [self.model.get_entity(le) for le in self._definition['hubs'] + self._definition.get('links',[])]

    def get_satellites(self):
        return [e for e in self.model.get_entities_by_type('satellite') if e.get_parent_entity() == self]

    def validate(self):

        errors = ErrorCollection()

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

        # Validating entity references:
        for name in self._definition['hubs']:
            if self.model.get_entity(name) is None:
               suggest = self.model.get_entity_name_suggestion('hub', name) 
               suggest = f'Do you mean <{suggest}>?' if suggest else ''
               errors.add("VALIDATION ERROR",
                          (self.filename,"Link", "<" + self.name + ">"),
                           f'Hub <{name}> not found. ' + suggest)
               
                        

        # Validating entity references:
        for name in self._definition.get('links',[]):
            if self.model.get_entity(name) is None:
               suggest = self.model.get_entity_name_suggestion('link', name) 
               suggest = f'Do you mean <{suggest}>?' if suggest else ''
               errors.add("VALIDATION ERROR",
                          (self.filename,"Link", "<" + self.name + ">"),
                           f'Link <{name}> not found. ' + suggest)

        return errors

    def get_component_entities(self):
        return [{'entity': self, 'component': c, 'type': c.type} for c in
                self.get_source_entities().values()]  # holt derzeit nur die Deliveries über die Mappings