from DataVaultGenerator.Components import DataVaultEntity, DataVaultEntityAttribute, ErrorCollection


class Hub(DataVaultEntity):

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

        self.isCaseSensitive = definition.get('caseSesitive', False)
        self.role_of = definition.get('roleof')
        self.bkcc_attribute = definition.get('bkcc_attribute')

        if self.role_of:
            self.generate = 0

        key = DataVaultEntityAttribute(self, self.model.config.datavault.keyattribute)
        key.name = self.key_columnname
        self.add_attribute(key)

    @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 hash_attribute_trim(self):
        return self._definition.get('key_treatment'
                                    , self.model.config.datavault.business_key_treatment)\
                                .get('trim',
                                     self.model.config.datavault.business_key_treatment.trim)
    @property
    def hash_attribute_case(self):
        return self._definition.get('key_treatment'
                                    , self.model.config.datavault.business_key_treatment)\
                                .get('case',
                                     self.model.config.datavault.business_key_treatment.case)
    @property
    def key_attribute(self):
        return self.get_role_attribute(self.model.config.datavault.keyattribute.get('role','sk'))

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

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

    def validate(self):

        errors = ErrorCollection()

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

        # role-of-reference

        if self.role_of and self.model.get_entity(self.role_of) is None:
           errors.add("VALIDATION ERROR",
                          (self.filename,"Hub", "<" + self.name + ">"),
                            f'role-of Hub <{self.role_of}> not found.')

        # constraints: 
        enforce_bk_type = self.model.config.datavault.constraints.get('enforce_bk_type')
        if enforce_bk_type:
            for attr in self.get_attributes('base'):
                if attr.native_datatype not in enforce_bk_type:
                   errors.add("VALIDATION ERROR",
                               (self.filename,"Hub", "<" + self.name + ">"),
                                 f'Datatype of attribute <{attr.name}> not valid (enforced: {enforce_bk_type})')

        return errors

    def get_roles(self):
        """returns a list of hubs with this hub as role_of-target""" 

        return [e for e in self.model.get_entities_by_type('hub', generatable_only=False) if e.role_of == self.name ]