"""Field Definition."""

from payee.connectors.secure_data.fields.field import Field


class TextField(Field):
    """Definition of a secure field."""

    _value_type = str

    def __init__(self, name, **kwargs):
        """Set properties on field definition."""
        self._name = name
        self._data_type = 'str'
        self._encrypt = kwargs.get('encrypt', True)
        self._obscure_in_response = kwargs.get('obscure_in_response', False)
        # if set use some original symbols in obscured response
        self._original_symbols_count_left = kwargs.get('original_symbols_count_left')
        self._original_symbols_count_right = kwargs.get('original_symbols_count_right')
        # if set then use fixed count of asterisks in despite of symbols count
        self._asterisk_count = kwargs.get('asterisk_count')
        self._required = kwargs.get('required', False)
        self._allowed_values = kwargs.get('allowed_values', None)
        self._value = None
        value = kwargs.get('value', None)
        if value:
            self.value = value

        super().__init__(name, **kwargs)

    @property
    def _params(self):
        """Get field params."""
        return {
            'encrypt': self._encrypt,
            'obscure_in_response': self._obscure_in_response,
            'original_symbols_count_left': self._original_symbols_count_left,
            'original_symbols_count_right': self._original_symbols_count_right,
            'asterisk_count': self._asterisk_count,
            'required': self._required,
            'allowed_values': self._allowed_values,
            'value': self._value,
        }

    @staticmethod
    def is_empty(original_value):
        """Check if value is empty.

        For example for bool False is not an empty value, while for str '' is.
        """
        return original_value is None or original_value == ''

    @property
    def _obscured_value(self):
        """Get obscured value."""
        if not self._value:
            return self._value

        if (
            not self._asterisk_count
            and not self._original_symbols_count_left
            and not self._original_symbols_count_right
        ):
            return super()._obscured_value

        if self._asterisk_count:
            asterisk_count = self._asterisk_count
        else:
            asterisk_count = (
                len(self._value)
                - (self._original_symbols_count_left or 0)
                - (self._original_symbols_count_right or 0)
            )
        return (
            (
                self._value[: self._original_symbols_count_left]
                if self._original_symbols_count_left
                else ''
            )
            + '*' * asterisk_count
            + (
                self._value[-self._original_symbols_count_right :]
                if self._original_symbols_count_right
                else ''
            )
        )