trestle.common.str_utils

def alias_to_classname(alias: str, mode: AliasMode) -> str:
    """
    Return class name based dashed or snake alias.

    This is applicable creating dynamic wrapper model for a list or dict field.
    """
    if mode == AliasMode.JSON:
        return _snake_to_upper_camel(alias.replace('-', '_'))
    return _snake_to_upper_camel(alias)

def as_bool(string_or_none: Optional[str]) -> bool:
    """Convert string to boolean."""
    if string_or_none:
        if string_or_none.lower() in ['false']:
            rval = False
        else:
            rval = True
    else:
        rval = False
    return rval

def as_string(string_or_none: Optional[str]) -> str:
    """Convert string or None to itself or empty string."""
    return string_or_none if string_or_none else ''

def classname_to_alias(classname: str, mode: AliasMode) -> str:
    """
    Return oscal key name or field element name based on class name.

    This is applicable when asking for a singular element.
    """
    suffix = classname.split('.')[-1]

    # Root/datatype wrapper names should resolve to the underlying semantic alias.
    root_suffix_aliases = {
        'StringDatatype': 'string',
        'IntegerDatatype': 'integer',
        'PositiveIntegerDatatype': 'positive-integer',
        'NonNegativeIntegerDatatype': 'non-negative-integer',
        'Base64Datatype': 'base64',
        'DateTimeWithTimezoneDatatype': 'date-time-with-timezone',
        'EmailAddressDatatype': 'email-address',
        'MarkupLineDatatype': 'markup-line',
        'MarkupMultilineDatatype': 'markup-multiline',
        'URIReferenceDatatype': 'uri-reference',
    }
    if mode == AliasMode.JSON:
        if suffix.endswith('_'):
            suffix = suffix[:-1]
        if suffix in root_suffix_aliases:
            return root_suffix_aliases[suffix]
        return _camel_to_dash(suffix.rstrip(string.digits))
    # else alias mode is field
    if suffix.endswith('_'):
        suffix = suffix[:-1]
    if suffix in root_suffix_aliases:
        return root_suffix_aliases[suffix].replace('-', '_')
    return _camel_to_snake(suffix.rstrip(string.digits))

def dash_to_underscore(name: str) -> str:
    """Convert dash to underscore."""
    return name.replace('-', '_')

def spaces_and_caps_to_lower_single_spaces(spaced_str: str) -> str:
    """Convert caps and duplicate spaces to lower with single spaces."""
    single_space = ' '.join(spaced_str.strip().split())
    return single_space.lower()

def spaces_and_caps_to_snake(spaced_str: str) -> str:
    """Convert caps and spaces to snake."""
    underscored = '_'.join(spaced_str.strip().split())
    return underscored.lower()

def string_from_root(item_with_root: Optional[Any]) -> str:
    """Convert root to string if present (Pydantic v2 RootModel)."""
    return as_string(item_with_root.root) if item_with_root else ''

def strip_lower_equals(str_a: Optional[str], str_b: Optional[str]) -> bool:
    """
    Safe test of lower string equality allowing Nones.

    If either argument is None the result is False because the intent is to report if they are equal as actual strings.
    """
    if str_a is None or str_b is None:
        return False
    return str_a.strip().lower() == str_b.strip().lower()

def to_ncname(name: str) -> str:
    """Convert to NCName."""
    rval = name
    if name:
        rval = re.sub(r'[^A-Za-z0-9_.-]', '_', name)
    return rval

def underscore_to_dash(name: str) -> str:
    """Convert underscore to dash and drop final dash if present."""
    converted = name.replace('_', '-')
    return converted if converted[-1] != '-' else converted[:-1]