# By: Riasat Ullah
# This file contains views for handling Autotask integration set up requests.

from constants import api_paths, label_names as lnm, static_vars, var_names
from django.http import JsonResponse
from django.views.decorators.http import require_http_methods
from system_tests.test_data import test_data_services
from taskcallweb import settings
from translators import label_translator as lt
from utils import helpers
from validations import request_validator
import json


@require_http_methods(['POST'])
def get_autotask_accounts(request):
    '''
    Get the list of Autotask accounts for which integrations exist in TaskCall.
    This refers to Autotask credentials stored in TaskCall.
    :param request: Http request
    :return: Json response
    '''
    if request.method == 'POST':
        lang = request_validator.get_user_language(request)
        if request_validator.user_in_session(request):
            if settings.TEST_MODE:
                return JsonResponse(test_data_services.autotask_domains, safe=False)
            else:
                status, output = helpers.post_api_request(api_paths.integrations_autotask_account, dict(),
                                                          request, lang=lang)
                return JsonResponse(output, status=status, safe=False)
        else:
            return JsonResponse(lt.get_label(lnm.err_unauthorized_access, lang), status=401, safe=False)


@require_http_methods(['POST'])
def get_autotask_account_details(request):
    '''
    Get the details of an existing Autotask integration --> domain, username, secret, tracking ID.
    :param request: Http request
    :return: Json response
    '''
    if request.method == 'POST':
        lang = request_validator.get_user_language(request)
        if request_validator.user_in_session(request):
            body = json.loads(request.body.decode())
            if settings.TEST_MODE:
                return JsonResponse(
                    {var_names.vendor_endpoint_name: 'webservices2.autotask.net', var_names.username: 'admin'},
                    safe=False
                )
            else:
                status, output = helpers.post_api_request(api_paths.integrations_autotask_account_details, body,
                                                          request, lang=lang)
                return JsonResponse(output, status=status, safe=False)
        else:
            return JsonResponse(lt.get_label(lnm.err_unauthorized_access, lang), status=401, safe=False)


@require_http_methods(['POST'])
def update_autotask_account_details(request):
    '''
    Update Autotask credentials.
    :param request: Http request
    :return: Json response
    '''
    if request.method == 'POST':
        lang = request_validator.get_user_language(request)
        if request_validator.user_in_session(request):
            body = json.loads(request.body.decode())
            if settings.TEST_MODE:
                return JsonResponse(True, safe=False)
            else:
                status, output = helpers.post_api_request(api_paths.integrations_autotask_account_details_update,
                                                          body, request, lang=lang)
                return JsonResponse(output, status=status, safe=False)
        else:
            return JsonResponse(lt.get_label(lnm.err_unauthorized_access, lang), status=401, safe=False)


@require_http_methods(['POST'])
def initiate_autotask_integration(request):
    '''
    Store Autotask account details (domain and admin credentials) and initiate the integration process.
    :param request: Http request
    :return: Json response
    '''
    if request.method == 'POST':
        lang = request_validator.get_user_language(request)
        if request_validator.user_in_session(request):
            body = json.loads(request.body.decode())
            if var_names.integration_name in body and var_names.vendor_endpoint_name in body:
                # "username", "password" and "secret_token" variables are optional. If they are provided it must mean
                # that new admin credentials are being provided. If not, then an existing account is being used. This
                # will be handled in the next step of the integration process.
                request.session[var_names.services] = body
                return JsonResponse(lt.get_label(lnm.msg_success, lang), safe=False)
            else:
                return JsonResponse(lt.get_label(lnm.err_invalid_request, lang), status=401, safe=False)
        else:
            return JsonResponse(lt.get_label(lnm.err_unauthorized_access, lang), status=401, safe=False)


@require_http_methods(['POST'])
def get_autotask_meta_data(request):
    '''
    Get available Autotask ticket categories, ticket types, statuses, priorities, companies.
    :param request: Http request
    :return: Http response
    '''
    if request.method == 'POST':
        lang = request_validator.get_user_language(request)
        if request_validator.user_in_session(request):
            body = json.loads(request.body.decode())

            # The code is handled this way here in order to facilitate the process of storing the Autotask
            # account credentials to avoid duplicate entries of the domain in the
            # organization_integration_type_details table for the same organization.
            if var_names.integration_key not in body:
                serv_session = request.session[var_names.services]
                body[var_names.vendor_endpoint_name] = serv_session[var_names.vendor_endpoint_name]
                if var_names.username in serv_session and var_names.password in serv_session \
                        and var_names.secret_token in serv_session:
                    body[var_names.username] = serv_session[var_names.username]
                    body[var_names.password] = serv_session[var_names.password]
                    body[var_names.secret_token] = serv_session[var_names.secret_token]

            if settings.TEST_MODE:
                return JsonResponse([test_data_services.autotask_ticket_categories,
                                     test_data_services.autotask_ticket_types,
                                     test_data_services.autotask_queues,
                                     test_data_services.autotask_statuses,
                                     test_data_services.autotask_priorities,
                                     test_data_services.autotask_companies], safe=False)
            else:
                status, output = helpers.post_api_request(api_paths.integrations_autotask_meta_data,
                                                          body, request, lang=lang)
                return JsonResponse(output, status=status, safe=False)
        else:
            return JsonResponse(lt.get_label(lnm.err_unauthorized_access, lang), status=401, safe=False)


@require_http_methods(['POST'])
def create_autotask_integration(request):
    '''
    Creates a new Autotask integration.
    :param request: Http request
    :return: JSON response
    '''
    if request.method == 'POST':
        lang = request_validator.get_user_language(request)
        if request_validator.user_in_session(request) and var_names.services in request.session and\
            var_names.integration_type in request.session[var_names.services] and\
            request.session[var_names.services][var_names.integration_type] == static_vars.integ_type_autotask and\
            var_names.service_ref_id in request.session[var_names.services] and\
                var_names.integration_name in request.session[var_names.services]:

            req_body = json.loads(request.body.decode())
            serv_session = request.session[var_names.services]

            post_body = {
                var_names.service_ref_id: serv_session[var_names.service_ref_id],
                var_names.integration_type: static_vars.integ_type_autotask,
                var_names.integration_name: serv_session[var_names.integration_name],
                var_names.vendor_endpoint_name: serv_session[var_names.vendor_endpoint_name],
                var_names.additional_info: req_body[var_names.additional_info]
            }
            if var_names.username in serv_session or var_names.password in serv_session or \
                    var_names.secret_token in serv_session:
                post_body[var_names.external_id] = serv_session[var_names.vendor_endpoint_name]
                post_body[var_names.external_info] = {
                    var_names.username: serv_session[var_names.username],
                    var_names.password: serv_session[var_names.password],
                    var_names.secret_token: serv_session[var_names.secret_token]
                }

            if settings.TEST_MODE:
                return JsonResponse('Action performed successfully', safe=False)
            else:
                status, output = helpers.post_api_request(api_paths.services_integrations_add, post_body,
                                                          request, lang=lang)
                return JsonResponse(output, status=status, safe=False)
        else:
            return JsonResponse(lt.get_label(lnm.err_unauthorized_access, lang), status=401, safe=False)


@require_http_methods(['POST'])
def edit_autotask_integration(request):
    '''
    Edits the configuration of an existing Autotask integration.
    :param request: Http request
    :return: JSON response
    '''
    if request.method == 'POST':
        lang = request_validator.get_user_language(request)
        if request_validator.user_in_session(request):
            body = json.loads(request.body.decode())
            if settings.TEST_MODE:
                return JsonResponse('Action performed successfully', safe=False)
            else:
                status, output = helpers.post_api_request(api_paths.services_integrations_edit, body,
                                                          request, lang=lang)
                return JsonResponse(output, status=status, safe=False)
        else:
            return JsonResponse(lt.get_label(lnm.err_unauthorized_access, lang), status=401, safe=False)