"""Lambda feed-status-notifierv2 function module."""

import json

import requests
from lambdacommon.common_config import logger

import config


def handler(event, context):
    """Lambda entry point."""
    try:
        handle_feed_statuses(config.INGESTION_STATUS_URI)
        handle_feed_statuses(config.MARKETSHARE_STATUS_URI)
        handle_feed_statuses(config.MONTHLY_STATUS_URI)
        handle_feed_statuses(config.OUTGOING_STATUS_URI)
        return {'status': config.METRIC_STATUS_OK}
    except Exception as e:
        logger.exception(str(e))
        raise e


def handle_feed_statuses(status_uri):
    """Handle feed statuses.

    Args:
        status_uri (str): endpoint for feed statuses.
    """
    status_response = requests.get(
        config.MONTY_URL_BASE_PATH + status_uri,
        verify=False,
    )
    if (status_response.ok):
        status_json = json.loads(status_response.content)
        process_metrics(status_json.get('data', []))
    else:
        logger.error('Could not retrieve statuses from {url}'.format(
            url=(config.MONTY_URL_BASE_PATH + status_uri)))


def process_metrics(statuses):
    """Process metrics from feed statuses.

    Args:
        statuses (arr): array of feed status dicts.
    """
    alerts = []
    for status in statuses:
        metrics = status['metrics']
        for metric in metrics:
            if metric['status'] != config.METRIC_STATUS_OK:
                alerts += [
                    {
                        'feed_id': status['feed_id'],
                        'feed_name': status['feed_name'],
                        'metric_name': metric['name'],
                        'status': metric['status'],
                    }
                ]
    if len(alerts):
        send_alerts(alerts)


def slack_handler(alert_config, alerts):
    """Send alerts to Slack as configured.

    Args:
        alert_config (dict): alert configuration.
        alerts (arr): array of dicts with values feed_id, feed_name,
            and status.
    """
    messages = []
    for alert in alerts:
        if (
            (alert['metric_name'], alert_config['target'])
            == (alert_config['metric_name'], 'slack')  # noqa: W503
        ):
            messages.append(
                (
                    'Feed Notification: *{metric_name}* health failed.  '
                    '*{feed_name}* (feed_id={feed_id}) '
                    'is in state: *{status}*'
                ).format(
                    metric_name=alert['metric_name'],
                    feed_name=alert['feed_name'],
                    feed_id=alert['feed_id'],
                    status=alert['status'],
                ),
            )
    body = {
        'channel': '#{channel}'.format(channel=alert_config['channel']),
        'text': '\n'.join(messages),
    }
    url = config.SLACK_WEBHOOK_URL
    headers = {'Content-type': 'application/json', 'Accept': 'text/plain'}
    response = requests.post(url, json=body, headers=headers, verify=False)
    if not response.ok:
        logger.error(
            'current_status_slack_handler: Could not POST to {url}'.format(
                url=url,
            ),
        )
    else:
        logger.info(
            'Successfully sent POST to {url}:\n{body}'.format(
                url=url,
                body=body,
            ),
        )


def jira_handler(alert_config, alerts):
    """Send alerts to Jira as configured.

    Args:
        alert_config (dict): alert configuration.
        alerts (arr): array of dicts with values feed_id, feed_name,
            and status.
    """
    pass


handlers_config = {
    'jira': jira_handler,
    'slack': slack_handler,
}


def send_alerts(alerts):
    """Send alerts for configured feeds.

    Args:
        alerts (arr): array of dicts with values feed_id, feed_name,
            and status.
    """
    for alert_config in config.ALERT_CONFIGURATION:
        handlers_config[alert_config['target']](alert_config, alerts)