Module jumpscale.data.types.types

import ast
import re


class String:
    def __init__(self, default=None):
        if not default:
            default = ""
        self.default = default

    def check(self, value):
        """Check whether provided value is a string"""
        return isinstance(value, str)

    def from_str(self, value):
        """return string from a string (is basically no more than a check)"""
        return value


class Integer:
    def __init__(self, default=None):
        if not default:
            default = 0
        self.default = self.from_str(default)

    def check(self, value):
        """Check whether provided string represent integer value

        Arguments:
            value (str)
        """
        try:
            int(value)
            return True
        except ValueError:
            return False

    def from_str(self, value):
        """get integer value from tha string

        Arguments:
            value (str)
        """
        try:
            return int(value)
        except ValueError:
            return None


class Boolean:
    def __init__(self, default=None):
        if not default:
            default = "False"
        self.default = self.from_str(default)

    def check(self, value):
        """Check whether provided string represent Boolean expresion

        Arguments:
            value (str)
        """
        valid_expresions = ["True", "False"]
        return value in valid_expresions

    def from_str(self, value):
        """Get the Boolean value from the string

        Arguments:
            value (str)
        """
        if value == "True":
            return True
        elif value == "False":
            return False
        else:
            return None


class Float:
    def __init__(self, default=None):
        if not default:
            default = 0.0
        self.default = self.from_str(default)

    def check(self, value):
        """Check whether provided string represent integer value

        Arguments:
            value (str)
        """
        try:
            float(value)
            return True
        except ValueError:
            return False

    def from_str(self, value):
        """get integer value from tha string

        Arguments:
            value (str)
        """
        try:
            return float(value)
        except ValueError:
            return None


class JSObject:
    def __init__(self, default=None):
        default = default or ""
        self.default = self.from_str(default)

    def check(self, value):
        return True

    def from_str(self, value):
        return value


class List:
    def __init__(self, default, subtype):
        self.subtype = subtype
        default = default or "[]"
        self.default = self.from_str(default)

    def _deep_check(self, value):
        """Check that the value represents a list with proper elements of the specified subtype.

        Args:
            value (list): The list to be checked.

        Returns:
            Boolean: True if the list is valid.
        """
        if not isinstance(value, list):
            return False
        for e in value:
            if isinstance(self.subtype, List) and not self.subtype._deep_check(e):
                return False
            elif not isinstance(self.subtype, List) and not self.subtype.check(str(e)):
                return False
        return True

    def check(self, value):
        """Check that the value represents a list with proper elements of the specified subtype.

        Args:
            value (list): The list to be checked.

        Returns:
            Boolean: True if the list is valid.
        """
        valid = len(value) >= 2 and value[0] == "[" and value[-1] == "]"
        if not valid:
            return False
        try:
            return self._deep_check(ast.literal_eval(value))
        except:
            return False
        return True

    def _deep_parse(self, value):
        """parses the subelements (if they are of different python type it's converted using the subtype parser)

        Args:
            value (list): The list to be parsed.

        Returns:
            list: The parsed list.
        """
        result = []
        if isinstance(self.subtype, List):
            for i, e in enumerate(value):
                value[i] = self.subtype._deep_parse(e)
        else:
            for i, e in enumerate(value):
                value[i] = self.subtype.from_str(str(e))
        return value

    def from_str(self, value):
        """parses the string value into a list.

        Args:
            value (str): The string to be parsed.

        Returns:
            list: The parsed list.
        """
        # print(f"from str-> value {value}")
        # print(f"subtype {self.subtype}")
        return object()
        # if isinstance(self.subtype, JSObject):
        #     print("returning noww")
        #     return object()
        # else:
        #     return self._deep_parse(ast.literal_eval(value))


def get_js_type(type_str, default_value=None):
    """Gets the js type from a string.

    1. "S" -> String
    2. "B" -> Boolean
    3. "I" -> Integer
    4. "O" -> JSObject
    4. "F" -> Float
    5. "L.*" -> List with subtype .*
    6. "E" -> String
    7. "" -> empty defaults to String

    Args:
        type_str (str): type description.
        default_value (any, optional): The default value. Defaults to None.

    Returns:
        Object: A js type object.
    """
    types = {
        "": String,
        "S": String,
        "I": Integer,
        "B": Boolean,
        "F": Float,
        "O": JSObject,
        "E": String,
        ## TODO: the following are totally wrong, but capturing them to be able to generate in python backend
        "email": String,
        "guid": String,
        "T": String,
        "D": String,
        "dict": String,
        "ipaddr": String,
        "ipaddress": String,
        "iprange": String,
        "bytes": String,
        "json": String,
        "I64": Float,
    }
    if len(type_str) == 0 or type_str[0] != "L":
        return types[type_str](default_value)
    else:
        subtype = type_str[1:]
        # print(subtype, default_value)
        return List(default_value, object)


class Email:
    def __init__(self, default=None):
        if not default:
            default = ""
        self.default = default
        self.regex = r"^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$"

    def check(self, value):
        """Check whether provided value is a valid email representation
        Arguments:
            value (str)
        Returbs:
            Boolean expresion"""
        return re.search(self.regex, value) is not None

    def from_str(self, value):
        """get the value from the string
        Arguments:
            value (str)
        Returbs:
            value (str)"""
        return value


class Path:
    def __init__(self, default=None):
        if not default:
            default = ""
        self.default = default
        self.regex = r"^(/[^/ ]*)+/?$"

    def check(self, value):
        """Check whether provided value is a valid path representation
        Arguments:
            value (str)
        Returbs:
            Boolean expresion"""
        return re.search(self.regex, value) is not None

    def from_str(self, value):
        """get the value from the string
        Arguments:
            value (str)
        Returbs:
            value (str)"""
        return value


class URL:
    def __init__(self, default=None):
        if not default:
            default = ""
        self.default = default
        self.regex = r"^(https?|ftp)://[^\s/$.?#].[^\s]*$"

    def check(self, value):
        """Check whether provided value is a valid URL representation
        Arguments:
            value (str)
        Returbs:
            Boolean expresion"""
        return re.search(self.regex, value) is not None

    def from_str(self, value):
        """get the value from the string
        Arguments:
            value (str)
        Returbs:
            value (str)"""
        return value


class Tel:
    def __init__(self, default=None):
        if not default:
            default = ""
        self.default = default
        self.regex = r"^\+?[0-9]{6,15}(?:x[0-9]+)?$"

    def check(self, value):
        """Check whether provided value is a valid Telephone number representation
        Arguments:
            value (str)
        Returbs:
            Boolean expresion"""
        value = self._clean(value)
        return re.search(self.regex, value) is not None

    def from_str(self, value):
        """get the value from the string
        Arguments:
            value (str)
        Returbs:
            value (str)"""
        return value

    def _clean(self, value):
        if value is not None:
            value = value.replace(",", "")
            value = value.replace("-", "")
            value = value.replace("(", "")
            value = value.replace(")", "")
            value = value.replace(" ", "")
            return value


class IPAddress:
    def __init__(self, default=None):
        if not default:
            default = ""
        self.default = default

    def check(self, value):
        """Check whether provided value is a valid IPaddress representation
        Arguments:
            value (str)
        Returns:
            Boolean expresion"""
        import ipaddress

        try:
            ipaddress.IPv4Address(value)
            return True
        except ipaddress.AddressValueError:
            return False

    def from_str(self, value):
        """get the value from the string
        Arguments:
            value (str)
        Returns:
            value (str)"""
        return value


class DateTime:
    """Supported format: yyyy-mm-dd hh:mm"""

    def __init__(self, default=None):
        if not default:
            default = ""
        self.default = default
        self.regex = r"^[0-9]{4}-(0[1-9]|1[0-2])-(0[1-9]|[1-2][0-9]|3[0-1]) (2[0-3]|[01][0-9]):[0-5][0-9]$"

    def check(self, value):
        """Check whether provided value is a valid datetime representation
        Arguments:
            value (str)
        Returbs:
            Boolean expresion"""
        return re.search(self.regex, value) is not None

    def from_str(self, value):
        """get the value from the string
        Arguments:
            value (str)
        Returbs:
            value (str)"""
        return value


class Date:
    """Support yyyy-mm-dd format"""

    def __init__(self, default=None):
        if not default:
            default = ""
        self.default = default
        self.regex = r"[0-9]{4}-(0[1-9]|1[0-2])-(0[1-9]|[1-2][0-9]|3[0-1])"

    def check(self, value):
        """Check whether provided value is a valid date representation
        Arguments:
            value (str)
        Returbs:
            Boolean expresion"""
        return re.search(self.regex, value) is not None

    def from_str(self, value):
        """get the value from the string
        Arguments:
            value (str)
        Returbs:
            value (str)"""
        return value


class Time:
    """Supported format : hh:mm"""

    def __init__(self, default=None):
        if not default:
            default = ""
        self.default = default
        self.regex = r"(2[0-3]|[01][0-9]):[0-5][0-9]"

    def check(self, value):
        """Check whether provided value is a valid time representation
        Arguments:
            value (str)
        Returbs:
            Boolean expresion"""
        return re.search(self.regex, value) is not None

    def from_str(self, value):
        """Get the value from string
            value (str)
        Returbs:
            value (str)"""
        return value


class Duration:
    """Supported format : (n)y (n)m (n)d (n)h (n)m (n)s"""

    def __init__(self, default=None):
        if not default:
            default = ""
        self.default = default
        self.regex = r"((\d{1,2}y\s?)?(\d{1,2}m\s?)?(\d{1,2}d\s?)?(\d{1,2}h\s?)?(\d{1,2}m\s?)?(\d{1,2}s\s?)?)|\d{1,2}"

    def check(self, value):
        """Check whether provided value is a valid duration representation
        Arguments:
            value (str)
        Returbs:
            Boolean expresion"""
        return re.search(self.regex, value) is not None

    def from_str(self, value):
        """Get the value from string
            value (str)
        Returbs:
            value (str)"""
        return value