# By: Riasat Ullah
# This file contains ManageEngine ServiceDesk Plus related views.

from data_syncers import syncer_task_instances
from dbqueries import db_integrations
from exceptions.user_exceptions import InvalidRequest
from integrations import manage_engine_service_desk_plus as me_sdp
from modules.router import Router
from objects.events import AcknowledgeEvent, ResolveEvent, UrgencyAmendmentEvent
from objects.task_payload import TaskPayload
from rest_framework.decorators import api_view
from rest_framework.response import Response
from translators import label_translator as _lt
from utils import constants, errors, info, integration_type_names as intt, logging, times, var_names
from utils.db_connection import CACHE_CLIENT, CONN_POOL
from validations import request_validator
import configuration


@api_view(['POST'])
def process_service_desk_plus_webhook(request, integration_key, conn=None, cache=None):
    '''
    Processes the incoming webhook from ManageEngine OpManager.
    :param request: Http request
    :param integration_key: integration key passed in the url
    :param conn: db connection
    :param cache: cache client
    :return: Http response
    '''
    logging.info(request.data)
    if request.method == 'POST':
        lang = request_validator.get_user_language(request)
        try:
            conn = CONN_POOL.get_db_conn() if conn is None else conn
            cache = CACHE_CLIENT if cache is None else cache

            alert_id = request.data[me_sdp.var_id] if me_sdp.var_id in request.data else None
            alert_title = request.data[me_sdp.var_subject] if me_sdp.var_subject in request.data \
                else 'ManageEngine ServiceDesk Plus Ticket'
            alert_msg = request.data[me_sdp.var_description] if me_sdp.var_description in request.data \
                else str(request.data)
            alert_url = request.data[var_names.vendor_url] if var_names.vendor_url in request.data else None
            alert_priority = me_sdp.get_field_value(me_sdp.var_priority, request.data)
            alert_status = me_sdp.get_field_value(me_sdp.var_status, request.data)

            tc_urgency = constants.critical_urgency
            if me_sdp.var_priority in request.data:
                if alert_priority in me_sdp.sdp_priority_mapping:
                    tc_urgency = me_sdp.sdp_priority_mapping[alert_priority]

            tc_state = constants.open_state
            if me_sdp.var_status in request.data:
                if alert_status in me_sdp.sdp_status_mapping:
                    tc_state = me_sdp.sdp_status_mapping[alert_status]

            current_time = times.get_current_timestamp()
            org_id, org_perm, serv_id, integ_id, integ_type_id, integ_details = \
                db_integrations.get_integration_details(conn, current_time, integration_key,
                                                        intt.manage_engine_service_desk_plus)

            integ_insts = db_integrations.get_integration_open_instances_trigger_info(
                conn, current_time, org_id, serv_id, integ_id)

            match_count = 0
            for inst_id, task_id, trig_info in integ_insts:
                if trig_info is not None:
                    source_payload = trig_info[var_names.source_payload]
                    src_alert_id = source_payload[me_sdp.var_id] if me_sdp.var_id in source_payload else None
                    src_priority = me_sdp.get_field_value(me_sdp.var_priority, source_payload)

                    if alert_id is not None and src_alert_id == alert_id:
                        match_count += 1
                        to_group = True

                        if alert_priority is not None:
                            if alert_priority != src_priority:
                                to_group = False
                                event = UrgencyAmendmentEvent(
                                    inst_id, current_time, constants.integrations_api, tc_urgency)
                                syncer_task_instances.amend_urgency(conn, cache, [event], org_id,
                                                                    is_sys_action=True)

                        if tc_state == constants.acknowledged_state:
                            event = AcknowledgeEvent(inst_id, current_time, constants.integrations_api, None)
                            syncer_task_instances.acknowledge(conn, cache, event, org_id, is_sys_action=True)

                        elif tc_state == constants.resolved_state:
                            event = ResolveEvent(inst_id, current_time, constants.integrations_api)
                            syncer_task_instances.resolve(conn, cache, event, org_id, is_sys_action=True)

                        else:
                            if to_group:
                                payload = TaskPayload(
                                    current_time, org_id, current_time.date(), alert_title,
                                    configuration.standard_timezone, current_time.time(), text_msg=alert_msg,
                                    urgency_level=tc_urgency, trigger_method=constants.integrations_api,
                                    trigger_info=request.data, integration_id=integ_id, integration_key=integration_key,
                                    service_id=serv_id, instantiate=False, alert=False, related_task_id=task_id,
                                    task_status=constants.grouped_state, vendor_incident_url=alert_url
                                )
                                Router(conn, cache, payload).start()

            # Create a new task if this is a new alert.
            if match_count == 0:
                payload = TaskPayload(
                    current_time, org_id, current_time.date(), alert_title, configuration.standard_timezone,
                    current_time.time(), text_msg=alert_msg, urgency_level=tc_urgency,
                    trigger_method=constants.integrations_api, trigger_info=request.data, integration_id=integ_id,
                    integration_key=integration_key, service_id=serv_id, vendor_incident_url=alert_url
                )
                Router(conn, cache, payload).start()

            return Response(info.msg_internal_success)
        except InvalidRequest as e:
            logging.exception(str(e))
            return Response(_lt.get_label(errors.err_invalid_request, lang), status=400)
        except Exception as e:
            logging.exception(str(e))
            return Response(_lt.get_label(errors.err_system_error, lang), status=500)
        finally:
            CONN_POOL.put_db_conn(conn)