# By: Riasat Ullah
# This file contains views for handling TeamDynamix 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_team_dynamix_accounts(request):
    '''
    Get the list of TeamDynamix accounts for which integrations exist in TaskCall. This is not the list of
    department accounts in TeamDynamix.
    :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.team_dynamix_domains, safe=False)
            else:
                status, output = helpers.post_api_request(api_paths.integrations_team_dynamix_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_team_dynamix_account_details(request):
    '''
    Get the TeamDynamix domain and admin user of existing accounts integrations haves been set on.
    :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: 'taskcallapp.teamdynamix.com', var_names.username: 'admin'},
                    safe=False
                )
            else:
                status, output = helpers.post_api_request(api_paths.integrations_team_dynamix_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_team_dynamix_account_details(request):
    '''
    Update TeamDynamix 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_team_dynamix_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_team_dynamix_integration(request):
    '''
    Store TeamDynamix 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" and "password" variables are optional. If they are provided then 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_team_dynamix_meta_data(request):
    '''
    Get available Team Dynamix accounts, applications, ticket types, statuses, priorities.
    :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 TeamDynamix
            # 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:
                    body[var_names.username] = serv_session[var_names.username]
                    body[var_names.password] = serv_session[var_names.password]

            if settings.TEST_MODE:
                return JsonResponse([test_data_services.team_dynamix_accounts,
                                     test_data_services.team_dynamix_applications,
                                     test_data_services.team_dynamix_ticket_types,
                                     test_data_services.team_dynamix_statuses,
                                     test_data_services.team_dynamix_priorities], safe=False)
            else:
                status, output = helpers.post_api_request(api_paths.integrations_team_dynamix_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_team_dynamix_integration(request):
    '''
    Creates a new TeamDynamix 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_team_dynamix 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_team_dynamix,
                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:
                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]
                }

            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_team_dynamix_integration(request):
    '''
    Edits the configuration of an existing TeamDynamix 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)