# -*- coding: utf-8 -*-
# Copyright © Cloud Linux GmbH & Cloud Linux Software, Inc 2010-2020 All Rights Reserved
#
# Licensed under CLOUD LINUX LICENSE AGREEMENT
# http://cloudlinux.com/docs/LICENSE.TXT


# TODO: convert this file into python package
#       and move logic of modules manipulations here
import json
import os
import argparse
from pathlib import Path
from typing import Dict

import cpanel
from clcommon.clwpos_lib import get_wp_cache_plugin
from clwpos import gettext as _, constants
from clwpos.cl_wpos_exceptions import WposError, WpCliCommandError
from clwpos.constants import MINIMUM_SUPPORTED_PHP_OBJECT_CACHE, \
    CL_DOC_USER_PLUGIN
from clwpos.utils import is_conflict_modules_installed, PHP
from cpanel import wordpress, WordpressError
from dataclasses import dataclass, field, asdict
from enum import Enum


class PluginStatus(Enum):
    UNINSTALLED = 'uninstalled'
    ACTIVE = 'active'
    INACTIVE = 'inactive'


@dataclass
class Issue:
    """
    Generic class for keeping compatibility/misconfiguration issues
    """
    header: str
    description: str
    fix_tip: str

    context: Dict[str, str] = field(default_factory=dict)

    @property
    def dict_repr(self):
        return asdict(self)


class UniqueId:
    PHP_NOT_SUPPORTED = 'PHP_NOT_SUPPORTED'
    PLUGIN_CONFLICT = 'PLUGIN_CONFLICT'
    WORDPRESS_MULTISITE_ENABLED = 'WORDPRESS_MULTISITE_ENABLED'
    MISCONFIGURED_WORDPRESS = 'MISCONFIGURED_WORDPRESS'

    WEBSERVER_NOT_SUPPORTED = 'WEBSERVER_NOT_SUPPORTED'
    PHP_MISCONFIGURATION = 'PHP_MISCONFIGURATION'
    UNCOMPATIBLE_WORDPRESS_VERSION = 'UNCOMPATIBLE_WORDPRESS_VERSION'

    CLOUDLINUX_MODULE_ALREADY_ENABLED = 'CLOUDLINUX_MODULE_ALREADY_ENABLED'


@dataclass
class CompatibilityIssue(Issue):
    """
    For compatibility issues
    """
    unique_id: str = None
    telemetry: Dict[str, str] = field(default_factory=dict)

    type: str = 'incompatibility'

    @property
    def dict_repr(self):
        representation = asdict(self)
        representation.pop('unique_id')
        representation.pop('telemetry')
        return representation


@dataclass
class MisconfigurationIssue(Issue):
    """
    For misconfiguration issues
    """
    type: str = 'misconfiguration'


class Feature(str):
    """
    Helper class which hides differences of optimization features behind abstract methods.
    """
    NAME = ''
    WP_PLUGIN_NAME = ''

    def __new__(cls, *args, **kwargs):
        if cls != Feature:
            return str.__new__(cls, *args)

        classes = {
            "object_cache": _ObjectCache,

            # yep, site_optimization and accelerate_wp names are same thing
            "site_optimization": _SiteOptimization,
            "accelerate_wp": _SiteOptimization
        }

        try:
            return classes[args[0]](*args)
        except KeyError:
            raise argparse.ArgumentTypeError(f"No such feature: {args[0]}.")

    @classmethod
    def optimization_feature(cls):
        return cls(cls.NAME.lower())

    @classmethod
    def redis_daemon_required(cls):
        raise NotImplementedError

    @classmethod
    def collect_docroot_issues(cls, wpos_user_obj, doc_root_info, allowed_modules=None):
        raise NotImplementedError

    @classmethod
    def is_php_supported(cls, php_version: PHP):
        raise NotImplementedError

    @classmethod
    def minimum_supported_wp_version(cls):
        raise NotImplementedError

    @staticmethod
    def collect_wordpress_issues(self, wordpress: Dict, docroot: str, module_is_enabled: bool):
        raise NotImplementedError

    @staticmethod
    def to_interface_name():
        raise NotImplementedError

    @staticmethod
    def get_wp_plugin_status(wordpress_abs_path, plugin_name) -> PluginStatus:
        """
        Get information about WordPress plugin current status.

        :param wordpress_abs_path:
            absolute path to wordpress installation
        :param plugin_name:
            name of plugin as it listed in plugins directory
        :return:
            PluginStatus
        """
        plugins_data = wordpress(wordpress_abs_path, 'plugin', 'list',
                                 '--name=%s' % plugin_name, '--json')
        if isinstance(plugins_data, WordpressError):
            raise WposError(message=plugins_data.message,
                            context=plugins_data.context)

        try:
            response = json.loads(plugins_data)
        except (ValueError, TypeError, json.JSONDecodeError) as e:
            raise WposError(
                message=_(
                    'Malformed plugins information received from wp-cli. '
                    'Raw response is %(response)s.'),
                context={'response': plugins_data},
                details=str(e)
            )

        # in case of missing plugin wp-cli returns empty dict
        if not response:
            return PluginStatus.UNINSTALLED

        # in any other case we get list of one element with parameters
        return PluginStatus(response[0]['status'])

    @classmethod
    def _get_wp_plugin_compatibility_issues(cls, docroot, wordpress):
        """
        Get issues that relates to currently installed WP plugin
        or None if everything is ok
        """
        try:
            plugin_status = cls.get_wp_plugin_status(
                wordpress_abs_path=os.path.join(docroot, wordpress["path"]),
                plugin_name=cls.WP_PLUGIN_NAME)
        except WposError as e:
            return CompatibilityIssue(
                header=_('Unexpected WordPress error'),
                description=_(
                    'Unable to detect the WordPress plugins '
                    'due to unexpected error. '
                    '\n\n'
                    'Technical details:\n%(error_message)s.\n'
                    '\nMost likely WordPress installation is not working properly.'
                ),
                fix_tip=_(
                    'Check that your website is working properly – '
                    'try to run the specified command to find any obvious '
                    'errors in the WordPress configuration. '
                    'Otherwise, try to fix other issues first - '
                    'it may help to resolve this issue as well.'
                ),
                context=dict(
                    error_message=e.message % e.context
                ),
                unique_id=UniqueId.MISCONFIGURED_WORDPRESS,
                telemetry=dict(
                    error_message=e.message % e.context
                )
            )

        return cls._get_issues_from_wp_plugin_status(plugin_status)

    @classmethod
    def _get_issues_from_wp_plugin_status(cls, plugin_status):
        raise NotImplementedError


class _ObjectCache(Feature):
    """Implementation for object caching"""

    NAME = 'OBJECT_CACHE'
    WP_PLUGIN_NAME = 'redis-cache'

    @classmethod
    def redis_daemon_required(cls):
        return True

    @staticmethod
    def to_interface_name():
        return 'object_cache'

    @classmethod
    def _get_issues_from_wp_plugin_status(cls, plugin_status):
        """
        Get issue that relates to currently installed redis-cache
        plugin or None if everything is ok
        """
        if plugin_status == PluginStatus.INACTIVE:
            return MisconfigurationIssue(
                header=_('"Redis Object Cache" plugin is deactivated'),
                description=_('Object caching is enabled, but the '
                              '"Redis Object Cache" plugin is deactivated in Wordpress admin page. Caching does not work'),
                fix_tip=_('Activate the Redis Object Cache plugin in the Wordpress admin page and '
                          'enable Object Cache Drop-in in the Redis Object Cache plugin settings. '
                          'As an alternative, rollback the feature and apply it again.')
            )
        elif plugin_status == PluginStatus.ACTIVE:
            return MisconfigurationIssue(
                header=_('The Object Cache Drop-in not installed'),
                description=_('The Object Cache Drop-In is not enabled. Caching does not work'),
                fix_tip=_('Enable the Object Cache using the Redis Object Cache plugin '
                          'settings page of Wordpress Admin. '
                          'As an alternative, rollback the feature and apply it again.')
            )
        elif plugin_status == PluginStatus.UNINSTALLED:
            return MisconfigurationIssue(
                header=_('"Redis Object Cache" plugin is not installed'),
                description=_('The "Redis Object Cache" WordPress plugin is not installed. '
                              'Caching does not work'),
                fix_tip=_('Rollback the feature and apply it again. '
                          'Contact your administrator if the issue persists.')
            )
        else:
            raise WposError(_('Unexpected plugin status: %(status)s'), context=dict(status=plugin_status))

    @classmethod
    def collect_docroot_issues(cls, wpos_user_obj, doc_root_info, allowed_modules=None):
        """
        Collects incompatibilities related to docroot (non-supported handler, etc)
        for object caching.
        """
        issues = []
        php_version = doc_root_info['php_version']
        is_modules_allowed = None
        supported_php_versions = wpos_user_obj.supported_php_versions[OBJECT_CACHE_FEATURE]
        header__, fix_tip__, description__, uniq_id__, telemetry__ = None, None, None, None, None

        if allowed_modules is not None:
            is_modules_allowed = 'object_cache' in allowed_modules

        if not cls.is_php_supported(php_version):
            header__ = _('PHP version is not supported')
            fix_tip__ = _('Please, set or ask your system administrator to set one of the '
                          'supported PHP versions: %(compatible_versions)s')
            description__ = _('Non supported PHP version %(php_version)s currently is used.')
            uniq_id__ = UniqueId.PHP_NOT_SUPPORTED
            telemetry__ = dict(
                reason='PHP_VERSION_TOO_LOW',
                php_version=php_version,
                supported_php_versions=supported_php_versions
            )

        elif php_version not in cpanel.get_cached_php_versions_with_redis_present():
            header = _('Redis extension is not installed for selected php version')
            fix_tip = _('Please, install or ask your system administrator to install redis extension '
                        'for current %(php_version)s version, or use one of the compatible php versions: '
                        '%(compatible_versions)s for the domain.')
            description = _('Redis PHP extension is required for optimization feature, but not installed for '
                            'selected PHP version: %(php_version)s.')
            if not is_modules_allowed:
                issues.append(MisconfigurationIssue(
                    header=header,
                    fix_tip=fix_tip,
                    description=description,
                    context=dict(php_version=php_version, compatible_versions=supported_php_versions)))
            else:
                header__ = header
                fix_tip__ = fix_tip
                description__ = description
                uniq_id__ = UniqueId.PHP_NOT_SUPPORTED
                telemetry__ = dict(
                    php_version=php_version,
                    reason='PHP_REDIS_NOT_INSTALLED',
                    supported_php_versions=supported_php_versions
                )

        elif php_version not in cpanel.get_cached_php_versions_with_redis_loaded():
            header = _('Redis extension is not loaded for selected php version')
            fix_tip = _('Please, load or ask your system administrator to load redis extension '
                        'for current %(php_version)s version, or use one of the compatible php versions: '
                        '%(compatible_versions)s for the domain.')
            description = _('Redis PHP extension is required for optimization feature, but not loaded for '
                            'selected PHP version: %(php_version)s.')
            if not is_modules_allowed:
                issues.append(MisconfigurationIssue(
                    header=header,
                    fix_tip=fix_tip,
                    description=description,
                    context=dict(php_version=php_version, compatible_versions=supported_php_versions)))
            else:
                header__ = header
                fix_tip__ = fix_tip
                description__ = description
                uniq_id__ = UniqueId.PHP_NOT_SUPPORTED
                telemetry__ = dict(
                    php_version=php_version,
                    reason='PHP_REDIS_NOT_LOADED',
                    supported_php_versions=supported_php_versions
                )

        if not supported_php_versions:
            fix_tip__ = _('Please, ask your system administrator to setup at least '
                          'one of the recommended PHP version in accordance with docs (%(docs_url)s).')

        if header__ is not None:
            issues.append(
                CompatibilityIssue(
                    header=header__,
                    description=description__,
                    fix_tip=fix_tip__,
                    context=dict(php_version=php_version,
                                 compatible_versions=', '.join(supported_php_versions),
                                 docs_url=constants.CL_DOC_USER_PLUGIN),
                    unique_id=uniq_id__,
                    telemetry=telemetry__
                )
            )

        if doc_root_info["php_handler"] not in wpos_user_obj.supported_handlers:
            issues.append(
                CompatibilityIssue(
                    header=_('Unsupported PHP handler'),
                    description=_('Website uses unsupported PHP handler. Currently supported '
                                  'handler(s): %(supported_handlers)s.'),
                    fix_tip=_('Please, set or ask your system administrator to set one of the '
                              'supported PHP handlers for the domain: %(supported_handlers)s. '
                              'Or keep watching our blog: %(blog_url)s for supported handlers list updates.'),
                    context={
                        'supported_handlers': ", ".join(wpos_user_obj.supported_handlers),
                        'blog_url': 'https://blog.cloudlinux.com/'
                    },
                    unique_id=UniqueId.PHP_NOT_SUPPORTED,
                    telemetry=dict(
                        reason='PHP_UNSUPPORTED_HANDLER',
                        handler=doc_root_info["php_handler"],
                        supported_handlers=wpos_user_obj.supported_handlers,
                        php_version=php_version
                    )
                )
            )

        incompatible_php_modules = {}
        incompatible_module = 'snuffleupagus'
        if incompatible_php_modules.get(php_version) == incompatible_module or \
                is_conflict_modules_installed(php_version, incompatible_module):
            incompatible_php_modules[php_version] = incompatible_module
            issues.append(
                CompatibilityIssue(
                    header=_('Unsupported PHP module is loaded'),
                    description=_('Incompatible PHP module "%(incompatible_module)s" is currently used.'),
                    fix_tip=_('Please, disable or remove "%(incompatible_module)s" PHP extension.'),
                    context=dict(incompatible_module=incompatible_module),
                    unique_id=UniqueId.PHP_NOT_SUPPORTED,
                    telemetry=dict(
                        handler=doc_root_info["php_handler"],
                        supported_handlers=wpos_user_obj.supported_handlers,
                        php_version=php_version
                    )
                ))

        return issues

    @classmethod
    def is_php_supported(cls, php_version: PHP):
        """
        Check if passed php version >= minimum PHP version
        supported by object caching.
        """
        return php_version.digits >= MINIMUM_SUPPORTED_PHP_OBJECT_CACHE

    @classmethod
    def minimum_supported_wp_version(cls):
        return constants.MINIMUM_SUPPORTED_WP_OBJECT_CACHE

    @classmethod
    def collect_wordpress_issues(cls, self, wordpress: Dict, docroot: str, module_is_enabled: bool):
        issues = []
        wp_dir = Path(docroot).joinpath(wordpress["path"])
        wp_content_dir = wp_dir.joinpath("wp-content")
        plugin_type = "object-cache"
        detected_object_cache_plugin = get_wp_cache_plugin(wp_dir, plugin_type)

        if module_is_enabled:
            if detected_object_cache_plugin != "redis-cache":
                issue = cls._get_wp_plugin_compatibility_issues(docroot, wordpress)
                if issue:
                    issues.append(issue)

            if not self.is_redis_running:
                issues.append(
                    MisconfigurationIssue(
                        header=_('Redis is not running'),
                        description=_('Object caching is enabled, but redis process is not running.'),
                        fix_tip=_('Redis will start automatically in 5 minutes. '
                                  'If the issue persists - contact your system administrator and report this issue')
                    )
                )
            try:
                cpanel.diagnose_redis_connection_constants(docroot, wordpress['path'])
            except WpCliCommandError as e:
                issues.append(
                    MisconfigurationIssue(
                        header=_('Unable to identify redis constants in wordpress config'),
                        description=_('wp-cli utility returns malformed response, reason: "%(reason)s"'),
                        fix_tip=_('Please, try to check executed command and fix possible issues with it. '
                                  'If issue persists - please, contact CloudLinux support.'),
                        context=dict(
                            reason=e.message % e.context
                        )
                    )
                )
            except WposError as e:
                issues.append(
                    MisconfigurationIssue(
                        header=_('Missed redis constants in site config'),
                        description=_('WordPress config does not have needed constants '
                                      'for redis connection establishment.\n'
                                      'Details: %(reason)s'),
                        fix_tip=_('Please, try to disable and enable plugin again. '
                                  'If issue persists - please, contact CloudLinux support.'),
                        context=dict(
                            reason=e.message % e.context
                        )
                    )
                )
        if detected_object_cache_plugin == "Unknown":
            drop_in_file = wp_content_dir.joinpath(f'{plugin_type}.php')
            issues.append(
                CompatibilityIssue(
                    header=_('Conflicting object caching plugin enabled'),
                    description=_('Unknown custom object caching plugin is already enabled'),
                    fix_tip=_(f'Remove the drop-in ({drop_in_file}) file from the WordPress '
                              f'instance because it conflicts with AccelerateWP object caching.'),
                    unique_id=UniqueId.PLUGIN_CONFLICT,
                    telemetry=dict(
                        reason='OBJECT_CACHE_ALREADY_ENABLED',
                        plugin=detected_object_cache_plugin
                    )
                ))
        elif detected_object_cache_plugin == "w3-total-cache":
            issues.append(
                CompatibilityIssue(
                    header=_('Object Caching of W3 Total Cache plugin is incompatible'),
                    description=_('WordPress website already has Object Caching feature enabled '
                                  'with caching backend configured by the the W3 Total Cache plugin.'),
                    fix_tip=_('Deactivate Object Caching in W3 Total Cache plugin settings.'),
                    context=dict(),
                    unique_id=UniqueId.PLUGIN_CONFLICT,
                    telemetry=dict(
                        reason='OBJECT_CACHE_ALREADY_ENABLED',
                        plugin=detected_object_cache_plugin
                    )
                ))
        elif detected_object_cache_plugin not in (None, "redis-cache"):
            issues.append(
                CompatibilityIssue(
                    header=_('Conflicting object caching plugin enabled'),
                    description=_('The "%(detected_wp_plugin)s" plugin conflicts with AccelerateWP object caching.'),
                    fix_tip=_('Deactivate object caching in the plugin settings or completely uninstall'
                              'the conflicting plugin using the WordPress administration interface.'),
                    context=dict(detected_wp_plugin=detected_object_cache_plugin),
                    unique_id=UniqueId.PLUGIN_CONFLICT,
                    telemetry=dict(
                        reason='OBJECT_CACHE_ALREADY_ENABLED',
                        plugin=detected_object_cache_plugin
                    )
                ))
        try:
            if not self.check_installed_roc_plugin(os.path.join(docroot, wordpress['path'])):
                issues.append(
                    CompatibilityIssue(
                        header=_('Another Redis Object Cache plugin is installed'),
                        description=_('Non CloudLinux Redis Object Cache is installed for the website'),
                        fix_tip=_('Uninstall Redis Object Cache plugin using WordPress administration page'),
                        unique_id=UniqueId.PLUGIN_CONFLICT,
                        telemetry=dict(
                            reason='OBJECT_CACHE_ALREADY_ENABLED',
                            plugin=detected_object_cache_plugin
                        )
                    ))
        except WpCliCommandError as e:
            issues.append(
                MisconfigurationIssue(
                    header=_('Unable to identify installed object cache plugin in WordPress'),
                    description=_('wp-cli utility returns malformed response, reason: "%(reason)s"'),
                    fix_tip=_('Please, try to check executed command and fix possible issues with it. '
                              'If issue persists - please, contact CloudLinux support.'),
                    context=dict(
                        reason=e.message % e.context
                    )
                )
            )

        try:
            multisite = cpanel.is_multisite(os.path.join(docroot, wordpress["path"]))
            if multisite:
                issues.append(
                    CompatibilityIssue(
                        header=_('WordPress Multisite mode is enabled'),
                        description=_('WordPress uses the Multisite mode which is currently not supported.'),
                        fix_tip=_('Install or configure WordPress in the single-site mode.'),
                        unique_id=UniqueId.WORDPRESS_MULTISITE_ENABLED,
                        telemetry=dict()
                    ))
        except WposError as e:
            issues.append(
                CompatibilityIssue(
                    header=_('Unexpected WordPress error'),
                    description=_('Unable to detect if the WordPress installation has the Multisite mode enabled '
                                  'mode due to unexpected error. '
                                  '\n\n'
                                  'Technical details:\n%(error_message)s.\n'
                                  '\nMost likely WordPress installation is not working properly.'),
                    fix_tip=_('If this is only one issue, please check that your website is working properly – '
                              'try to run the specified command to find any obvious '
                              'errors in the WordPress configuration. '
                              'Otherwise, try to fix other issues first - it may help to resolve this issue as well.'),
                    context=dict(
                        error_message=e.message % e.context
                    ),
                    unique_id=UniqueId.MISCONFIGURED_WORDPRESS,
                    telemetry=dict(
                        error_message=e.message % e.context
                    )
                ))
        return issues


class _SiteOptimization(Feature):
    """Implementation for site optimization feature"""

    NAME = 'SITE_OPTIMIZATION'
    WP_PLUGIN_NAME = 'clsop'

    @classmethod
    def redis_daemon_required(cls):
        return False

    @staticmethod
    def to_interface_name():
        return 'accelerate_wp'

    @classmethod
    def collect_docroot_issues(cls, wpos_user_obj, doc_root_info, allowed_modules=None):
        """
        Collects incompatibilities related to docroot (non-supported handler, etc)
        for site optimizatin module.
        """
        issues = []
        php_version = doc_root_info['php_version']

        if not cls.is_php_supported(php_version):
            supported_php_versions = wpos_user_obj.supported_php_versions[SITE_OPTIMIZATION_FEATURE]
            issues.append(
                CompatibilityIssue(
                    header=_('PHP version is not supported'),
                    fix_tip=_('Please, set or ask your system administrator to set one of the '
                              'supported PHP version: %(compatible_versions)s for the domain.'),
                    description=_('Non supported PHP version %(php_version)s currently is used.'),
                    context=dict(php_version=php_version,
                                 compatible_versions=', '.join(supported_php_versions),
                                 docs_url=CL_DOC_USER_PLUGIN),
                    unique_id=UniqueId.PHP_NOT_SUPPORTED,
                    telemetry=dict(reason='PHP_VERSION_TOO_LOW')
                )
            )

        return issues

    @staticmethod
    def _requirements():
        with open("/opt/cloudlinux-site-optimization-module/requirements.json", "r") as f:
            # {
            #    "required_php_version": "7.0",
            #    "required_wp_version": "5.4",
            #    "incompatible_plugins": {
            #      "w3-total-cache": "w3-total-cache/w3-total-cache.php",
            #      "wp-super-cache": "wp-super-cache/wp-cache.php"
            #    }
            # }
            return json.load(f)

    @classmethod
    def is_php_supported(cls, php_version: PHP):
        """
        Check if passed php version >= minimum PHP version
        supported by site optimization feature.
        """
        return php_version.digits >= int(cls._requirements()["required_php_version"].replace(".", ""))

    @classmethod
    def minimum_supported_wp_version(cls):
        return cls._requirements()["required_wp_version"]

    @classmethod
    def collect_wordpress_issues(cls, self, wordpress_info: Dict, docroot: str, module_is_enabled: bool):
        issues = []
        abs_wp_path = Path(docroot).joinpath(wordpress_info["path"])
        wp_content_dir = abs_wp_path.joinpath("wp-content")
        plugin_type = "advanced-cache"

        detected_advanced_cache_plugin = get_wp_cache_plugin(abs_wp_path, plugin_type)

        plugins_data = wordpress(str(abs_wp_path), "plugin", "list", "--status=active", "--format=json")

        if isinstance(plugins_data, WordpressError):
            found_plugins = set()
        else:
            try:
                found_plugins = {item["name"] for item in json.loads(plugins_data)}
            except (ValueError, TypeError, json.JSONDecodeError):
                issues.append(
                    MisconfigurationIssue(
                        header=_('Unable to identify module compatibility'),
                        description=_('Malformed output received from the following command: <br>&emsp;$/opt/clwpos/wp-cli plugin list --status=active --format=json'
                                      '<br><br>The raw command output is:<br>&emsp;\"%(wp_cli_response)s\"'),
                        fix_tip=_('Please, check the received command output and ensure it returns a valid JSON.'),
                        context=dict(
                            wp_cli_response=plugins_data
                        )
                    )
                )
                found_plugins = set()

        incompatible_plugins = set(cls._requirements()["incompatible_plugins"].keys())
        result = found_plugins & incompatible_plugins
        if detected_advanced_cache_plugin:
            result.add(detected_advanced_cache_plugin)

        # if our WP Rocket module is enabled it's not conflicting plugin
        if module_is_enabled:
            result.discard("WP Rocket")
            issue = cls._get_wp_plugin_compatibility_issues(docroot,
                                                            wordpress_info)
            if issue:
                issues.append(issue)

        # for more beautiful output
        if len(result) > 1:
            result.discard("Unknown")

        result = list(result)
        if len(result) == 1 and result[0] == 'Unknown':
            drop_in_file = wp_content_dir.joinpath(f'{plugin_type}.php')
            issues.append(
                CompatibilityIssue(
                    header=_("Conflicting advanced cache plugin enabled"),
                    description=_("Unknown advanced cache plugin is already enabled."),
                    fix_tip=_(f'Remove the drop-in ({drop_in_file}) file from the WordPress '
                              f'instance because it conflicts with AccelerateWP.'),
                    context=dict(plugins=", ".join(result)),
                    unique_id=UniqueId.PLUGIN_CONFLICT,
                    telemetry=dict(
                        reason='SOM_ALREADY_ENABLED',
                        plugin=list(result)
                    )
                )
            )
        elif result:
            issues.append(
                CompatibilityIssue(
                    header=_("Conflicting plugins are enabled"),
                    description=_("Found conflicting plugins: %(plugins)s."),
                    fix_tip=_("Deactivate and uninstall the conflicting plugin "
                              "using the WordPress administration interface."),
                    context=dict(plugins=", ".join(result)),
                    unique_id=UniqueId.PLUGIN_CONFLICT,
                    telemetry=dict(
                        reason='SOM_ALREADY_ENABLED',
                        plugin=list(result)
                    )
                )
            )
        return issues

    @classmethod
    def _get_issues_from_wp_plugin_status(cls, plugin_status):
        """
        Get issue that relates to currently installed redis-cache
        plugin or None if everything is ok
        """
        if plugin_status == PluginStatus.INACTIVE:
            return MisconfigurationIssue(
                header=_('"AccelerateWP" plugin is deactivated'),
                description=_('AccelerateWP feature is enabled, but the '
                              '"AccelerateWP" plugin is deactivated in Wordpress admin page. Caching does not work'),
                fix_tip=_(
                    'Activate the "AccelerateWP" plugin in the Wordpress admin page. '
                    'As an alternative, rollback the feature and apply it again.')
            )
        elif plugin_status == PluginStatus.UNINSTALLED:
            return MisconfigurationIssue(
                header=_('"AccelerateWP" plugin is not installed'),
                description=_(
                    'The "AccelerateWP" WordPress plugin is not installed. '
                    'Caching does not work'),
                fix_tip=_('Rollback the feature and apply it again. '
                          'Contact your administrator if the issue persists.')
            )


OBJECT_CACHE_FEATURE = Feature("object_cache")
SITE_OPTIMIZATION_FEATURE = Feature("site_optimization")

ALL_OPTIMIZATION_FEATURES = [
    OBJECT_CACHE_FEATURE,
    SITE_OPTIMIZATION_FEATURE
]