"""
Code that goes along with the Airflow tutorial located at:
https://github.com/apache/incubator-airflow/blob/master/airflow/example_dags/tutorial.py
"""

import sys
import uuid

from os.path import dirname
from os.path import realpath


sys.path.append(dirname(dirname(dirname(realpath(__file__)))))  # noqa

import logging

from datetime import datetime, timedelta

import requests

from airflow import DAG
from airflow.operators.python_operator import (
    PythonOperator
)
from airflow.utils.db import provide_session
from airflow.utils import timezone

from auth.core import TokenManagement
from auth.models import Token

from base.exceptions import AuthenticationError
from base.models import Session

from routing.common import Routing
from routing.dbapi import get_map_by_action
from routing.models import TenantInfo

logger = logging.getLogger()

ACK_DELIVERY_API = "/api/monitor/acknowledge/delivery/update/"


default_args = {
    'owner': 'sourav',
    'depends_on_past': False,
    'start_date': datetime(2019, 1, 4),
    'email': ['noreply@intellectselect.com'],
    'email_on_failure': True,
    'email_on_retry': False,
    'retries': 1,
    'retry_delay': timedelta(minutes=1),
    'queue': 'requisition',
    # 'pool': 'backfill',
    # 'priority_weight': 10,
    # 'end_date': datetime(2016, 1, 1),
}

class PropagateDag(DAG):
    def __init__(self, *args, **kwargs):
        super(PropagateDag, self).__init__(*args, **kwargs)

    @provide_session
    def create_dagrun(self,
                      run_id,
                      state,
                      execution_date,
                      start_date=None,
                      external_trigger=False,
                      conf=None,
                      session=None):
        return super(PropagateDag, self).create_dagrun(
            run_id=str("ISELECT___") + str(uuid.uuid4()) + str("__") + str(timezone.utcnow()),
            state=state,
            execution_date=timezone.utcnow(),
            start_date=start_date,
            external_trigger=external_trigger,
            conf=conf,
            session=session)


dag = PropagateDag(
    'propagate', default_args=default_args,
    schedule_interval=None
)


def route(**kwargs):
    # data = kwargs.get('dag_run').conf
    # 1st task
    data = kwargs.get('dag_run').conf
    import socket
    hostname = socket.gethostname()
    ip_addr = socket.gethostbyname(hostname)
    logger.info('#################### --- WORKER IP --- ####################')
    logger.info(ip_addr)

    # 2nd task
    logger.info('#################### --- ROUTE 0 --- ####################')
    logger.info('### PROPAGATION DATA ###')
    logger.info(data['propagation_data'])
    logger.info('### acknowledgement_info ###')
    logger.info(data['acknowledgement_info'])
    logger.info('### DESTINATIONS ###')
    logger.info(data.get('destinations', None))
    endpoint = get_map_by_action(data['action_code'])
    short_names = data['destinations']
    response = {}
    response['ack_info'] = data['acknowledgement_info']
    updated_prop_data = {'propagation_data': data['propagation_data'],
                         'acknowledgement_info': data['acknowledgement_info']}
    response['destinations'] = data['destinations']
    response['originator_name'] = data['acknowledgement_info']['ack_originator_global_name']  # noqa
    # response['destin_responses'] = []
    # logger.info(data['propagation_data'])
    destin_responses = []
    logger.info('### DESTINATION URL WITH RESPONSE ###')
    for name in short_names:
        # logger.info(name)
        # rdata = Routing(name).get_routing_data()
        rdata = Routing(name).get_tenant_routing()
        logger.info(rdata)
        url = '{}{}'.format(rdata['destination_url'], endpoint)
        logger.info(updated_prop_data)
        resp = requests.post(url, json=updated_prop_data)
        logger.info(resp)
        if resp.status_code in range(200, 400):
            comments = "Success"
        else:
            resp_message = resp.json()
            comments = resp_message.get('error_msg')
        destin_responses.append(
            {"destination_name": name,
             "status_code": resp.status_code,
             "comments": comments,
             "response_time": resp.elapsed.total_seconds(),
             "ack_received_time": str(datetime.utcnow()),
             "direction": 60
             })
        logger.info(url)
        logger.info(resp.text)
    response['destin_responses'] = destin_responses
    logger.info(
        '#################### --- ROUTE 0 Response --- ####################')
    logger.info(response)
    # 3rd task
    logger.info('### ORIGINATOR ###')
    originator_name = response['originator_name']
    logger.info(originator_name)
    # rdata = Routing(originator_name).get_routing_data()
    rdata = Routing(originator_name).get_tenant_routing()
    url = '{}{}'.format(rdata['destination_url'], ACK_DELIVERY_API)
    logger.info("########### DELIVERY ACKNOWLEDGMENT ###############")
    # logger.info(url)
    resp = requests.post(url, json=response)
    logger.info(resp.text)
    if resp:
        return resp.json()
    logger.info(resp)


# def acknowledgement_action_request(**context):
#     responses = context['task_instance'].xcom_pull(task_ids='propagate_task')
#     logger.info("#############################")
#     logger.info(responses)
#     originator_name = responses['originator_name']
#     # rdata = Routing(originator_name).get_routing_data()
#     rdata = Routing(originator_name).get_tenant_routing()
#     url = '{}{}'.format(rdata['destination_url'], ACK_DELIVERY_API)
#     logger.info("#############################")
#     logger.info(url)
#     resp = requests.post(url, json=responses)
#     logger.info("#############################")
#     logger.info(resp.text)
#     if resp:
#         return resp.json()


# def authentication(**kwargs):
#     data = kwargs.get('dag_run').conf
#     logger.info('###################### --- Validation START')
#     import socket
#     hostname = socket.gethostname()
#     ip_addr = socket.gethostbyname(hostname)
#     logger.info(ip_addr)
#     logger.info('###################### --- Validation END')
#     return data
#     logger.info('###################### --- Validation')
#     auth_data = data.get('auth')
#     token = auth_data.get('token')
#     global_short_name = auth_data.get('global_short_name')
#     ses = Session()
#     tenant = ses.query(Token).join(Token.tenant).filter(
#         TenantInfo.global_short_name == TokenInfo.global_short_name).one_or_none()
#     if not tenant:
#         raise AuthenticationError('No tenant found!')
#     token = TokenManagement().validate_token(tenant, token)
#     if token:
#         return data


t1 = PythonOperator(
    # task_id='validate_token',
    # python_callable=authentication,
    task_id='propagate_task',
    python_callable=route,
    provide_context=True,
    dag=dag
)

# t2 = PythonOperator(
#     task_id='propagate_task',
#     python_callable=route,
#     provide_context=True,
#     dag=dag
# )
#
# t3 = PythonOperator(
#     task_id='ack_action_request_task',
#     python_callable=acknowledgement_action_request,
#     provide_context=True,
#     dag=dag
# )
#
# t1.set_downstream(t2)  # t1 >> t2
# t2.set_downstream(t3)  # t2 >> t3