import datetime
import json

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

from .models import CallRequest, RequestLog


def auth_request():
    r = requests.post(
        config.ENTRYPOINT_AUTH,
        data=dict(
            username=config.USERNAME,
            password=config.PASSWORD,
        )
    )
    if r.status_code == 200:
        print(r.json())
        config.ACCESS_TOKEN = r.json()['accessToken']
        config.REFRESH_TOKEN = r.json()['refreshToken']
        config.ACCESS_TOKEN_EXPIRED = datetime.datetime.now() + datetime.timedelta(minutes=5)


def get_token():
    if not config.ACCESS_TOKEN or config.ACCESS_TOKEN_EXPIRED <= timezone.now():
        auth_request()

    return config.ACCESS_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
    )
    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()
            call_request.call_text_log = result['text_log']
            call_request.call_result = result['call_result']

            if result['confirmed']:
                call_request.status = call_request.Status.APPROVED
            elif result['call_result_code'] in [3]:
                call_request.status = call_request.Status.CANCELED

            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.date.strftime('%Y-%m-%d'),
        receipt_time=call_request.date.strftime('%H:%M'),
        doctor_specialisation=call_request.doctor_speciality,
        doctor_fullname=call_request.doctor_name,
        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