from typing import Optional, List, Type, Dict, Any

class MetaConstant(type):
    def __repr__(cls) -> str:
        parent = cls.mro()[1]
        if parent == object:
            return cls.__name__
        else:
            repr = f"{parent.__name__}.{cls.__name__}"
            if hasattr(cls, "_value"):
                repr += f'(\'{cls._value}\')'
            return repr


class Constant(metaclass=MetaConstant):
    _value: str
    def __new__(
        cls, val: Optional[str] = None, _visited: Optional[List[Type]] = None
    ) -> "Constant":
        if _visited is None:
            _visited = []
        _value: Optional[str] = getattr(cls, "_value", None)
        if _value is None and val is None:
            msg = f'Abstract {cls.__bases__[0].__name__} "{cls.__name__}" cannot be instantiated'
            raise TypeError(msg)
        elif _value is None:
            # DFS through the class tree to find a matching subclass.
            for child in cls.__subclasses__():
                try:
                    if match := child.__new__(child, val, _visited=_visited):
                        return match
                except:
                    continue
            # Compile a list of the subclassese we've tried for a better exception message.
            valids = ", ".join([f"{c}" for c in _visited])
            msg = f"invalid {cls.__name__}:'{val}' is not valid for any {cls.__name__}s: [{valids}]"
            raise ValueError(msg)
        elif val is None:
            # Default case.
            return super(Constant, cls).__new__(cls)
        else:
            # Base case for DFS.
            if _value == val:
                return super(Constant, cls).__new__(cls)
            else:
                _visited.append(cls)
                msg = f"invalid value for {cls}: '{val}'"
                raise ValueError(msg)

    def __init_subclass__(cls) -> None:
        """Register subclass as parent attribute
        Ex. Datacenter.fra4
        """
        setattr(type(cls), cls.__name__, cls)

    @property
    def value(self) -> str:
        return self._value

    def __repr__(self) -> str:
        return "Value: "+self._value

    def __str__(self) -> str:
        return self._value

    def __eq__(self, other:Any) -> bool:
        return self._value == other._value

class Location(Constant):
    DataCenter: "DataCenter"
    AvailabilityZone: "AvailabilityZone"

class DataCenter(Location):
    ams1: "ams1"
    lon1: "lon1"

class ams1(DataCenter):
    _value = "ams1"

class lon1(DataCenter):
    _value = "lon1"

class AvailabilityZone(Location):
    west1_a: "west1_a"
    west2_a: "west2_a"
    
class west1_a(AvailabilityZone):
    _value = "west1-a"
    
class west2_a(AvailabilityZone):
    _value = "west2-a"

def print_my_location(location:Location):
    print(location)

from multimethod import multimethod

DOMAIN = "moll.dev"

@multimethod # type: ignore[no-redef]
def generate_vm_name(vmname:str, location:Location):
    raise ValueError(f"Location '{type(location)}' not supported yet!")

@multimethod # type: ignore[no-redef]
def generate_vm_name(vmname:str, location:DataCenter) -> str:
    print(type(location))
    return f"{vmname}.{location}.{DOMAIN}"    

@multimethod
def generate_vm_name(vmname:str, location:AvailabilityZone) -> str:
    print(type(location))
    return f"{vmname}-{location}.{DOMAIN}"

class Environment(Constant):
    Prod:"Prod"
    Dev:"Dev"
    PCC:"PCC"
    
class Prod(Environment):
    _value = "prod"

class Dev(Environment):
    _value = "dev"

class PCC(Environment):
    _value = "pcc"

@multimethod # type: ignore[no-redef]
def check(environment:Environment, location:Location):
    # log f"Not a supported deployment combination ({environment}, {location})!"
    return False

@multimethod # type: ignore[no-redef]
def check(environment:Prod, location:Location):
    return True

@multimethod # type: ignore[no-redef]
def check(environment:Dev, location:AvailabilityZone):
    return True

@multimethod # type: ignore[no-redef]
def check(environment:Dev, location:AvailabilityZone):
    return True

@multimethod # type: ignore[no-redef]
def check(environment:PCC, location:ams1):
    return True