import boto3
import json
import urllib.request


def build_message_block(response, send_quota_usage):
    blocks = [
        {
            "type": "header",
            "text": {
                "type": "plain_text",
                "text": "SES Send quota use " + str(int(send_quota_usage)) + "%"
            }
        },
        {
            "type": "divider"
        },
        {
            "type": "section",
            "fields": [
                {
                    "type": "mrkdwn",
                    "text": "*SentLast24Hours (usage):* " + str(f"{int(response['SentLast24Hours']):,}")
                }
            ]
        },
        {
            "type": "section",
            "fields": [
                {
                    "type": "mrkdwn",
                    "text": "*Max24HourSend (limt):*   " + str(f"{int(response['Max24HourSend']):,}")
                }
            ]
        },
        {
            "type": "section",
            "fields": [
                {
                    "type": "mrkdwn",
                    "text": "*MaxSendRate:* " + str(f"{int(response['MaxSendRate']):,}")
                }
            ]
        }
    ]
    
    # if response['ResponseMetadata']:
    #     meta_data_json = json.dumps(response['ResponseMetadata'])
    #     blocks += [
    #         {
    #             "type": "section",
    #             "text": {
    #                 "type": "mrkdwn",
    #                 "text": "*ResponseMetadata:*\n```" + meta_data_json + "```"
    #             }
    #         }
    #     ]
    
    return blocks


def post_slack(blocks, message=None):
    send_data = {
        "channel": "XXXXXXXXXXX",   # SESの通知用channel
        "username": "SES Monitor",
        "icon_emoji": ":chart_with_upwards_trend:",
        "text": message,
        "blocks": blocks
    }
    send_text = "payload=" + json.dumps(send_data)
    
    print('post_slack() send_text: ', send_text)
    
    request = urllib.request.Request(
        "（SlackのWebhook URL）",
        data=send_text.encode('utf-8'),
        method="POST"
    )
    
    with urllib.request.urlopen(request) as response:
        response_body = response.read().decode('utf-8')


def get_ses_send_quota():
    ses = boto3.client('ses')
    response = ses.get_send_quota()
    send_quota_usage = response['SentLast24Hours'] / response['Max24HourSend'] * 100
    
    if send_quota_usage >= 60:
        message_body = build_message_block(response, send_quota_usage)
        notice_message = 'SES send quota usage: ' + str(send_quota_usage) + '%'
        print(message_body)
        print(notice_message)
        post_slack(message_body, notice_message)


def lambda_handler(event, context):
    get_ses_send_quota()
    
    return

import json
from datetime import date, datetime
import urllib.request

import boto3


def json_serial(obj):
    # If it is a date type, convert it to a character string.
    if isinstance(obj, (datetime, date)):
        return obj.isoformat()
    # Other than the above, it is not supported.
    raise TypeError ("Type %s not serializable" % type(obj))


def delete_suppressed_destination(mail):
    client = boto3.client('sesv2')

    suppressed = client.get_suppressed_destination(EmailAddress=mail)
    del_json = json.dumps(suppressed, default=json_serial)
    message = '\n'.join([
        '*Delete suppressed destination json*: `' + mail + '`',
        '```' + del_json + '```'
        ])

    try:
        client.delete_suppressed_destination(EmailAddress=mail)
    except client.exceptions.NotFoundException:
        post_slack('*NotFoundException*: `' + mail + '`\n' + message)
        return
    except client.exceptions.BadRequestException:
        post_slack('*BadRequestException*: `' + mail + '`\n' + message)
        return
    except client.exceptions.TooManyRequestsException:
        post_slack('*TooManyRequestsException*: `' + mail + '`\n' + message)
        return

    try:
        suppressed = client.get_suppressed_destination(EmailAddress=mail)
    except client.exceptions.NotFoundException:
        del_response = '*Deleted!*'
    except client.exceptions.BadRequestException:
        del_response = '*BadRequestException*'
    except client.exceptions.TooManyRequestsException:
        del_response = '*TooManyRequestsException*'

    return (del_response, del_json)


def is_no_suppress_mail(mail):
    if 'no-suppress' in mail or mail.endswith('@no.suppress.domain.jp'):
        return True
    return False
    
    
def is_ignore_mail(mail):
    ignore_list = (
        'ignore@example.com',
        )
    if mail in ignore_list or mail.endswith('@ignore.domain.jp'):
        return True
    return False


# Bounce.
def build_blocks_bounce(bounced_recipient, message_json):

    mail = bounced_recipient['emailAddress']

    diagnosticCode = bounced_recipient['diagnosticCode']
    bounce_status = '\n'.join((
        'action: ' + bounced_recipient['action'],
        'status: ' + bounced_recipient['status'],
        'diagnostic_code: ' + diagnosticCode,
        ))

    bounce_json = json.dumps(message_json)

    blocks = [
        {
            "type": "section",
            "fields": [
                {
                    "type": "mrkdwn",
                    "text": "*Mail: *"
                },
                {
                    "type": "mrkdwn",
                    "text": "`" + mail + "`"
                }
            ]
        },
		{
			"type": "section",
			"text": {
				"type": "mrkdwn",
				"text": "*Bounced information: *\n```" + bounce_status + "```"
			}
		},
		{
			"type": "section",
			"text": {
				"type": "mrkdwn",
				"text": "*Bounced message json: *\n```" + bounce_json + "```"
			}
		}
    ]
    return blocks

def build_blocks_delete(mail, del_response, del_json):
    blocks = [
        {
            "type": "header",
            "text": {
                "type": "plain_text",
                "text": "Delete notification"
            }
        },
        {
            "type": "divider"
        },
        {
            "type": "section",
            "fields": [
                {
                    "type": "mrkdwn",
                    "text": "*Mail:*"
                },
                {
                    "type": "mrkdwn",
                    "text": "`" + mail + "`"
                }
            ]
        },
        {
            "type": "section",
            "fields": [
                {
                    "type": "mrkdwn",
                    "text": "*Response:*"
                },
                {
                    "type": "mrkdwn",
                    "text": del_response
                }
            ]
        },
		{
			"type": "section",
			"text": {
				"type": "mrkdwn",
				"text": "*Suppressed destination json: *\n```" + del_json + "```"
			}
		}
    ]
    return blocks

def prepare_bounced_message(message_json):
    bounced_message = [
        {
            "type": "header",
            "text": {
                "type": "plain_text",
                "text": "Bounce notification"
            }
        },
        {
            "type": "divider"
        },
		{
			"type": "section",
            "fields": [
                {
                    "type": "mrkdwn",
                    "text": "*Timestamp (UTC): *"
                },
                {
                    "type": "mrkdwn",
                    "text": "`" + message_json['bounce']['timestamp'] + "`"
                }
            ]
		}
    ]
    return bounced_message


# Complaint.
def build_blocks_complaint(complained_recipient, message_json):

    mail = complained_recipient['emailAddress']

    complaint_json = json.dumps(message_json)

    blocks = [
        {
            "type": "section",
            "fields": [
                {
                    "type": "mrkdwn",
                    "text": "*Mail: *"
                },
                {
                    "type": "mrkdwn",
                    "text": "`" + mail + "`"
                }
            ]
        },
		{
			"type": "section",
			"text": {
				"type": "mrkdwn",
				"text": "*Complaintd message json: *\n```" + complaint_json + "```"
			}
		}
    ]
    return blocks

def prepare_complained_message(message_json):
    complained_message = [
        {
            "type": "header",
            "text": {
                "type": "plain_text",
                "text": "Complaint notification"
            }
        },
        {
            "type": "divider"
        },
		{
			"type": "section",
            "fields": [
                {
                    "type": "mrkdwn",
                    "text": "*Timestamp (UTC): *"
                },
                {
                    "type": "mrkdwn",
                    "text": "`" + message_json['complaint']['timestamp'] + "`"
                }
            ]
		}
    ]
    return complained_message


def post_slack(blocks, message=None):
    send_data = {
        "channel": "XXXXXXXXXXX",   # SESの通知用Channel-ID
        "username": "SES Notice",
        "icon_emoji": ":mailbox_with_no_mail:",
        "text": message,
        "blocks": blocks
    }

    send_text = "payload=" + json.dumps(send_data)

    print('post_slack() send_text: ', send_text)

    request = urllib.request.Request(
        "（SlackのWebhook URL）",
        data=send_text.encode('utf-8'),
        method="POST"
    )

    with urllib.request.urlopen(request) as response:
        response_body = response.read().decode('utf-8')


def ses_process(event):
    message_json = json.loads(event['Records'][0]['Sns']['Message'])

    if message_json['notificationType'] == 'Bounce':
        bounced_recipients = message_json['bounce']['bouncedRecipients']
        bounced_mails = []
        delete_result = []
        notice_message = ""

        for bounced_recipient in bounced_recipients:
            bounced_mails += build_blocks_bounce(bounced_recipient, message_json)
            mail = bounced_recipient['emailAddress']
            if is_no_suppress_mail(mail) and not is_ignore_mail(mail):
                del_result, del_json = delete_suppressed_destination(mail)
                delete_result += build_blocks_delete(mail, del_result, del_json)
                notice_message = "DELETE: " + mail

        bounced_message = prepare_bounced_message(message_json)
        bounced_message = bounced_message + bounced_mails + delete_result

        if not notice_message:
            notice_message = "BOUNCE: " + mail
            
        if not is_ignore_mail(mail):
            post_slack(bounced_message, notice_message)

    elif message_json['notificationType'] == 'Complaint':
        complained_recipients = message_json['complaint']['complainedRecipients']
        complained_mails = []

        for complained_recipient in complained_recipients:
            complained_mails += build_blocks_complaint(complained_recipient, message_json)
            mail = complained_recipient['emailAddress']

        complained_message = prepare_complained_message(message_json)
        complained_message = complained_message + complained_mails
        notice_message = "COMPLAINT: " + mail
        
        if not is_ignore_mail(mail):
            post_slack(complained_message, notice_message)

    return


def lambda_handler(event, context):
    if event['Records'][0]['EventSource'] == 'aws:sns' :
        ses_process(event)

    return