import datetime
import json

import requests
from django.utils import timezone
from django.core.cache import cache
from constance import config

from appa.models import CallRequest, RequestLog
from . import call_status


def get_token():
    token = cache.get('ACCESS_TOKEN')
    if token is None:
        r = requests.post(
            config.ENTRYPOINT_AUTH,
            data=dict(username=config.USERNAME, password=config.PASSWORD)
        )
        if r.status_code == 200:
            token = r.json()['accessToken']
            cache.set('ACCESS_TOKEN', token, timeout=300)
            cache.set('REFRESH_TOKEN', r.json()['refreshToken'], timeout=300)

    return token


def delete_call_request(call_request: CallRequest, logging=True):
    hooks = None
    if logging:
        log = RequestLog(
            request_url=config.ENTRYPOINT_DELETE % (call_request.call_id,),
        )
        hooks = {'response': log.response_hook}

    r = requests.post(
        config.ENTRYPOINT_DELETE % (call_request.call_id,),
        headers={'Authorization': f'Bearer {get_token()}'},
        hooks=hooks
    )
    print(r.status_code)
    if r.status_code == 200:
        call_request.reset_request()


def get_record(call_request: CallRequest, logging=True):
    if call_request.call_id:
        hooks = None
        if logging:
            log = RequestLog(
                request_url=config.ENTRYPOINT_RECORD % (call_request.call_id,),
            )
            hooks = {'response': log.response_hook}

        r = requests.get(
            config.ENTRYPOINT_RECORD % (call_request.call_id,),
            headers={'Authorization': f'Bearer {get_token()}'},
            hooks=hooks
        )
        if r.status_code == 200:
            result = r.json()
            if result['call_result_code'] != call_status.STATUS_1:
                call_request.call_text_log = result['text_log']
                call_request.call_result = result['call_result']
                call_request.request_status = call_request.RequestStatus.COMPLETED

                if result['confirmed']:
                    call_request.status = call_request.Status.APPROVED

                elif result['call_result_code'] == call_status.STATUS_4:
                    call_request.status = call_request.Status.TRANSFER

                elif result['call_result_code'] in call_status.STATUS_CALLBACK:
                    call_request.status = call_request.Status.CALLBACK

                elif result['call_result_code'] in call_status.STATUS_CANCELLED:
                    call_request.status = call_request.Status.CANCELED

                    from appa.medicine_api.api import cancel_booking
                    cancel_booking(call_request.booking_id)

                elif result['call_result_code'] in call_status.STATUS_WITHOUT_ANSWER:
                    call_request.status = call_request.Status.WITHOUT_ANSWER

                else:
                    call_request.status = call_request.Status.OTHER

                call_request.save()


def add_call_request(call_request: CallRequest, logging=True, delete=False):
    if call_request.request_status == call_request.RequestStatus.SENT:
        if delete:
            delete_call_request(call_request)

    data = dict(records=[dict(
        first_name=call_request.patient_first_name,
        second_name=call_request.patient_last_name,
        middle_name=call_request.patient_middle_name,
        phone_number=call_request.patient_phone,
        receipt_date=call_request.booking_date.strftime('%Y-%m-%d'),
        receipt_time=call_request.booking_date.strftime('%H:%M'),
        doctor_specialisation=call_request.service_name,
        note=call_request.organization,
        filial=call_request.address,
        ext_id=str(call_request.uid)
    )])

    hooks = None
    if logging:
        log = RequestLog(
            request_url=config.ENTRYPOINT_ADD_RECORDS,
            request_body=json.dumps(data, ensure_ascii=False, indent=4),
        )
        hooks = {'response': log.response_hook}

    r = requests.post(
        config.ENTRYPOINT_ADD_RECORDS,
        headers={'Authorization': f'Bearer {get_token()}'},
        json=data,
        hooks=hooks
    )
    call_request.response_status_code = r.status_code
    call_request.request_time = timezone.now()

    if r.status_code == 200:
        record = r.json()['added_records'][0]
        call_request.call_id = record['id']
        call_request.request_status = CallRequest.RequestStatus.SENT

    elif r.status_code == 400:
        call_request.request_status = CallRequest.RequestStatus.ERROR

    call_request.save(update_fields=(
        'call_id',
        'request_status',
        'request_time',
        'response_status_code',
        'response_message',
    ))


def call_history(date_from: datetime.date, date_to: datetime.date):
    pass