# -*- coding: utf-8 -*-

# Copyright 2010 - 2017 RhodeCode GmbH and the AppEnlight project authors
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#   http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

import logging
import sqlalchemy as sa
import urllib.request, urllib.parse, urllib.error
from datetime import timedelta
from appenlight.models import Base
from appenlight.lib.utils.date_utils import convert_date
from sqlalchemy.dialects.postgresql import JSON
from ziggurat_foundations.models.base import BaseModel

log = logging.getLogger(__name__)

#
channel_rules_m2m_table = sa.Table(
    "channels_actions",
    Base.metadata,
    sa.Column("channel_pkey", sa.Integer, sa.ForeignKey("alert_channels.pkey")),
    sa.Column("action_pkey", sa.Integer, sa.ForeignKey("alert_channels_actions.pkey")),
)

channel_resources_m2m_table = sa.Table(
    "channels_resources",
    Base.metadata,
    sa.Column("channel_pkey", sa.Integer, sa.ForeignKey("alert_channels.pkey")),
    sa.Column("resource_id", sa.Integer, sa.ForeignKey("resources.resource_id")),
)

DATE_FRMT = "%Y-%m-%dT%H:%M"


class AlertChannel(Base, BaseModel):
    """
    Stores information about possible alerting options
    """

    __tablename__ = "alert_channels"
    __possible_channel_names__ = ["email"]
    __mapper_args__ = {
        "polymorphic_on": "channel_name",
        "polymorphic_identity": "integration",
    }

    owner_id = sa.Column(
        sa.Unicode(30),
        sa.ForeignKey("users.id", onupdate="CASCADE", ondelete="CASCADE"),
    )
    channel_name = sa.Column(sa.Unicode(25), nullable=False)
    channel_value = sa.Column(sa.Unicode(80), nullable=False, default="")
    channel_json_conf = sa.Column(JSON(), nullable=False, default="")
    channel_validated = sa.Column(sa.Boolean, nullable=False, default=False)
    send_alerts = sa.Column(sa.Boolean, nullable=False, default=True)
    daily_digest = sa.Column(sa.Boolean, nullable=False, default=True)
    integration_id = sa.Column(
        sa.Integer, sa.ForeignKey("integrations.id"), nullable=True
    )
    pkey = sa.Column(sa.Integer(), nullable=False, primary_key=True)

    channel_actions = sa.orm.relationship(
        "AlertChannelAction",
        cascade="all",
        passive_deletes=True,
        passive_updates=True,
        secondary=channel_rules_m2m_table,
        backref="channels",
    )
    resources = sa.orm.relationship(
        "Resource",
        cascade="all",
        passive_deletes=True,
        passive_updates=True,
        secondary=channel_resources_m2m_table,
        backref="resources",
    )

    @property
    def channel_visible_value(self):
        if self.integration:
            return "{}: {}".format(
                self.channel_name, self.integration.resource.resource_name
            )

        return "{}: {}".format(self.channel_name, self.channel_value)

    def get_dict(self, exclude_keys=None, include_keys=None, extended_info=True):
        """
        Returns dictionary with required information that will be consumed by
        angular
        """
        instance_dict = super(AlertChannel, self).get_dict(exclude_keys, include_keys)
        exclude_keys_list = exclude_keys or []
        include_keys_list = include_keys or []

        instance_dict["supports_report_alerting"] = True
        instance_dict["channel_visible_value"] = self.channel_visible_value

        if extended_info:
            instance_dict["actions"] = [
                rule.get_dict(extended_info=True) for rule in self.channel_actions
            ]

        del instance_dict["channel_json_conf"]

        if self.integration:
            instance_dict[
                "supports_report_alerting"
            ] = self.integration.supports_report_alerting
        d = {}
        for k in instance_dict.keys():
            if k not in exclude_keys_list and (
                k in include_keys_list or not include_keys
            ):
                d[k] = instance_dict[k]
        return d

    def __repr__(self):
        return "<AlertChannel: (%s,%s), user:%s>" % (
            self.channel_name,
            self.channel_value,
            self.user_name,
        )

    def send_digest(self, **kwargs):
        """
        This should implement daily top error report notifications
        """
        log.warning("send_digest NOT IMPLEMENTED")

    def notify_reports(self, **kwargs):
        """
        This should implement notification of reports that occured in 1 min
        interval
        """
        log.warning("notify_reports NOT IMPLEMENTED")

    def notify_alert(self, **kwargs):
        """
        Notify user of report/uptime/chart threshold events based on events alert
        type

        Kwargs:
            application: application that the event applies for,
            event: event that is notified,
            user: user that should be notified
            request: request object

        """
        alert_name = kwargs["event"].unified_alert_name()
        if alert_name in ["slow_report_alert", "error_report_alert"]:
            self.notify_report_alert(**kwargs)
        elif alert_name == "uptime_alert":
            self.notify_uptime_alert(**kwargs)
        elif alert_name == "chart_alert":
            self.notify_chart_alert(**kwargs)

    def notify_chart_alert(self, **kwargs):
        """
        This should implement report open/close alerts notifications
        """
        log.warning("notify_chart_alert NOT IMPLEMENTED")

    def notify_report_alert(self, **kwargs):
        """
        This should implement report open/close alerts notifications
        """
        log.warning("notify_report_alert NOT IMPLEMENTED")

    def notify_uptime_alert(self, **kwargs):
        """
        This should implement uptime open/close alerts notifications
        """
        log.warning("notify_uptime_alert NOT IMPLEMENTED")

    def get_notification_basic_vars(self, kwargs):
        """
        Sets most common variables used later for rendering notifications for
        channel
        """
        if "event" in kwargs:
            kwargs["since_when"] = kwargs["event"].start_date

        url_start_date = kwargs.get("since_when") - timedelta(minutes=1)
        url_end_date = kwargs.get("since_when") + timedelta(minutes=4)
        tmpl_vars = {
            "timestamp": kwargs["since_when"],
            "user": kwargs["user"],
            "since_when": kwargs.get("since_when"),
            "url_start_date": url_start_date,
            "url_end_date": url_end_date,
        }
        tmpl_vars["resource_name"] = kwargs["resource"].resource_name
        tmpl_vars["resource"] = kwargs["resource"]

        if "event" in kwargs:
            tmpl_vars["event_values"] = kwargs["event"].values
            tmpl_vars["alert_type"] = kwargs["event"].unified_alert_name()
            tmpl_vars["alert_action"] = kwargs["event"].unified_alert_action()
        return tmpl_vars

    def report_alert_notification_vars(self, kwargs):
        tmpl_vars = self.get_notification_basic_vars(kwargs)
        reports = kwargs.get("reports", [])
        tmpl_vars["reports"] = reports
        tmpl_vars["confirmed_total"] = len(reports)

        tmpl_vars["report_type"] = "error reports"
        tmpl_vars["url_report_type"] = "report/list"

        alert_type = tmpl_vars.get("alert_type", "")
        if "slow_report" in alert_type:
            tmpl_vars["report_type"] = "slow reports"
            tmpl_vars["url_report_type"] = "report/list_slow"

        app_url = kwargs["request"].registry.settings["_mail_url"]

        destination_url = kwargs["request"].route_url("/", _app_url=app_url)
        if alert_type:
            destination_url += "ui/{}?resource={}&start_date={}&end_date={}".format(
                tmpl_vars["url_report_type"],
                tmpl_vars["resource"].resource_id,
                tmpl_vars["url_start_date"].strftime(DATE_FRMT),
                tmpl_vars["url_end_date"].strftime(DATE_FRMT),
            )
        else:
            destination_url += "ui/{}?resource={}".format(
                tmpl_vars["url_report_type"], tmpl_vars["resource"].resource_id
            )
        tmpl_vars["destination_url"] = destination_url

        return tmpl_vars

    def uptime_alert_notification_vars(self, kwargs):
        tmpl_vars = self.get_notification_basic_vars(kwargs)
        app_url = kwargs["request"].registry.settings["_mail_url"]
        destination_url = kwargs["request"].route_url("/", _app_url=app_url)
        destination_url += "ui/{}?resource={}".format(
            "uptime", tmpl_vars["resource"].resource_id
        )
        tmpl_vars["destination_url"] = destination_url

        reason = ""
        e_values = tmpl_vars.get("event_values")

        if e_values and e_values.get("response_time") == 0:
            reason += " Response time was slower than 20 seconds."
        elif e_values:
            code = e_values.get("status_code")
            reason += " Response status code: %s." % code

        tmpl_vars["reason"] = reason
        return tmpl_vars

    def chart_alert_notification_vars(self, kwargs):
        tmpl_vars = self.get_notification_basic_vars(kwargs)
        tmpl_vars["chart_name"] = tmpl_vars["event_values"]["chart_name"]
        tmpl_vars["action_name"] = tmpl_vars["event_values"].get("action_name") or ""
        matched_values = tmpl_vars["event_values"]["matched_step_values"]
        tmpl_vars["readable_values"] = []
        for key, value in list(matched_values["values"].items()):
            matched_label = matched_values["labels"].get(key)
            if matched_label:
                tmpl_vars["readable_values"].append(
                    {"label": matched_label["human_label"], "value": value}
                )
        tmpl_vars["readable_values"] = sorted(
            tmpl_vars["readable_values"], key=lambda x: x["label"]
        )
        start_date = convert_date(tmpl_vars["event_values"]["start_interval"])
        end_date = None
        if tmpl_vars["event_values"].get("end_interval"):
            end_date = convert_date(tmpl_vars["event_values"]["end_interval"])

        app_url = kwargs["request"].registry.settings["_mail_url"]
        destination_url = kwargs["request"].route_url("/", _app_url=app_url)
        to_encode = {
            "resource": tmpl_vars["event_values"]["resource"],
            "start_date": start_date.strftime(DATE_FRMT),
        }
        if end_date:
            to_encode["end_date"] = end_date.strftime(DATE_FRMT)

        destination_url += "ui/{}?{}".format("logs", urllib.parse.urlencode(to_encode))
        tmpl_vars["destination_url"] = destination_url
        return tmpl_vars