[ Avaa Bypassed ]

from .utils import Singleton


class ExecutionEnvironment(metaclass=Singleton):
    """This class hold all the system environment based elements.

    The goal is to abstract all differences between system and
    isolate them in one point.

    This is a singleton.
    """

    def __init__(self):
        self.__keyring = None
        self.__api_session = None

        self.__connection_backend = None
        self.__killswitch = None
        self.__ipv6leak = None

        self.__settings = None
        self.__connection_metadata = None
        self.__api_metadata = None
        self.__accounting = None
        self.__netzone = None

    @property
    def keyring(self):
        """Return the keyring to use"""
        if self.__keyring is None:
            from .keyring import KeyringBackend
            self.__keyring = KeyringBackend.get_default()
        return self.__keyring

    @keyring.setter
    def keyring(self, newvalue):
        self.__keyring = newvalue

    @property
    def connection_backend(self):
        """Return the connection backend to use (nm, etc.)"""
        if self.__connection_backend is None:
            from .connection_backend import ConnectionBackend
            self.__connection_backend = ConnectionBackend.get_backend()
        return self.__connection_backend

    @connection_backend.setter
    def connection_backend(self, newvalue):
        self.__connection_backend = newvalue

    @property
    def api_session(self):
        """Return the session to the API"""
        if self.__api_session is None:
            from .session import APISession
            self.__api_session = APISession()
        return self.__api_session

    @api_session.setter
    def api_session(self, newvalue):
        self.__api_session = newvalue

    @property
    def killswitch(self):
        """Return the session to the API"""
        if self.__killswitch is None:
            from .killswitch import KillSwitch
            self.__killswitch = KillSwitch()
        return self.__killswitch

    @killswitch.setter
    def killswitch(self, newvalue):
        self.__killswitch = newvalue

    @property
    def ipv6leak(self):
        """Return the session to the API"""
        if self.__ipv6leak is None:
            from .killswitch import IPv6LeakProtection
            self.__ipv6leak = IPv6LeakProtection()
        return self.__ipv6leak

    @ipv6leak.setter
    def ipv6leak(self, newvalue):
        self.__ipv6leak = newvalue

    @property
    def settings(self):
        """Return the session to the API"""
        if self.__settings is None:
            from .user_settings import SettingsBackend
            self.__settings = SettingsBackend.get_backend()
        return self.__settings

    @settings.setter
    def settings(self, newvalue):
        self.__settings = newvalue

    @property
    def connection_metadata(self):
        """Return the session to the API"""
        if self.__connection_metadata is None:
            from .metadata import ConnectionMetadataBackend
            self.__connection_metadata = ConnectionMetadataBackend.get_backend() # noqa
        return self.__connection_metadata

    @connection_metadata.setter
    def connection_metadata(self, newvalue):
        self.__connection_metadata = newvalue

    @property
    def netzone(self):
        """Return the session to the API"""
        if self.__netzone is None:
            from .metadata import NetzoneMetadataBackend
            self.__netzone = NetzoneMetadataBackend.get_backend() # noqa
        return self.__netzone

    @netzone.setter
    def netzone(self, newvalue):
        self.__netzone = newvalue

    @property
    def accounting(self):
        """Return the session to the API"""
        if self.__accounting is None:
            from .accounting import Accounting
            self.__accounting = Accounting.get_backend() # noqa
        return self.__accounting

    @accounting.setter
    def accounting(self, newvalue):
        self.__accounting = newvalue


    @property
    def user_agent(self):
        from ..constants import APP_VERSION
        """Get user agent to use when communicating with API

        Returns:
            string: User-Agent
        """
        try:
            import distro
            distribution, version, _ = distro.linux_distribution()
        except ImportError:
            distribution, version = "Linux", "unknown distribution", "unknown version"

        return "ProtonVPN/{} (Linux; {}/{})".format(APP_VERSION, distribution, version)