# combo - content management system
# Copyright (C) 2014-2015  Entr'ouvert
#
# This program is free software: you can redistribute it and/or modify it
# under the terms of the GNU Affero General Public License as published
# by the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU Affero General Public License for more details.
#
# You should have received a copy of the GNU Affero General Public License
# along with this program.  If not, see <http://www.gnu.org/licenses/>.

import copy
import os
import re
from collections import OrderedDict
from datetime import date, datetime, timedelta

import pygal
import pygal.util
from dateutil.relativedelta import MO, relativedelta
from django.conf import settings
from django.db import models, transaction
from django.db.models import JSONField
from django.template import RequestContext, Template, TemplateSyntaxError, VariableDoesNotExist
from django.template.defaultfilters import date as format_date
from django.urls import reverse
from django.utils import timezone
from django.utils.dates import WEEKDAYS
from django.utils.functional import cached_property
from django.utils.timesince import timesince
from django.utils.translation import gettext
from django.utils.translation import gettext_lazy as _
from requests.exceptions import RequestException

from combo.data.library import register_cell_class
from combo.data.models import CellBase, django_template_validator
from combo.middleware import get_request
from combo.utils import get_templated_url, requests, spooler


class UnsupportedDataSet(Exception):
    pass


class MissingRequest(Exception):
    pass


class MissingVariable(Exception):
    pass


@register_cell_class
class Gauge(CellBase):
    title = models.CharField(_('Title'), max_length=150, blank=True, null=True)
    url = models.CharField(_('URL'), max_length=150, blank=True, null=True)
    data_source = models.CharField(_('Data Source'), max_length=150, blank=True, null=True)
    jsonp_data_source = models.BooleanField(_('Use JSONP to get data'), default=True)
    max_value = models.PositiveIntegerField(_('Max Value'), blank=True, null=True)

    default_template_name = 'combo/gauge-cell.html'

    class Media:
        js = ('js/gauge.min.js', 'js/combo.gauge.js')

    class Meta:
        verbose_name = _('Gauge')

    def get_additional_label(self):
        return self.title

    def is_relevant(self, context):
        return bool(self.data_source)

    def get_cell_extra_context(self, context):
        if self.jsonp_data_source:
            data_source_url = get_templated_url(self.data_source)
        else:
            data_source_url = reverse('combo-ajax-gauge-count', kwargs={'cell': self.id})
        return {
            'cell': self,
            'title': self.title,
            'url': get_templated_url(self.url) if self.url else None,
            'max_value': self.max_value,
            'data_source_url': data_source_url,
            'jsonp': self.jsonp_data_source,
        }


@register_cell_class
class ChartCell(CellBase):
    default_template_name = 'combo/dataviz-chart.html'

    title = models.CharField(_('Title'), max_length=150, blank=True, null=True)
    url = models.URLField(_('URL'), max_length=250, blank=True, null=True)

    class Meta:
        verbose_name = _('Chart (legacy)')

    @classmethod
    def is_enabled(cls):
        return (
            settings.LEGACY_CHART_CELL_ENABLED
            and hasattr(settings, 'KNOWN_SERVICES')
            and settings.KNOWN_SERVICES.get('bijoe')
        )

    def get_default_form_class(self):
        from .forms import ChartForm

        return ChartForm

    def get_additional_label(self):
        if self.title:
            return self.title
        return ''

    def get_cell_extra_context(self, context):
        context = super().get_cell_extra_context(context)
        context['title'] = self.title
        context['url'] = self.url
        return context


class StatisticManager(models.Manager):
    def get_by_natural_key(self, slug, site_slug, service_slug):
        return self.get_or_create(slug=slug, site_slug=site_slug, service_slug=service_slug)[0]


class Statistic(models.Model):
    slug = models.SlugField(_('Slug'), max_length=256)
    label = models.CharField(_('Label'), max_length=256)
    site_slug = models.SlugField(_('Site slug'), max_length=256)
    service_slug = models.SlugField(_('Service slug'), max_length=256)
    site_title = models.CharField(_('Site title'), max_length=256)
    url = models.URLField(_('Data URL'))
    filters = JSONField(default=list)
    has_future_data = models.BooleanField(default=False)
    data_type = models.CharField(max_length=32)
    deprecated = models.BooleanField(default=False)
    available = models.BooleanField(_('Available data'), default=True)
    last_update = models.DateTimeField(_('Last update'), null=True, auto_now=True)

    objects = StatisticManager()

    class Meta:
        ordering = ['-available', 'deprecated', 'site_title', 'label']
        unique_together = ['slug', 'site_slug', 'service_slug']

    def __str__(self):
        name = _('%(title)s: %(label)s') % {'title': self.site_title or self.site_slug, 'label': self.label}
        if not self.available:
            name = _('%s (unavailable)') % name
        elif self.deprecated:
            name = _('%s (deprecated)') % name
        return name

    def natural_key(self):
        return (self.slug, self.site_slug, self.service_slug)

    def has_native_support_for_interval(self, time_interval):
        # pylint: disable=not-an-iterable
        return any(
            time_interval == x['id']
            for filter_ in self.filters
            for x in filter_['options']
            if filter_['id'] == 'time_interval'
        )


TIME_FILTERS = [
    ('previous-year', _('Previous year')),
    ('current-year', _('Current year')),
    ('next-year', _('Next year')),
    ('previous-month', _('Previous month')),
    ('current-month', _('Current month')),
    ('next-month', _('Next month')),
    ('previous-week', _('Previous week')),
    ('current-week', _('Current week')),
    ('next-week', _('Next week')),
    ('range', _('Free range (date)')),
    ('range-template', _('Free range (template)')),
]


@register_cell_class
class ChartNgCell(CellBase):
    statistic = models.ForeignKey(
        verbose_name=_('Data'),
        to=Statistic,
        blank=False,
        null=True,
        on_delete=models.SET_NULL,
        related_name='cells',
        help_text=_(
            'This list may take a few seconds to be updated, please refresh the page if an item is missing.'
        ),
    )
    subfilters = JSONField(default=list)
    filter_params = JSONField(default=dict)
    title = models.CharField(_('Title'), max_length=150, blank=True)
    time_range = models.CharField(
        _('Shown period'),
        max_length=20,
        blank=True,
        choices=TIME_FILTERS,
    )
    time_range_start = models.DateField(_('From'), null=True, blank=True)
    time_range_end = models.DateField(_('To'), null=True, blank=True)
    time_range_start_template = models.CharField(
        _('From'),
        max_length=200,
        blank=True,
        validators=[django_template_validator],
        help_text=_(
            'Template code returning a date. For example, Monday in two weeks would be '
            'today|add_days:"14"|adjust_to_week_monday. Page variables are also accessible.'
        ),
    )
    time_range_end_template = models.CharField(
        _('To'),
        max_length=200,
        blank=True,
        validators=[django_template_validator],
    )
    chart_type = models.CharField(
        _('Chart Type'),
        max_length=20,
        default='bar',
        choices=(
            ('bar', _('Bar')),
            ('horizontal-bar', _('Horizontal Bar')),
            ('stacked-bar', _('Stacked Bar')),
            ('stacked-bar-percent', _('Stacked Bar (%)')),
            ('line', _('Line')),
            ('pie', _('Pie')),
            ('dot', _('Dot')),
            ('table', _('Table')),
            ('table-inverted', _('Table (inverted)')),
        ),
    )

    height = models.CharField(
        _('Height'),
        max_length=20,
        default='250',
        choices=(
            ('150', _('Short (150px)')),
            ('250', _('Average (250px)')),
            ('350', _('Tall (350px)')),
        ),
    )

    sort_order = models.CharField(
        _('Sort data'),
        max_length=5,
        default='none',
        help_text=_('This setting only applies for one-dimensional charts.'),
        choices=(
            ('none', _('None')),
            ('alpha', _('Alphabetically')),
            ('asc', _('Increasing values')),
            ('desc', _('Decreasing values')),
        ),
    )

    hide_null_values = models.BooleanField(
        default=False,
        verbose_name=_('Hide null values'),
        help_text=_('This setting only applies for one-dimensional charts.'),
    )

    manager_form_template = 'combo/chartngcell_form.html'

    invalid_reason_codes = {
        'missing_statistic_url': _('No statistic URL set'),
        'statistic_data_not_found': _('Statistic URL seems to unexist'),
        'statistic_url_invalid': _('Statistic URL seems to be invalid'),
    }

    class Meta:
        verbose_name = _('Chart')

    class Media:
        js = ('js/chartngcell.js',)

    @classmethod
    def is_enabled(cls):
        return settings.KNOWN_SERVICES.get('bijoe') or settings.STATISTICS_PROVIDERS

    def get_default_form_class(self):
        from .forms import ChartNgForm

        return ChartNgForm

    def get_additional_label(self):
        return self.title

    def is_relevant(self, context):
        return bool(self.statistic)

    def check_validity(self):
        if not self.statistic:
            return

        if not self.statistic.url:
            self.mark_as_invalid('missing_statistic_url')
            return

        resp = None
        try:
            resp = self.get_statistic_data()
        except (RequestException, MissingRequest, MissingVariable):
            pass

        self.set_validity_from_url(
            resp, not_found_code='statistic_data_not_found', invalid_code='statistic_url_invalid'
        )

    def get_statistic_data(self, filter_params=None, raise_if_not_cached=False, invalidate_cache=False):
        return requests.get(
            self.statistic.url,
            params=filter_params or self.get_filter_params(),
            cache_duration=300,
            remote_service='auto',
            without_user=True,
            raise_if_not_cached=raise_if_not_cached,
            log_errors=False,
            invalidate_cache=invalidate_cache,
        )

    def get_chart(self, width=None, height=None, raise_if_not_cached=False):
        filter_params = self.get_filter_params()
        transaction.on_commit(
            lambda: spooler.refresh_statistics_data(cell_pk=self.pk, filter_params=filter_params)
        )
        response = self.get_statistic_data(filter_params, raise_if_not_cached)
        response.raise_for_status()
        response = response.json()

        style = pygal.style.DefaultStyle(font_family='"Open Sans", sans-serif', background='transparent')

        chart = {
            'bar': pygal.Bar,
            'horizontal-bar': pygal.HorizontalBar,
            'stacked-bar': pygal.StackedBar,
            'stacked-bar-percent': pygal.StackedBar,
            'line': pygal.Line,
            'pie': pygal.Pie,
            'dot': pygal.Dot,
            'table': pygal.Bar,
            'table-inverted': pygal.Bar,
        }[self.chart_type](config=pygal.Config(style=copy.copy(style), order_min=0.1, max_scale=5))

        if self.statistic.service_slug == 'bijoe':
            x_labels, y_labels, data = self.parse_response(response, chart)
            chart.x_labels = x_labels

            if chart.axis_count == 1:
                data = self.process_one_dimensional_data(chart, data)
            self.add_data_to_chart(chart, data, y_labels)
        else:
            data = response['data']

            interval = self.filter_params.get('time_interval', '')
            if data['x_labels'] and interval:
                if interval == 'day' or not self.statistic.has_native_support_for_interval(interval):
                    self.aggregate_data(data, interval)
                elif interval == 'month':
                    data['x_labels'] = [
                        format_date(datetime.strptime(x, '%Y-%m'), 'M Y') for x in data['x_labels']
                    ]

            chart.x_labels = data['x_labels']
            chart.axis_count = min(len(data['series']), 2)

            if self.statistic.data_type:
                chart.config.value_formatter = self.get_value_formatter(self.statistic.data_type)
                chart.compute_sum = False

            if chart.axis_count == 1:
                data['series'][0]['data'] = self.process_one_dimensional_data(
                    chart, data['series'][0]['data']
                )
                if self.chart_type == 'pie':
                    data["series"] = [
                        {"label": label, "data": [data]}
                        for label, data in zip(chart.x_labels, data["series"][0]["data"])
                        if data
                    ]

            if self.chart_type == 'stacked-bar-percent':
                self.make_percent([serie['data'] for serie in data['series']])

            for serie in data['series']:
                chart.add(serie['label'], serie['data'])
        self.configure_chart(chart, width, height)
        return chart

    def get_filter_params(self):
        params = {k: self.evaluate_filter_value(v) for k, v in self.filter_params.items() if v}

        now = timezone.now().date()
        if self.time_range == 'current-year':
            params['start'] = date(year=now.year, month=1, day=1)
            params['end'] = date(year=now.year + 1, month=1, day=1)
        elif self.time_range == 'previous-year':
            params['start'] = date(year=now.year - 1, month=1, day=1)
            params['end'] = date(year=now.year, month=1, day=1)
        elif self.time_range == 'next-year':
            params['start'] = date(year=now.year + 1, month=1, day=1)
            params['end'] = date(year=now.year + 2, month=1, day=1)
        elif self.time_range == 'current-month':
            params['start'] = now.replace(day=1)
            params['end'] = now + relativedelta(day=1, months=1)
        elif self.time_range == 'previous-month':
            params['start'] = now + relativedelta(day=1, months=-1)
            params['end'] = now.replace(day=1)
        elif self.time_range == 'next-month':
            params['start'] = now + relativedelta(day=1, months=1)
            params['end'] = now + relativedelta(day=1, months=2)
        elif self.time_range == 'current-week':
            params['start'] = now + relativedelta(weekday=MO(-1))
            params['end'] = now + relativedelta(weekday=MO(+1), days=+1)
        elif self.time_range == 'previous-week':
            params['start'] = now + relativedelta(weekday=MO(-2))
            params['end'] = now + relativedelta(weekday=MO(-1))
        elif self.time_range == 'next-week':
            params['start'] = now + relativedelta(weekday=MO(+1), days=+1)
            params['end'] = now + relativedelta(weekday=MO(+2), days=+1)
        elif self.time_range == 'range':
            if self.time_range_start:
                params['start'] = self.time_range_start
            if self.time_range_end:
                params['end'] = self.time_range_end
        elif self.time_range == 'range-template':
            if self.time_range_start_template:
                start = self.evaluate_range_template(self.time_range_start_template)
                if start:
                    params['start'] = start
            if self.time_range_end_template:
                end = self.evaluate_range_template(self.time_range_end_template)
                if end:
                    params['end'] = end
        if 'time_interval' in params and not self.statistic.has_native_support_for_interval(
            params['time_interval']
        ):
            params['time_interval'] = 'day'
        return params

    def evaluate_range_template(self, value):
        if value in self.page.extra_variables:
            value = self.page.extra_variables[value].strip('{ }')

        context = self.request_context
        context.update({'now': datetime.now, 'today': datetime.now})
        try:
            return Template('{{ %s|date:"Y-m-d" }}' % value).render(context)
        except (VariableDoesNotExist, TemplateSyntaxError):
            return None

    def evaluate_filter_value(self, value):
        if isinstance(value, list) or not value.startswith('variable:'):
            return value

        try:
            variable = self.page.extra_variables[value.replace('variable:', '')]
        except KeyError:
            raise MissingVariable

        return Template(variable).render(self.request_context)

    @cached_property
    def request_context(self):
        if not getattr(self, '_request', None):
            raise MissingRequest

        ctx = RequestContext(self._request, getattr(self._request, 'extra_context', {}))
        ctx['request'] = self._request
        return ctx

    def parse_response(self, response, chart):
        # normalize axis to have a fake axis when there are no dimensions and
        # always a x axis when there is a single dimension.
        data = response['data']
        loop_labels = response['axis'].get('loop') or []
        x_labels = response['axis'].get('x_labels') or []
        y_labels = response['axis'].get('y_labels') or []
        if loop_labels:
            if 'x_labels' in response['axis'] and 'y_labels' in response['axis']:
                # no support for three dimensions
                raise UnsupportedDataSet()
            if not y_labels:
                y_labels = loop_labels
            else:
                x_labels, y_labels = y_labels, loop_labels
            if (
                x_labels
                and y_labels
                and (len(y_labels) != len(data) or not all([len(x) == len(x_labels) for x in data]))
            ):
                # varying dimensions
                raise UnsupportedDataSet()
        if not x_labels and not y_labels:  # unidata
            x_labels = ['']
            y_labels = ['']
            data = [data]
            chart.axis_count = 0
        elif not x_labels:
            x_labels = y_labels
            y_labels = ['']
            chart.axis_count = 1
        elif not y_labels:
            y_labels = ['']
            chart.axis_count = 1
        else:
            chart.axis_count = 2

        chart.compute_sum = bool(response.get('measure') == 'integer' and chart.axis_count > 0)

        formatter = self.get_value_formatter(response.get('unit'), response.get('measure'))
        if formatter is not None:
            chart.config.value_formatter = formatter

        return x_labels, y_labels, data

    def configure_dot_chart(self, chart, width, height):
        chart.show_legend = False
        # use a single colour for dots
        chart.config.style.colors = ('#1f77b4',) * max(len(chart.x_labels), 1)

    def configure_horizontal_bar_chart(self, chart, width, height):
        if width and width < 500:
            # truncate labels
            chart.x_labels = [pygal.util.truncate(x, 15) for x in chart.x_labels]

    def configure_pie_chart(self, chart, width, height):
        chart.show_legend = True
        if width and height:
            # pies are as tall as wide, reserve the appropriate space and distribute
            # the rest for the legend.
            chart.truncate_legend = (width - height) // 10
        elif width:
            chart.truncate_legend = width // 20

    def configure_chart(self, chart, width, height):
        auto_height_scale = pygal.style.DefaultStyle.legend_font_size * 1.75
        chart.config.margin = 0
        if width:
            chart.config.width = width
        height = height or int(self.height)
        # adapt chart's height to legend length
        chart.config.height = max(height, auto_height_scale * len(chart.raw_series))

        if width or height:
            chart.config.explicit_size = True

        chart.config.js = [os.path.join(settings.STATIC_URL, 'js/pygal-tooltips.js')]

        chart.show_legend = bool(chart.axis_count > 1)
        chart.truncate_legend = 30
        # matplotlib tab10 palette
        chart.config.style.colors = (
            '#1f77b4',
            '#ff7f0e',
            '#2ca02c',
            '#d62728',
            '#9467bd',
            '#8c564b',
            '#e377c2',
            '#7f7f7f',
            '#bcbd22',
            '#17becf',
        )

        custom_configure_method_name = 'configure_%s_chart' % self.chart_type.replace('-', '_')
        if hasattr(self, custom_configure_method_name):
            getattr(self, custom_configure_method_name)(chart, width, height)

        if self.chart_type != 'pie':
            if width and width < 500:
                chart.legend_at_bottom = True
                # restore demanded chart's height
                chart.config.height = height

    def process_one_dimensional_data(self, chart, data):
        if self.hide_null_values:
            data = self.hide_values(chart, data)
        if data and self.sort_order != 'none':
            data = self.sort_values(chart, data)
        if getattr(chart, 'compute_sum', True) and self.chart_type in ('table', 'table-inverted'):
            data = self.add_total_to_line_table(chart, data)
        return data

    @staticmethod
    def hide_values(chart, data):
        x_labels, new_data = [], []
        for label, value in zip(chart.x_labels, data):
            if value:
                x_labels.append(label)
                new_data.append(value)
        chart.x_labels = x_labels
        return new_data

    def sort_values(self, chart, data):

        if self.sort_order == 'alpha':
            digit_re = re.compile('([0-9]+)')

            def natural_sort_key(item):
                return [int(text) if text.isdigit() else text.lower() for text in digit_re.split(item[0])]

            tmp_items = sorted(zip(chart.x_labels, data), key=natural_sort_key)

        elif self.sort_order == 'asc':
            tmp_items = sorted(zip(chart.x_labels, data), key=lambda x: (x[1] or 0))
        elif self.sort_order == 'desc':
            tmp_items = sorted(zip(chart.x_labels, data), key=lambda x: (x[1] or 0), reverse=True)
        x_labels, sorted_data = zip(*((label, value) for label, value in tmp_items))
        chart.x_labels = list(x_labels)
        return list(sorted_data)

    @staticmethod
    def add_total_to_line_table(chart, data):
        # workaround pygal
        chart.compute_sum = False

        # do not add total for single point
        if len(data) <= 1:
            return data

        data.append(sum(x for x in data if x is not None))
        chart.x_labels.append(gettext('Total'))
        return data

    def add_data_to_chart(self, chart, data, y_labels):
        if self.chart_type != 'pie':
            series_data = []
            for i, serie_label in enumerate(y_labels):
                if chart.axis_count < 2:
                    values = data
                else:
                    values = [data[i][j] for j in range(len(chart.x_labels))]
                series_data.append(values)
                chart.add(serie_label, values)
            if self.chart_type == 'stacked-bar-percent':
                self.make_percent(series_data)
        else:
            # pie, create a serie by data, to get different colours
            values = data
            for label, value in zip(chart.x_labels, values):
                if not value:
                    continue
                chart.add(label, value)

    @staticmethod
    def get_value_formatter(unit, measure='duration'):
        if unit == 'seconds' or measure == 'duration':

            def format_duration(value):
                base_date = datetime(1871, 3, 18)
                return timesince(base_date, base_date + timedelta(seconds=value))

            return format_duration
        elif measure == 'percent':
            percent_formatter = lambda x: f'{x:.1f}%'
            return percent_formatter

    def make_percent(self, series_data):
        for i, values in enumerate(zip(*series_data)):
            sum_values = sum(v for v in values if v is not None)
            if sum_values == 0:
                continue

            factor = 100 / sum_values
            for values in series_data:
                if values[i] is not None:
                    values[i] = round(values[i] * factor, 1)

    @staticmethod
    def aggregate_data(data, interval):
        series_data = [serie['data'] for serie in data['series']]
        dates = [datetime.strptime(label, '%Y-%m-%d') for label in data['x_labels']]
        min_date, max_date = min(dates), max(dates)

        date_formats = {
            'day': 'd M Y',
            # Translators: This indicates week number followed by year, for example it can yield W2-2021.
            # First "W" is the first letter of the word "week" and should be translated accordingly, second
            # "W" and "o" are interpreted by Django's date filter and should be left as is. First W is
            # backslash escaped to prevent it from being interpreted, translators should refer to Django's
            # documentation in order to know if the new letter resulting of translation should be escaped or not.
            'week': gettext(r'\WW-o'),
            'month': 'M Y',
            'year': 'Y',
            'weekday': 'l',
        }
        if interval == 'day':
            x_labels = [
                format_date(min_date + timedelta(days=i), date_formats['day'])
                for i in range((max_date - min_date).days + 1)
            ]
        elif interval == 'month':
            month_difference = max_date.month - min_date.month + (max_date.year - min_date.year) * 12
            x_labels = [
                format_date(min_date + relativedelta(months=i), date_formats['month'])
                for i in range(month_difference + 1)
            ]
        elif interval == 'year':
            x_labels = [str(year) for year in range(min_date.year, max_date.year + 1)]
        elif interval == 'weekday':
            x_labels = [str(label) for label in WEEKDAYS.values()]
        elif interval == 'week':
            x_labels = []
            date, last_date = min_date, max_date
            if min_date.weekday() > max_date.weekday():
                last_date += relativedelta(weeks=1)
            while date <= last_date:
                x_labels.append(format_date(date, date_formats['week']))
                date += relativedelta(weeks=1)

        aggregates = OrderedDict((label, [0] * len(series_data)) for label in x_labels)
        for i, date in enumerate(dates):
            key = format_date(date, date_formats[interval])
            for j, dummy in enumerate(series_data):
                aggregates[key][j] += series_data[j][i] or 0

        data['x_labels'] = x_labels
        for i, serie in enumerate(data['series']):
            serie['data'] = [values[i] for values in aggregates.values()]

    @property
    def available_filters(self):
        return self.statistic.filters + self.subfilters

    def update_subfilters(self, filter_params=None):
        self._request = get_request()
        try:
            response = self.get_statistic_data(filter_params=filter_params)
        except (TemplateSyntaxError, VariableDoesNotExist):
            return

        try:
            response.raise_for_status()
            data = response.json()['data']
        except Exception:
            return

        new_subfilters = data.get('subfilters', [])
        if self.subfilters != new_subfilters:
            self.subfilters = new_subfilters
            subfilter_ids = {filter_['id'] for filter_ in self.available_filters}
            self.filter_params = {k: v for k, v in self.filter_params.items() if k in subfilter_ids}
            self.save()

    def get_cache_key(self, filters_cell_id):
        return 'dataviz:%s:%s' % (filters_cell_id, self.pk)


@register_cell_class
class ChartFiltersCell(CellBase):
    filters = JSONField(_('Filters'), default=dict)

    title = _('Filters')
    default_template_name = 'combo/chart-filters.html'
    manager_form_template = 'combo/chartfilterscell_form.html'
    max_one_by_page = True

    class Meta:
        verbose_name = _('Filters')

    class Media:
        js = ('js/combo.multiselectwidget.js',)
        css = {'all': ('css/combo.multiselectwidget.css',)}

    @classmethod
    def is_enabled(cls):
        return settings.CHART_FILTERS_CELL_ENABLED and settings.STATISTICS_PROVIDERS

    def get_cell_extra_context(self, context):
        from .forms import ChartFiltersForm

        ctx = super().get_cell_extra_context(context)
        if 'filters_cell_id' in context['request'].GET:  # detect refresh on submit
            ctx['form'] = ChartFiltersForm(
                data=context['request'].GET,
                page=self.page,
                filters_cell=self,
                filters_cell_id=context['request'].GET['filters_cell_id'],
            )
        else:
            ctx['form'] = ChartFiltersForm(page=self.page, filters_cell=self)

        return ctx

    def get_default_form_class(self):
        from .forms import ChartFiltersConfigForm

        return ChartFiltersConfigForm