import logging
from typing import Dict

logger = logging.getLogger(__name__)


class Param:
    def __init__(
        self,
        name,
        ptype=str,
        default_value=None,
        required=True,
        values=None,
        configurable=True,
        idx=None,
    ):
        self.name = name
        self.ptype = ptype
        self.default_value = default_value
        self.required = required
        self.values = values
        self.configurable = configurable
        self.idx = idx

    def valid(self, value=None):
        try:
            # assign default value to None
            if value is None:
                value = self.default_value
            # if required, value shouldn't be none
            if self.required and value is None:
                return False
            if value is not None:
                # chek, that every element of the value is in values list.
                if self.ptype == list and self.values:
                    for val in value:
                        if val not in self.values:
                            return False
                else:
                    # chek, that value is in values list.
                    if self.values and value not in self.values:
                        return False
                # if value is not required type, validate, that it can be converted
                if not isinstance(value, self.ptype):
                    try:
                        _ = self.ptype(value)
                    except ValueError:
                        return False
        except Exception as e:
            logger.exception(e)
            return False

        return True

    def __call__(self, args: Dict) -> Dict:
        value = args.get(self.name, None)
        if self.valid(value):
            if value is None:
                return {self.name: self.default_value}
            else:
                return {self.name: value}
        else:
            raise RuntimeError(f"Parameter {self.name} has invalid value {value}")

    def json(self, value):
        return {f"{self.name}": self.ptype(value)}