import importlib
import inspect
import json
import pkgutil
import threading
from typing import Optional

import platypush.backend  # lgtm [py/import-and-import-from]
import platypush.plugins  # lgtm [py/import-and-import-from]
import platypush.message.event  # lgtm [py/import-and-import-from]
import platypush.message.response  # lgtm [py/import-and-import-from]

from platypush.backend import Backend
from platypush.config import Config
from platypush.plugins import Plugin, action
from platypush.message.event import Event
from platypush.message.response import Response

from ._model import (
    BackendModel,
    EventModel,
    PluginModel,
    ProcedureEncoder,
    ResponseModel,
)


class InspectPlugin(Plugin):
    """
    This plugin can be used to inspect platypush plugins and backends
    """

    def __init__(self, **kwargs):
        super().__init__(**kwargs)
        self._plugins = {}
        self._backends = {}
        self._events = {}
        self._responses = {}
        self._plugins_lock = threading.RLock()
        self._backends_lock = threading.RLock()
        self._events_lock = threading.RLock()
        self._responses_lock = threading.RLock()
        self._html_doc = False

    def _init_plugins(self):
        package = platypush.plugins
        prefix = package.__name__ + '.'

        for _, modname, _ in pkgutil.walk_packages(
            path=package.__path__, prefix=prefix, onerror=lambda _: None
        ):
            try:
                module = importlib.import_module(modname)
            except Exception as e:
                self.logger.warning('Could not import module %s: %s', modname, e)
                continue

            for _, obj in inspect.getmembers(module):
                if inspect.isclass(obj) and issubclass(obj, Plugin):
                    model = PluginModel(
                        plugin=obj, prefix=prefix, html_doc=self._html_doc
                    )
                    if model.name:
                        self._plugins[model.name] = model

    def _init_backends(self):
        package = platypush.backend
        prefix = package.__name__ + '.'

        for _, modname, _ in pkgutil.walk_packages(
            path=package.__path__, prefix=prefix, onerror=lambda _: None
        ):
            try:
                module = importlib.import_module(modname)
            except Exception as e:
                self.logger.debug('Could not import module %s: %s', modname, e)
                continue

            for _, obj in inspect.getmembers(module):
                if inspect.isclass(obj) and issubclass(obj, Backend):
                    model = BackendModel(
                        backend=obj, prefix=prefix, html_doc=self._html_doc
                    )
                    if model.name:
                        self._backends[model.name] = model

    def _init_events(self):
        package = platypush.message.event
        prefix = package.__name__ + '.'

        for _, modname, _ in pkgutil.walk_packages(
            path=package.__path__, prefix=prefix, onerror=lambda _: None
        ):
            try:
                module = importlib.import_module(modname)
            except Exception as e:
                self.logger.debug('Could not import module %s: %s', modname, e)
                continue

            for _, obj in inspect.getmembers(module):
                if type(obj) == Event:  # pylint: disable=unidiomatic-typecheck
                    continue

                if inspect.isclass(obj) and issubclass(obj, Event) and obj != Event:
                    event = EventModel(
                        event=obj, html_doc=self._html_doc, prefix=prefix
                    )
                    if event.package not in self._events:
                        self._events[event.package] = {event.name: event}
                    else:
                        self._events[event.package][event.name] = event

    def _init_responses(self):
        package = platypush.message.response
        prefix = package.__name__ + '.'

        for _, modname, _ in pkgutil.walk_packages(
            path=package.__path__, prefix=prefix, onerror=lambda _: None
        ):
            try:
                module = importlib.import_module(modname)
            except Exception as e:
                self.logger.debug('Could not import module %s: %s', modname, e)
                continue

            for _, obj in inspect.getmembers(module):
                if type(obj) == Response:  # pylint: disable=unidiomatic-typecheck
                    continue

                if (
                    inspect.isclass(obj)
                    and issubclass(obj, Response)
                    and obj != Response
                ):
                    response = ResponseModel(
                        response=obj, html_doc=self._html_doc, prefix=prefix
                    )
                    if response.package not in self._responses:
                        self._responses[response.package] = {response.name: response}
                    else:
                        self._responses[response.package][response.name] = response

    @action
    def get_all_plugins(self, html_doc: Optional[bool] = None):
        """
        :param html_doc: If True then the docstring will be parsed into HTML (default: False)
        """
        with self._plugins_lock:
            if not self._plugins or (
                html_doc is not None and html_doc != self._html_doc
            ):
                self._html_doc = html_doc
                self._init_plugins()

            return json.dumps(
                {name: dict(plugin) for name, plugin in self._plugins.items()}
            )

    @action
    def get_all_backends(self, html_doc: Optional[bool] = None):
        """
        :param html_doc: If True then the docstring will be parsed into HTML (default: False)
        """
        with self._backends_lock:
            if not self._backends or (
                html_doc is not None and html_doc != self._html_doc
            ):
                self._html_doc = html_doc
                self._init_backends()

            return json.dumps(
                {name: dict(backend) for name, backend in self._backends.items()}
            )

    @action
    def get_all_events(self, html_doc: Optional[bool] = None):
        """
        :param html_doc: If True then the docstring will be parsed into HTML (default: False)
        """
        with self._events_lock:
            if not self._events or (
                html_doc is not None and html_doc != self._html_doc
            ):
                self._html_doc = html_doc
                self._init_events()

            return json.dumps(
                {
                    package: {name: dict(event) for name, event in events.items()}
                    for package, events in self._events.items()
                }
            )

    @action
    def get_all_responses(self, html_doc: Optional[bool] = None):
        """
        :param html_doc: If True then the docstring will be parsed into HTML (default: False)
        """
        with self._responses_lock:
            if not self._responses or (
                html_doc is not None and html_doc != self._html_doc
            ):
                self._html_doc = html_doc
                self._init_responses()

            return json.dumps(
                {
                    package: {name: dict(event) for name, event in responses.items()}
                    for package, responses in self._responses.items()
                }
            )

    @action
    def get_procedures(self) -> dict:
        """
        Get the list of procedures installed on the device.
        """
        return json.loads(json.dumps(Config.get_procedures(), cls=ProcedureEncoder))

    @action
    def get_config(self, entry: Optional[str] = None) -> Optional[dict]:
        """
        Return the configuration of the application or of a section.

        :param entry: [Optional] configuration entry name to retrieve (e.g. ``workdir`` or ``backend.http``).
        :return: The requested configuration object.
        """
        if entry:
            return Config.get(entry)

        cfg = Config.get()
        return cfg


# vim:sw=4:ts=4:et: