"""
Biblioteka operacji na stringach dla QL
"""

import re
import base64

def length(s):
    """Długość stringa"""
    return len(str(s))

def upper(s):
    """Zamienia na wielkie litery"""
    return str(s).upper()

def lower(s):
    """Zamienia na małe litery"""
    return str(s).lower()

def capitalize(s):
    """Pierwsza litera wielka"""
    return str(s).capitalize()

def title(s):
    """Każde słowo z wielkiej litery"""
    return str(s).title()

def trim(s):
    """Usuwa białe znaki z początku i końca"""
    return str(s).strip()

def ltrim(s):
    """Usuwa białe znaki z początku"""
    return str(s).lstrip()

def rtrim(s):
    """Usuwa białe znaki z końca"""
    return str(s).rstrip()

def replace(s, old, new):
    """Zamienia fragmenty stringa"""
    return str(s).replace(old, new)

def split(s, delimiter=' '):
    """Dzieli string na listę"""
    return str(s).split(delimiter)

def join(arr, delimiter=''):
    """Łączy listę w string"""
    return delimiter.join(str(x) for x in arr)

def substring(s, start, end=None):
    """Wyciąga podciąg"""
    if end is None:
        return str(s)[start:]
    return str(s)[start:end]

def char_at(s, index):
    """Znak na pozycji"""
    return str(s)[index]

def index_of(s, search):
    """Pozycja pierwszego wystąpienia"""
    return str(s).find(search)

def last_index_of(s, search):
    """Pozycja ostatniego wystąpienia"""
    return str(s).rfind(search)

def contains(s, search):
    """Czy zawiera podciąg"""
    return search in str(s)

def starts_with(s, prefix):
    """Czy zaczyna się od"""
    return str(s).startswith(prefix)

def ends_with(s, suffix):
    """Czy kończy się na"""
    return str(s).endswith(suffix)

def repeat(s, count):
    """Powtarza string"""
    return str(s) * count

def reverse(s):
    """Odwraca string"""
    return str(s)[::-1]

def is_alpha(s):
    """Czy tylko litery"""
    return str(s).isalpha()

def is_digit(s):
    """Czy tylko cyfry"""
    return str(s).isdigit()

def is_alnum(s):
    """Czy litery i cyfry"""
    return str(s).isalnum()

def is_space(s):
    """Czy tylko białe znaki"""
    return str(s).isspace()

def match(s, pattern):
    """Dopasowanie wyrażenia regularnego"""
    return bool(re.match(pattern, str(s)))

def search(s, pattern):
    """Wyszukiwanie wyrażenia regularnego"""
    match = re.search(pattern, str(s))
    return match.group() if match else None

def format(template, *args):
    """Formatowanie stringa"""
    return template.format(*args)

def encode_base64(s):
    """Kodowanie Base64"""
    return base64.b64encode(str(s).encode()).decode()

def decode_base64(s):
    """Dekodowanie Base64"""
    return base64.b64decode(str(s).encode()).decode()