#! /usr/bin/env python3

from email.mime.multipart import MIMEMultipart
from email.mime.text import MIMEText
from contextlib import closing
from sql import sql_queries
import snowflake.connector
import psycopg2
import smtplib
import argparse
import sys
import json
import datetime

with open('config.json', 'r') as f:
    config = json.load(f)
sf_user = config['snowflake']["user"]
sf_password = config['snowflake']["password"]
sf_account = config['snowflake']["account"]
sf_warehouse = config['snowflake']['warehouse']

db_name_slz = config['postgres_slz']["database"]
db_user_slz = config['postgres_slz']["user"]
db_password_slz = config['postgres_slz']["password"]
db_host_slz = config['postgres_slz']["host"]
db_port_slz = config['postgres_slz']["port"]

local_db_name = config['failure_counter']["database"]
local_db_user = config['failure_counter']["user"]
local_db_password = config['failure_counter']["password"]
local_db_host = config['failure_counter']["host"]
local_db_port = config['failure_counter']["port"]

failure_count_increase = "UPDATE failed_count SET failed_count = failed_count + 1, last = 'FAILED', last_updated = NOW() WHERE count_id = 'grasea';"
failure_count_to_zero = "UPDATE failed_count SET failed_count = 0, last = 'OK', last_updated = NOW() WHERE count_id = 'grasea';"

def postgres_update_failure_count(sql_query):
    with closing(psycopg2.connect(database=local_db_name, user=local_db_user, password=local_db_password, host=local_db_host, port=local_db_port)) as connection:
        with connection.cursor() as cursor:
            cursor.execute(sql_query)
            connection.commit()

def create_arg_parser():
    parser = argparse.ArgumentParser()
    parser.add_argument('-m', '--mail',
                        nargs='+',
                        action='store',
                        dest='recipients',
                        type=str)
    parser.add_argument('-p', '--print', action="store_const", const=True)
    return parser


def send_mail(recipients: str, message: str, status: str) -> None:
    # Create a multipart message
    msg = MIMEMultipart()
    body_part = MIMEText(message, 'plain')
    msg['Subject'] = f"[{status}][PROD] GRAS (Exploration Area)"
    msg['From'] = "support.sme@dataart.com"
    msg['To'] = recipients
    # Add body to email
    msg.attach(body_part)
    # Create SMTP object
    server = smtplib.SMTP('relay1.dataart.com', 25)
    server.sendmail(msg['From'], msg['To'].split(','), msg.as_string())
    server.quit()


def snowflake_fetch_data(sql_query) -> dict:
    ctx = snowflake.connector.connect(
        user=sf_user,
        password=sf_password,
        account=sf_account,
        warehouse=sf_warehouse
    )
    cs = ctx.cursor(snowflake.connector.DictCursor)
    try:
        cs.execute(sql_query)
        result_dict = cs.fetchall()
    finally:
        cs.close()
    ctx.close()
    return result_dict


def postgres_fetch_data_slz(sql_query) -> list:
    result_list = []
    with closing(psycopg2.connect(database=db_name_slz, user=db_user_slz, password=db_password_slz, host=db_host_slz, port=db_port_slz)) as connection:
        with connection.cursor() as cursor:
            cursor.execute(sql_query)
            columns = cursor.description
            rows = cursor.fetchall()
    for row in rows:
        tmp = {}
        for i in range(len(columns)):
            tmp[columns[i][0]] = row[i]
        result_list.append(tmp)
    return result_list

def check_1_to_47() -> dict:
    result_dict = {}
    full_log = {}

    ### Check 1 SLZ status (expected result: 0 results) ################################################
    tmp_pg_check_1 = postgres_fetch_data_slz(sql_queries.pg_check_1)
    print(f"SLZ_STATUS_CHECK_1: - {tmp_pg_check_1}")
    #Check
    if tmp_pg_check_1:
        full_log["SLZ_STATUS_CHECK_1"] = {}
        result_dict["SLZ_STATUS_CHECK_1"] = {}
        for item in tmp_pg_check_1:
            full_log["SLZ_STATUS_CHECK_1"].update({item['REPORT_DATE'].strftime("%Y-%m-%d"): item['MISSING_REPORTS'].lower()})
            print(f"{item['REPORT_DATE']} - {item['MISSING_REPORTS']}")
            result_dict["SLZ_STATUS_CHECK_1"].update({item['REPORT_DATE'].strftime("%Y-%m-%d"): item['MISSING_REPORTS'].lower()})
    else:
        full_log["SLZ_STATUS_CHECK_1"] = {'SLZ_STATUS_CHECK_1': 'Query returned 0 results'}

    ### Check 2 All GRAS reports for previous day are uploaded to Snowflake  (expected result: result == TRUE) ################################################
    tmp_sf_check_2 = snowflake_fetch_data(sql_queries.sf_check_2)
    sf_check_2_result = tmp_sf_check_2[0]['RESULT']
    expected = True
    print(f"CHECK_2: - {sf_check_2_result}")
    full_log["CHECK_2"] = {'CHECK_2_RESULT': sf_check_2_result}

    if sf_check_2_result != expected:
        result_dict["CHECK_2"] = {'CHECK_2_RESULT': "Failed: Query returned sf_check_2_result"}

    ### Check 3 RAW -> All GRAS reports for previous day are uploaded to Snowflake RAW schema (expected result: All results == TRUE) ################################################
    tmp_sf_check_3 = snowflake_fetch_data(sql_queries.sf_check_3)
    print(f"CHECK_3: - {tmp_sf_check_3}")
    if tmp_sf_check_3:
        full_log["CHECK_3"] = tmp_sf_check_3
        for item in tmp_sf_check_3:
            expected = True
            sf_check_3_result = item['RESULT']
            print(f"{sf_check_3_result}")
            if sf_check_3_result != expected:
                result_dict["CHECK_3"] = {}
                result_dict["CHECK_3"] = {'CHECK_3_RESULT': "Failed: Not All results are TRUE"}
            else:
                full_log["CHECK_3"] = {'CHECK_3': 'All results are TRUE'}

    ### Check 4 RAW → EXP - GRAS_BUSINESS_UNIT - Import status successful (expected result: dest; SF exp => (equal or bigger) then dest; SF raw) ################################################
    tmp_sf_check_4 = snowflake_fetch_data(sql_queries.sf_check_4)
    sf_check_4_dest = int(tmp_sf_check_4[0]['count'])
    sf_check_4_src = int(tmp_sf_check_4[1]['count'])
    print(f"DEST_EXP_CHECK_4: - {sf_check_4_dest}")
    print(f"SRC_RAW_CHECK_4: - {sf_check_4_src}")
    full_log["CHECK_4"] = {'DEST_EXP_CHECK_4': sf_check_4_dest, 'SRC_RAW_CHECK_4': sf_check_4_src}

    if sf_check_4_dest < sf_check_4_src:
        result_dict["CHECK_4"] = full_log["CHECK_4"]

    ### Check 5 RAW → EXP - GRAS_COMPANY - Import status successful (expected result: dest; SF exp => (equal or bigger) then dest; SF raw) ################################################
    tmp_sf_check_5 = snowflake_fetch_data(sql_queries.sf_check_5)
    sf_check_5_dest = int(tmp_sf_check_5[0]['count'])
    sf_check_5_src = int(tmp_sf_check_5[1]['count'])
    print(f"DEST_EXP_CHECK_5: - {sf_check_5_dest}")
    print(f"SRC_RAW_CHECK_5: - {sf_check_5_src}")
    full_log["CHECK_5"] = {'DEST_EXP_CHECK_5': sf_check_5_dest, 'SRC_RAW_CHECK_5': sf_check_5_src}

    if sf_check_5_dest < sf_check_5_src:
        result_dict["CHECK_5"] = full_log["CHECK_5"]

    ### Check 6 RAW → EXP - GRAS_CONFIGURATION - Import status successful (expected result: dest; SF exp => (equal or bigger) then dest; SF raw) ################################################
    tmp_sf_check_6 = snowflake_fetch_data(sql_queries.sf_check_6)
    sf_check_6_dest = int(tmp_sf_check_6[0]['count'])
    sf_check_6_src = int(tmp_sf_check_6[1]['count'])
    print(f"DEST_EXP_CHECK_6: - {sf_check_6_dest}")
    print(f"SRC_RAW_CHECK_6: - {sf_check_6_src}")
    full_log["CHECK_6"] = {'DEST_EXP_CHECK_6': sf_check_6_dest, 'SRC_RAW_CHECK_6': sf_check_6_src}

    if sf_check_6_dest < sf_check_6_src:
        result_dict["CHECK_6"] = full_log["CHECK_6"]

    ### Check 7 RAW → EXP - GRAS_CONFIGURATION_CATEGORY - Import status successful (expected result: dest; SF exp => (equal or bigger) then dest; SF raw) ################################################
    tmp_sf_check_7 = snowflake_fetch_data(sql_queries.sf_check_7)
    sf_check_7_dest = int(tmp_sf_check_7[0]['count'])
    sf_check_7_src = int(tmp_sf_check_7[1]['count'])
    print(f"DEST_EXP_CHECK_7: - {sf_check_7_dest}")
    print(f"SRC_RAW_CHECK_7: - {sf_check_7_src}")
    full_log["CHECK_7"] = {'DEST_EXP_CHECK_7': sf_check_7_dest, 'SRC_RAW_CHECK_7': sf_check_7_src}

    if sf_check_7_dest < sf_check_7_src:
        result_dict["CHECK_7"] = full_log["CHECK_7"]

    ### Check 8 RAW → EXP - GRAS_COUNTRY - Import status successful (expected result: dest; SF exp => (equal or bigger) then dest; SF raw) ################################################
    tmp_sf_check_8 = snowflake_fetch_data(sql_queries.sf_check_8)
    sf_check_8_dest = int(tmp_sf_check_8[0]['count'])
    sf_check_8_src = int(tmp_sf_check_8[1]['count'])
    print(f"DEST_EXP_CHECK_8: - {sf_check_8_dest}")
    print(f"SRC_RAW_CHECK_8: - {sf_check_8_src}")
    full_log["CHECK_8"] = {'DEST_EXP_CHECK_8': sf_check_8_dest, 'SRC_RAW_CHECK_8': sf_check_8_src}

    if sf_check_8_dest < sf_check_8_src:
        result_dict["CHECK_8"] = full_log["CHECK_8"]

    ### Check 9 RAW → EXP - GRAS_GENRE - Import status successful (expected result: dest; SF exp => (equal or bigger) then dest; SF raw) ################################################
    tmp_sf_check_9 = snowflake_fetch_data(sql_queries.sf_check_9)
    sf_check_9_dest = int(tmp_sf_check_9[0]['count'])
    sf_check_9_src = int(tmp_sf_check_9[1]['count'])
    print(f"DEST_EXP_CHECK_9: - {sf_check_9_dest}")
    print(f"SRC_RAW_CHECK_9: - {sf_check_9_src}")
    full_log["CHECK_9"] = {'DEST_EXP_CHECK_9': sf_check_9_dest, 'SRC_RAW_CHECK_9': sf_check_9_src}

    if sf_check_9_dest < sf_check_9_src:
        result_dict["CHECK_9"] = full_log["CHECK_9"]

    ### Check 10 RAW → EXP - GRAS_LABEL - Import status successful (expected result: dest; SF exp => (equal or bigger) then dest; SF raw) ################################################
    tmp_sf_check_10 = snowflake_fetch_data(sql_queries.sf_check_10)
    sf_check_10_dest = int(tmp_sf_check_10[0]['count'])
    sf_check_10_src = int(tmp_sf_check_10[1]['count'])
    print(f"DEST_EXP_CHECK_10: - {sf_check_10_dest}")
    print(f"SRC_RAW_CHECK_10: - {sf_check_10_src}")
    full_log["CHECK_10"] = {'DEST_EXP_CHECK_10': sf_check_10_dest, 'SRC_RAW_CHECK_10': sf_check_10_src}

    if sf_check_10_dest < sf_check_10_src:
        result_dict["CHECK_10"] = full_log["CHECK_10"]

    ### Check 11 RAW → EXP - GRAS_LANGUAGE - Import status successful (expected result: dest; SF exp => (equal or bigger) then dest; SF raw) ################################################
    tmp_sf_check_11 = snowflake_fetch_data(sql_queries.sf_check_11)
    sf_check_11_dest = int(tmp_sf_check_11[0]['count'])
    sf_check_11_src = int(tmp_sf_check_11[1]['count'])
    print(f"DEST_EXP_CHECK_11: - {sf_check_11_dest}")
    print(f"SRC_RAW_CHECK_11: - {sf_check_11_src}")
    full_log["CHECK_11"] = {'DEST_EXP_CHECK_11': sf_check_11_dest, 'SRC_RAW_CHECK_11': sf_check_11_src}

    if sf_check_11_dest < sf_check_11_src:
        result_dict["CHECK_11"] = full_log["CHECK_11"]

    ### Check 12 RAW → EXP - GRAS_MEDIA_TYPE - Import status successful (expected result: dest; SF exp => (equal or bigger) then dest; SF raw) ################################################
    tmp_sf_check_12 = snowflake_fetch_data(sql_queries.sf_check_12)
    sf_check_12_dest = int(tmp_sf_check_12[0]['count'])
    sf_check_12_src = int(tmp_sf_check_12[1]['count'])
    print(f"DEST_EXP_CHECK_12: - {sf_check_12_dest}")
    print(f"SRC_RAW_CHECK_12: - {sf_check_12_src}")
    full_log["CHECK_12"] = {'DEST_EXP_CHECK_12': sf_check_12_dest, 'SRC_RAW_CHECK_12': sf_check_12_src}

    if sf_check_12_dest < sf_check_12_src:
        result_dict["CHECK_12"] = full_log["CHECK_12"]

    ### Check 13 RAW → RAW → EXP - GRAS_PARTICIPANT - Import status successful (expected result: Counts match) ################################################
    tmp_sf_check_13 = snowflake_fetch_data(sql_queries.sf_check_13)
    sf_check_13_dest = int(tmp_sf_check_13[0]['count'])
    sf_check_13_src = int(tmp_sf_check_13[1]['count'])
    print(f"DEST_EXP_CHECK_13: - {sf_check_13_dest}")
    print(f"SRC_RAW_CHECK_13: - {sf_check_13_src}")
    full_log["CHECK_13"] = {'DEST_EXP_CHECK_13': sf_check_13_dest, 'SRC_RAW_CHECK_13': sf_check_13_src}

    if sf_check_13_dest != sf_check_13_src:
        result_dict["CHECK_13"] = full_log["CHECK_13"]

    ### Check 14 RAW → EXP - GRAS_PARTICIPANT_MEMBER - Import status successful (expected result: Counts match) ################################################
    tmp_sf_check_14 = snowflake_fetch_data(sql_queries.sf_check_14)
    sf_check_14_dest = int(tmp_sf_check_14[0]['count'])
    sf_check_14_src = int(tmp_sf_check_14[1]['count'])
    print(f"DEST_EXP_CHECK_14: - {sf_check_14_dest}")
    print(f"SRC_RAW_CHECK_14: - {sf_check_14_src}")
    full_log["CHECK_14"] = {'DEST_EXP_CHECK_14': sf_check_14_dest, 'SRC_RAW_CHECK_14': sf_check_14_src}

    if sf_check_14_dest != sf_check_14_src:
        result_dict["CHECK_14"] = full_log["CHECK_14"]

    ### Check 15 RAW → EXP - GRAS_PRODUCT - Import status successful (expected result: Counts match) ################################################
    tmp_sf_check_15 = snowflake_fetch_data(sql_queries.sf_check_15)
    sf_check_15_dest = int(tmp_sf_check_15[0]['count'])
    sf_check_15_src = int(tmp_sf_check_15[1]['count'])
    print(f"DEST_EXP_CHECK_15: - {sf_check_15_dest}")
    print(f"SRC_RAW_CHECK_15: - {sf_check_15_src}")
    full_log["CHECK_15"] = {'DEST_EXP_CHECK_15': sf_check_15_dest, 'SRC_RAW_CHECK_15': sf_check_15_src}

    if sf_check_15_dest != sf_check_15_src:
        result_dict["CHECK_15"] = full_log["CHECK_15"]

    ### Check 16 RAW → EXP - GRAS_PRODUCT_CLASS - Import status successful (expected result: dest; SF exp => (equal or bigger) then dest; SF raw) ################################################
    tmp_sf_check_16 = snowflake_fetch_data(sql_queries.sf_check_16)
    sf_check_16_dest = int(tmp_sf_check_16[0]['count'])
    sf_check_16_src = int(tmp_sf_check_16[1]['count'])
    print(f"DEST_EXP_CHECK_16: - {sf_check_16_dest}")
    print(f"SRC_RAW_CHECK_16: - {sf_check_16_src}")
    full_log["CHECK_16"] = {'DEST_EXP_CHECK_16': sf_check_16_dest, 'SRC_RAW_CHECK_16': sf_check_16_src}

    if sf_check_16_dest < sf_check_16_src:
        result_dict["CHECK_16"] = full_log["CHECK_16"]

    ### Check 17 RAW → EXP - GRAS_PRODUCT_TRACK - Import status successful (expected result: Counts match) ################################################
    tmp_sf_check_17 = snowflake_fetch_data(sql_queries.sf_check_17)
    sf_check_17_dest = int(tmp_sf_check_17[0]['count'])
    sf_check_17_src = int(tmp_sf_check_17[1]['count'])
    print(f"DEST_EXP_CHECK_17: - {sf_check_17_dest}")
    print(f"SRC_RAW_CHECK_17: - {sf_check_17_src}")
    full_log["CHECK_17"] = {'DEST_EXP_CHECK_17': sf_check_17_dest, 'SRC_RAW_CHECK_17': sf_check_17_src}

    if sf_check_17_dest != sf_check_17_src:
        result_dict["CHECK_17"] = full_log["CHECK_17"]

    ### Check 18 RAW → EXP - GRAS_PRODUCT_VERSION - Import status successful (expected result: Counts match) ################################################
    tmp_sf_check_18 = snowflake_fetch_data(sql_queries.sf_check_18)
    sf_check_18_dest = int(tmp_sf_check_18[0]['count'])
    sf_check_18_src = int(tmp_sf_check_18[1]['count'])
    print(f"DEST_EXP_CHECK_18: - {sf_check_18_dest}")
    print(f"SRC_RAW_CHECK_18: - {sf_check_18_src}")
    full_log["CHECK_18"] = {'DEST_EXP_CHECK_18': sf_check_18_dest, 'SRC_RAW_CHECK_18': sf_check_18_src}

    if sf_check_18_dest != sf_check_18_src:
        result_dict["CHECK_18"] = full_log["CHECK_18"]

    ### Check 19 RAW → EXP - GRAS_PROJECT_ARTIST - Import status successful (expected result: Counts match) ################################################
    tmp_sf_check_19 = snowflake_fetch_data(sql_queries.sf_check_19)
    sf_check_19_dest = int(tmp_sf_check_19[0]['count'])
    sf_check_19_src = int(tmp_sf_check_19[1]['count'])
    print(f"DEST_EXP_CHECK_19: - {sf_check_19_dest}")
    print(f"SRC_RAW_CHECK_19: - {sf_check_19_src}")
    full_log["CHECK_19"] = {'DEST_EXP_CHECK_19': sf_check_19_dest, 'SRC_RAW_CHECK_19': sf_check_19_src}

    if sf_check_19_dest != sf_check_19_src:
        result_dict["CHECK_19"] = full_log["CHECK_19"]

    ### Check 20 RAW → EXP - GRAS_PROJECT_TYPE - Import status successful (expected result: dest; SF exp => (equal or bigger) then dest; SF raw) ################################################
    tmp_sf_check_20 = snowflake_fetch_data(sql_queries.sf_check_20)
    sf_check_20_dest = int(tmp_sf_check_20[0]['count'])
    sf_check_20_src = int(tmp_sf_check_20[1]['count'])
    print(f"DEST_EXP_CHECK_20: - {sf_check_20_dest}")
    print(f"SRC_RAW_CHECK_20: - {sf_check_20_src}")
    full_log["CHECK_20"] = {'DEST_EXP_CHECK_20': sf_check_20_dest, 'SRC_RAW_CHECK_20': sf_check_20_src}

    if sf_check_20_dest < sf_check_20_src:
        result_dict["CHECK_20"] = full_log["CHECK_20"]

    ### Check 21 RAW → EXP - GRAS_RECORDING_PROJECT - Import status successful (expected result: Counts match) ################################################
    tmp_sf_check_21 = snowflake_fetch_data(sql_queries.sf_check_21)
    sf_check_21_dest = int(tmp_sf_check_21[0]['count'])
    sf_check_21_src = int(tmp_sf_check_21[1]['count'])
    print(f"DEST_EXP_CHECK_21: - {sf_check_21_dest}")
    print(f"SRC_RAW_CHECK_21: - {sf_check_21_src}")
    full_log["CHECK_21"] = {'DEST_EXP_CHECK_21': sf_check_21_dest, 'SRC_RAW_CHECK_21': sf_check_21_src}

    if sf_check_21_dest != sf_check_21_src:
        result_dict["CHECK_21"] = full_log["CHECK_21"]

    ### Check 22 RAW → EXP - GRAS_REC_PROJECT_PRODUCT_VERSION - Import status successful (expected result: Counts match) ################################################
#    tmp_sf_check_22 = snowflake_fetch_data(sql_queries.sf_check_22)
#    sf_check_22_dest = int(tmp_sf_check_22[0]['count'])
#    sf_check_22_src = int(tmp_sf_check_22[1]['count'])
#    print(f"DEST_EXP_CHECK_22: - {sf_check_22_dest}")
#    print(f"SRC_RAW_CHECK_22: - {sf_check_22_src}")
#    full_log["CHECK_22"] = {'DEST_EXP_CHECK_22': sf_check_22_dest, 'SRC_RAW_CHECK_22': sf_check_22_src}
#
#    if sf_check_22_dest != sf_check_22_src:
#        result_dict["CHECK_22"] = full_log["CHECK_22"]

    ### Check 23 RAW → EXP - GRAS_REPERTOIRE_OWNER_HIERARCHY - Import status successful (expected result: dest; SF exp => (equal or bigger) then dest; SF raw) ################################################
    tmp_sf_check_23 = snowflake_fetch_data(sql_queries.sf_check_23)
    sf_check_23_dest = int(tmp_sf_check_23[0]['count'])
    sf_check_23_src = int(tmp_sf_check_23[1]['count'])
    print(f"DEST_EXP_CHECK_23: - {sf_check_23_dest}")
    print(f"SRC_RAW_CHECK_23: - {sf_check_23_src}")
    full_log["CHECK_23"] = {'DEST_EXP_CHECK_23': sf_check_23_dest, 'SRC_RAW_CHECK_23': sf_check_23_src}

    if sf_check_23_dest < sf_check_23_src:
        result_dict["CHECK_23"] = full_log["CHECK_23"]

    ### Check 24 RAW → EXP - GRAS_TRACK  - Import status successful (expected result: Counts match) ################################################
    tmp_sf_check_24 = snowflake_fetch_data(sql_queries.sf_check_24)
    sf_check_24_dest = int(tmp_sf_check_24[0]['count'])
    sf_check_24_src = int(tmp_sf_check_24[1]['count'])
    print(f"DEST_EXP_CHECK_24: - {sf_check_24_dest}")
    print(f"SRC_RAW_CHECK_24: - {sf_check_24_src}")
    full_log["CHECK_24"] = {'DEST_EXP_CHECK_24': sf_check_24_dest, 'SRC_RAW_CHECK_24': sf_check_24_src}

    if sf_check_24_dest != sf_check_24_src:
        result_dict["CHECK_24"] = full_log["CHECK_24"]

    ### Check 25 RAW → EXP - GRAS_TRACK_PARTICIPANT  - Import status successful (expected result: Counts match) ################################################
    tmp_sf_check_25 = snowflake_fetch_data(sql_queries.sf_check_25)
    sf_check_25_dest = int(tmp_sf_check_25[0]['count'])
    sf_check_25_src = int(tmp_sf_check_25[1]['count'])
    print(f"DEST_EXP_CHECK_25: - {sf_check_25_dest}")
    print(f"SRC_RAW_CHECK_25: - {sf_check_25_src}")
    full_log["CHECK_25"] = {'DEST_EXP_CHECK_25': sf_check_25_dest, 'SRC_RAW_CHECK_25': sf_check_25_src}

    if sf_check_25_dest != sf_check_25_src:
        result_dict["CHECK_25"] = full_log["CHECK_25"]

    ### Check 26 EXP → View - GRAS_BUSINESS_UNIT (expected result: Counts match) ################################################
    tmp_sf_check_26 = snowflake_fetch_data(sql_queries.sf_check_26)
    sf_check_26_src = int(tmp_sf_check_26[0]['count'])
    sf_check_26_dest = int(tmp_sf_check_26[1]['count'])
    print(f"SRC_EXP_CHECK_26: - {sf_check_26_src}")
    print(f"DEST_EXP_VIEW_CHECK_26: - {sf_check_26_dest}")
    full_log["CHECK_26"] = {'SRC_EXP_CHECK_26': sf_check_26_src, 'DEST_EXP_VIEW_CHECK_26': sf_check_26_dest}

    if sf_check_26_src != sf_check_26_dest:
        result_dict["CHECK_26"] = full_log["CHECK_26"]

    ### Check 27 EXP → View - GRAS_COMPANY (expected result: Counts match) ################################################
    tmp_sf_check_27 = snowflake_fetch_data(sql_queries.sf_check_27)
    sf_check_27_src = int(tmp_sf_check_27[0]['count'])
    sf_check_27_dest = int(tmp_sf_check_27[1]['count'])
    print(f"SRC_EXP_CHECK_27: - {sf_check_27_src}")
    print(f"DEST_EXP_VIEW_CHECK_27: - {sf_check_27_dest}")
    full_log["CHECK_27"] = {'SRC_EXP_CHECK_27': sf_check_27_src, 'DEST_EXP_VIEW_CHECK_27': sf_check_27_dest}

    if sf_check_27_src != sf_check_27_dest:
        result_dict["CHECK_27"] = full_log["CHECK_27"]

    ### Check 28 EXP → View - GRAS_CONFIGURATION (expected result: Counts match) ################################################
    tmp_sf_check_28 = snowflake_fetch_data(sql_queries.sf_check_28)
    sf_check_28_src = int(tmp_sf_check_28[0]['count'])
    sf_check_28_dest = int(tmp_sf_check_28[1]['count'])
    print(f"SRC_EXP_CHECK_28: - {sf_check_28_src}")
    print(f"DEST_EXP_VIEW_CHECK_28: - {sf_check_28_dest}")
    full_log["CHECK_28"] = {'SRC_EXP_CHECK_28': sf_check_28_src, 'DEST_EXP_VIEW_CHECK_28': sf_check_28_dest}

    if sf_check_28_src != sf_check_28_dest:
        result_dict["CHECK_28"] = full_log["CHECK_28"]

    ### Check 29 EXP → View - GRAS_CONFIGURATION_CATEGORY (expected result: Counts match) ################################################
    tmp_sf_check_29 = snowflake_fetch_data(sql_queries.sf_check_29)
    sf_check_29_src = int(tmp_sf_check_29[0]['count'])
    sf_check_29_dest = int(tmp_sf_check_29[1]['count'])
    print(f"SRC_EXP_CHECK_29: - {sf_check_29_src}")
    print(f"DEST_EXP_VIEW_CHECK_29: - {sf_check_29_dest}")
    full_log["CHECK_29"] = {'SRC_EXP_CHECK_29': sf_check_29_src, 'DEST_EXP_VIEW_CHECK_29': sf_check_29_dest}

    if sf_check_29_src != sf_check_29_dest:
        result_dict["CHECK_29"] = full_log["CHECK_29"]

    ### Check 30 EXP → View - GRAS_COUNTRY (expected result: Counts match) ################################################
    tmp_sf_check_30 = snowflake_fetch_data(sql_queries.sf_check_30)
    sf_check_30_src = int(tmp_sf_check_30[0]['count'])
    sf_check_30_dest = int(tmp_sf_check_30[1]['count'])
    print(f"SRC_EXP_CHECK_30: - {sf_check_30_src}")
    print(f"DEST_EXP_VIEW_CHECK_30: - {sf_check_30_dest}")
    full_log["CHECK_30"] = {'SRC_EXP_CHECK_30': sf_check_30_src, 'DEST_EXP_VIEW_CHECK_30': sf_check_30_dest}

    if sf_check_30_src != sf_check_30_dest:
        result_dict["CHECK_30"] = full_log["CHECK_30"]

    ### Check 31 EXP → View - GRAS_GENRE (expected result: Counts match) ################################################
    tmp_sf_check_31 = snowflake_fetch_data(sql_queries.sf_check_31)
    sf_check_31_src = int(tmp_sf_check_31[0]['count'])
    sf_check_31_dest = int(tmp_sf_check_31[1]['count'])
    print(f"SRC_EXP_CHECK_31: - {sf_check_31_src}")
    print(f"DEST_EXP_VIEW_CHECK_31: - {sf_check_31_dest}")
    full_log["CHECK_31"] = {'SRC_EXP_CHECK_31': sf_check_31_src, 'DEST_EXP_VIEW_CHECK_31': sf_check_31_dest}

    if sf_check_31_src != sf_check_31_dest:
        result_dict["CHECK_31"] = full_log["CHECK_31"]

    ### Check 32 EXP → View - GRAS_LABEL (expected result: Counts match) ################################################
    tmp_sf_check_32 = snowflake_fetch_data(sql_queries.sf_check_32)
    sf_check_32_src = int(tmp_sf_check_32[0]['count'])
    sf_check_32_dest = int(tmp_sf_check_32[1]['count'])
    print(f"SRC_EXP_CHECK_32: - {sf_check_32_src}")
    print(f"DEST_EXP_VIEW_CHECK_32: - {sf_check_32_dest}")
    full_log["CHECK_32"] = {'SRC_EXP_CHECK_32': sf_check_32_src, 'DEST_EXP_VIEW_CHECK_32': sf_check_32_dest}

    if sf_check_32_src != sf_check_32_dest:
        result_dict["CHECK_32"] = full_log["CHECK_32"]

    ### Check 33 EXP → View - GRAS_LANGUAGE (expected result: Counts match) ################################################
    tmp_sf_check_33 = snowflake_fetch_data(sql_queries.sf_check_33)
    sf_check_33_src = int(tmp_sf_check_33[0]['count'])
    sf_check_33_dest = int(tmp_sf_check_33[1]['count'])
    print(f"SRC_EXP_CHECK_33: - {sf_check_33_src}")
    print(f"DEST_EXP_VIEW_CHECK_33: - {sf_check_33_dest}")
    full_log["CHECK_33"] = {'SRC_EXP_CHECK_33': sf_check_33_src, 'DEST_EXP_VIEW_CHECK_33': sf_check_33_dest}

    if sf_check_33_src != sf_check_33_dest:
        result_dict["CHECK_33"] = full_log["CHECK_33"]

    ### Check 34 EXP → View - GRAS_MEDIA_TYPE (expected result: Counts match) ################################################
    tmp_sf_check_34 = snowflake_fetch_data(sql_queries.sf_check_34)
    sf_check_34_src = int(tmp_sf_check_34[0]['count'])
    sf_check_34_dest = int(tmp_sf_check_34[1]['count'])
    print(f"SRC_EXP_CHECK_34: - {sf_check_34_src}")
    print(f"DEST_EXP_VIEW_CHECK_34: - {sf_check_34_dest}")
    full_log["CHECK_34"] = {'SRC_EXP_CHECK_34': sf_check_34_src, 'DEST_EXP_VIEW_CHECK_34': sf_check_34_dest}

    if sf_check_34_src != sf_check_34_dest:
        result_dict["CHECK_34"] = full_log["CHECK_34"]

    ### Check 35 EXP → View - GRAS_PARTICIPANT (expected result: Counts match) ################################################
    tmp_sf_check_35 = snowflake_fetch_data(sql_queries.sf_check_35)
    sf_check_35_src = int(tmp_sf_check_35[0]['count'])
    sf_check_35_dest = int(tmp_sf_check_35[1]['count'])
    print(f"SRC_EXP_CHECK_35: - {sf_check_35_src}")
    print(f"DEST_EXP_VIEW_CHECK_35: - {sf_check_35_dest}")
    full_log["CHECK_35"] = {'SRC_EXP_CHECK_35': sf_check_35_src, 'DEST_EXP_VIEW_CHECK_35': sf_check_35_dest}

    if sf_check_35_src != sf_check_35_dest:
        result_dict["CHECK_35"] = full_log["CHECK_35"]

    ### Check 36 EXP → View - GRAS_PARTICIPANT_MEMBER (expected result: Counts match) ################################################
    tmp_sf_check_36 = snowflake_fetch_data(sql_queries.sf_check_36)
    sf_check_36_src = int(tmp_sf_check_36[0]['count'])
    sf_check_36_dest = int(tmp_sf_check_36[1]['count'])
    print(f"SRC_EXP_CHECK_36: - {sf_check_36_src}")
    print(f"DEST_EXP_VIEW_CHECK_36: - {sf_check_36_dest}")
    full_log["CHECK_36"] = {'SRC_EXP_CHECK_36': sf_check_36_src, 'DEST_EXP_VIEW_CHECK_36': sf_check_36_dest}

    if sf_check_36_src != sf_check_36_dest:
        result_dict["CHECK_36"] = full_log["CHECK_36"]

    ### Check 37 EXP → View - GRAS_PRODUCT (expected result: Counts match) ################################################
    tmp_sf_check_37 = snowflake_fetch_data(sql_queries.sf_check_37)
    sf_check_37_src = int(tmp_sf_check_37[0]['count'])
    sf_check_37_dest = int(tmp_sf_check_37[1]['count'])
    print(f"SRC_EXP_CHECK_37: - {sf_check_37_src}")
    print(f"DEST_EXP_VIEW_CHECK_37: - {sf_check_37_dest}")
    full_log["CHECK_37"] = {'SRC_EXP_CHECK_37': sf_check_37_src, 'DEST_EXP_VIEW_CHECK_37': sf_check_37_dest}

    if sf_check_37_src != sf_check_37_dest:
        result_dict["CHECK_37"] = full_log["CHECK_37"]

    ### Check 38 EXP → View - GRAS_PRODUCT_CLASS (expected result: Counts match) ################################################
    tmp_sf_check_38 = snowflake_fetch_data(sql_queries.sf_check_38)
    sf_check_38_src = int(tmp_sf_check_38[0]['count'])
    sf_check_38_dest = int(tmp_sf_check_38[1]['count'])
    print(f"SRC_EXP_CHECK_38: - {sf_check_38_src}")
    print(f"DEST_EXP_VIEW_CHECK_38: - {sf_check_38_dest}")
    full_log["CHECK_38"] = {'SRC_EXP_CHECK_38': sf_check_38_src, 'DEST_EXP_VIEW_CHECK_38': sf_check_38_dest}

    if sf_check_38_src != sf_check_38_dest:
        result_dict["CHECK_38"] = full_log["CHECK_38"]

    ### Check 39 EXP → View - GRAS_PRODUCT_TRACK (expected result: Counts match) ################################################
    tmp_sf_check_39 = snowflake_fetch_data(sql_queries.sf_check_39)
    sf_check_39_src = int(tmp_sf_check_39[0]['count'])
    sf_check_39_dest = int(tmp_sf_check_39[1]['count'])
    print(f"SRC_EXP_CHECK_39: - {sf_check_39_src}")
    print(f"DEST_EXP_VIEW_CHECK_39: - {sf_check_39_dest}")
    full_log["CHECK_39"] = {'SRC_EXP_CHECK_39': sf_check_39_src, 'DEST_EXP_VIEW_CHECK_39': sf_check_39_dest}

    if sf_check_39_src != sf_check_39_dest:
        result_dict["CHECK_39"] = full_log["CHECK_39"]

    ### Check 40 EXP → View - GRAS_PRODUCT_VERSION (expected result: Counts match) ################################################
    tmp_sf_check_40 = snowflake_fetch_data(sql_queries.sf_check_40)
    sf_check_40_src = int(tmp_sf_check_40[0]['count'])
    sf_check_40_dest = int(tmp_sf_check_40[1]['count'])
    print(f"SRC_EXP_CHECK_40: - {sf_check_40_src}")
    print(f"DEST_EXP_VIEW_CHECK_40: - {sf_check_40_dest}")
    full_log["CHECK_40"] = {'SRC_EXP_CHECK_40': sf_check_40_src, 'DEST_EXP_VIEW_CHECK_40': sf_check_40_dest}

    if sf_check_40_src != sf_check_40_dest:
        result_dict["CHECK_40"] = full_log["CHECK_40"]

    ### Check 41 EXP → View - GRAS_PROJECT_ARTIST (expected result: Counts match) ################################################
    tmp_sf_check_41 = snowflake_fetch_data(sql_queries.sf_check_41)
    sf_check_41_src = int(tmp_sf_check_41[0]['count'])
    sf_check_41_dest = int(tmp_sf_check_41[1]['count'])
    print(f"SRC_EXP_CHECK_41: - {sf_check_41_src}")
    print(f"DEST_EXP_VIEW_CHECK_41: - {sf_check_41_dest}")
    full_log["CHECK_41"] = {'SRC_EXP_CHECK_41': sf_check_41_src, 'DEST_EXP_VIEW_CHECK_41': sf_check_41_dest}

    if sf_check_41_src != sf_check_41_dest:
        result_dict["CHECK_41"] = full_log["CHECK_41"]

    ### Check 42 EXP → View - GRAS_PROJECT_TYPE (expected result: Counts match) ################################################
    tmp_sf_check_42 = snowflake_fetch_data(sql_queries.sf_check_42)
    sf_check_42_src = int(tmp_sf_check_42[0]['count'])
    sf_check_42_dest = int(tmp_sf_check_42[1]['count'])
    print(f"SRC_EXP_CHECK_42: - {sf_check_42_src}")
    print(f"DEST_EXP_VIEW_CHECK_42: - {sf_check_42_dest}")
    full_log["CHECK_42"] = {'SRC_EXP_CHECK_42': sf_check_42_src, 'DEST_EXP_VIEW_CHECK_42': sf_check_42_dest}

    if sf_check_42_src != sf_check_42_dest:
        result_dict["CHECK_42"] = full_log["CHECK_42"]

    ### Check 43 EXP → View - GRAS_REC_PROJECT_PRODUCT_VERSION (expected result: Counts match) ################################################
    tmp_sf_check_43 = snowflake_fetch_data(sql_queries.sf_check_43)
    sf_check_43_src = int(tmp_sf_check_43[0]['count'])
    sf_check_43_dest = int(tmp_sf_check_43[1]['count'])
    print(f"SRC_EXP_CHECK_43: - {sf_check_43_src}")
    print(f"DEST_EXP_VIEW_CHECK_43: - {sf_check_43_dest}")
    full_log["CHECK_43"] = {'SRC_EXP_CHECK_43': sf_check_43_src, 'DEST_EXP_VIEW_CHECK_43': sf_check_43_dest}

    if sf_check_43_src != sf_check_43_dest:
        result_dict["CHECK_43"] = full_log["CHECK_43"]

    ### Check 44 EXP → View - GRAS_RECORDING_PROJECT (expected result: Counts match) ################################################
    tmp_sf_check_44 = snowflake_fetch_data(sql_queries.sf_check_44)
    sf_check_44_src = int(tmp_sf_check_44[0]['count'])
    sf_check_44_dest = int(tmp_sf_check_44[1]['count'])
    print(f"SRC_EXP_CHECK_44: - {sf_check_44_src}")
    print(f"DEST_EXP_VIEW_CHECK_44: - {sf_check_44_dest}")
    full_log["CHECK_44"] = {'SRC_EXP_CHECK_44': sf_check_44_src, 'DEST_EXP_VIEW_CHECK_44': sf_check_44_dest}

    if sf_check_44_src != sf_check_44_dest:
        result_dict["CHECK_44"] = full_log["CHECK_44"]

    ### Check 45 EXP → View - GRAS_REPERTOIRE_OWNER_HIERARCHY (expected result: Counts match) ################################################
    tmp_sf_check_45 = snowflake_fetch_data(sql_queries.sf_check_45)
    sf_check_45_src = int(tmp_sf_check_45[0]['count'])
    sf_check_45_dest = int(tmp_sf_check_45[1]['count'])
    print(f"SRC_EXP_CHECK_45: - {sf_check_45_src}")
    print(f"DEST_EXP_VIEW_CHECK_45: - {sf_check_45_dest}")
    full_log["CHECK_45"] = {'SRC_EXP_CHECK_45': sf_check_45_src, 'DEST_EXP_VIEW_CHECK_45': sf_check_45_dest}

    if sf_check_45_src != sf_check_45_dest:
        result_dict["CHECK_45"] = full_log["CHECK_45"]

    ### Check 46 EXP → View - GRAS_TRACK (expected result: Counts match) ################################################
    tmp_sf_check_46 = snowflake_fetch_data(sql_queries.sf_check_46)
    sf_check_46_src = int(tmp_sf_check_46[0]['count'])
    sf_check_46_dest = int(tmp_sf_check_46[1]['count'])
    print(f"SRC_EXP_CHECK_46: - {sf_check_46_src}")
    print(f"DEST_EXP_VIEW_CHECK_46: - {sf_check_46_dest}")
    full_log["CHECK_46"] = {'SRC_EXP_CHECK_46': sf_check_46_src, 'DEST_EXP_VIEW_CHECK_46': sf_check_46_dest}

    if sf_check_46_src != sf_check_46_dest:
        result_dict["CHECK_46"] = full_log["CHECK_46"]

    ### Check 47 EXP → View - GRAS_TRACK_PARTICIPANT (expected result: Counts match) ################################################
    tmp_sf_check_47 = snowflake_fetch_data(sql_queries.sf_check_47)
    sf_check_47_src = int(tmp_sf_check_47[0]['count'])
    sf_check_47_dest = int(tmp_sf_check_47[1]['count'])
    print(f"SRC_EXP_CHECK_47: - {sf_check_47_src}")
    print(f"DEST_EXP_VIEW_CHECK_47: - {sf_check_47_dest}")
    full_log["CHECK_47"] = {'SRC_EXP_CHECK_47': sf_check_47_src, 'DEST_EXP_VIEW_CHECK_47': sf_check_47_dest}

    if sf_check_47_src != sf_check_47_dest:
        result_dict["CHECK_47"] = full_log["CHECK_47"]

    return result_dict, full_log

################# run the all steps ######################
def run_steps() -> dict:
    message_dict = {'name':"[PROD] GRAS (Exploration Area)",'status':"",'date':"", 'info':"", 'details':"", 'full_log':""}
    # set date according to sql searching date, currently it's `today`
    message_dict["date"] = datetime.datetime.now().strftime("%Y-%m-%d")

    result_dict_1_to_47, monitoring_1_to_47_log = check_1_to_47()
    message_dict['full_log'] = {**monitoring_1_to_47_log}
    message_dict['details'] = {**result_dict_1_to_47}

    if result_dict_1_to_47:
        postgres_update_failure_count(failure_count_increase)
        message_dict['status'] = "FAILED"
        message_dict['info'] = "Some steps failed"

    else:
        postgres_update_failure_count(failure_count_to_zero)
        message_dict['status'] = "OK"
        message_dict['info'] = "All steps executed without errors"

    return message_dict


if __name__ == '__main__':
    # # check command line parameters and print or email result
    parser = create_arg_parser()
    arg_list = parser.parse_args()
    if len(sys.argv[1:]) > 0:
        result = run_steps()
        with open('/tmp/gras_exploration_area_daily_log.json', 'w') as json_file:
            json.dump(result, json_file, indent=4)

        if arg_list.recipients:
            recipients = arg_list.recipients[0]
            send_mail(recipients=recipients, message=json.dumps(result, indent=4), status=result['status'])

        if arg_list.print:
            print(json.dumps(result, indent=4))
    else:
        parser.print_help()