"""Input validation utilities"""
import re
import json
import base64
from typing import Any

def is_empty_string(value: str) -> bool:
    """Check whether as string is empty"""
    return (isinstance(value, str) and value.strip() == "")


def is_empty_input(value: Any) -> bool:
    """Check whether user provided an empty value."""
    return (value is None or is_empty_string(value))


def is_integer_input(value: Any) -> bool:
    """
    Check whether user provided a value that can be parsed into an integer.
    """
    def __is_int__(val, base):
        try:
            int(val, base=base)
        except ValueError:
            return False
        return True
    return isinstance(value, int) or (
        (not is_empty_input(value)) and (
            isinstance(value, str) and (
                __is_int__(value, 10)
                or __is_int__(value, 8)
                or __is_int__(value, 16))))


def is_valid_representative_name(repr_name: str) -> bool:
    """
    Check whether the given representative name is a valid according to our rules.

    Parameters
    ----------
    repr_name: a string of characters.

    Checks For
    ----------
    * The name MUST start with an alphabet [a-zA-Z]
    * The name MUST end with an alphabet [a-zA-Z] or number [0-9]
    * The name MUST be composed of alphabets [a-zA-Z], numbers [0-9],
      underscores (_) and/or hyphens (-).

    Returns
    -------
    Boolean indicating whether or not the name is valid.
    """
    pattern = re.compile(r"^[a-zA-Z]+[a-zA-Z0-9_-]*[a-zA-Z0-9]$")
    return bool(pattern.match(repr_name))


def encode_errors(errors: tuple[tuple[str, str], ...], form) -> bytes:
    """Encode form errors into base64 string."""
    return base64.b64encode(
        json.dumps({
            "errors": dict(errors),
            "original_formdata": dict(form)
        }).encode("utf8"))


def decode_errors(errorstr) -> dict[str, dict]:
    """Decode errors from base64 string"""
    if not bool(errorstr):
        return {"errors": {}, "original_formdata": {}}
    return json.loads(base64.b64decode(errorstr.encode("utf8")).decode("utf8"))