import asyncio
import logging
import json

from tornado.httpclient import HTTPResponse, HTTPRequest

import dock
import apps
from dock.govs import govs_api
from dock.oa import oa_result_notify, PushException
from models.govs_order_master import GovsOrderMaster
from models.govs_create_delay import GovsApplicationForDelay
from paste.core.logging import echo_log
from paste.web import requests


async def get_create_delay_request(govs_delay: GovsApplicationForDelay, govs_order: GovsOrderMaster):
    """
    创建申请延期请求对象。方法仅创建请求对象，并未实际提交请求，具体由调度方法处理。

    :param govs_delay: 申请延期对象
    :param govs_order: 工单对象
    :return: HTTPRequest 对象
    """

    api_url = '/orderhandler/OrderDelayApply/createOrderDelay'
    body = {
        "finallyTimeAfterApprove": govs_delay.finally_time_after_approve,
        "finallyTimeBeforeApprove": govs_delay.finally_time_before_approve,
        "requestDelay": govs_delay.request_delay,
        "isNatureDay": govs_delay.is_nature_day,
        "alreadyNotifyOrderUser": govs_delay.already_notify_order_user,
        "requestReason": govs_delay.request_reason,
        "remarks": govs_delay.remarks,
        "contactName": govs_delay.contact_name,
        "contactTime": govs_delay.contact_time,
        "contactType": govs_delay.contact_type,
        "contactTypeName": govs_delay.contact_type_name,
        "replyScript": govs_delay.reply_script,
        "fileList": [],
        "masterId": govs_order.master_id,
        "orderNo": govs_order.order_no,
        "processInstanceId": govs_order.process_instance_id,
        "requestDelayTime": govs_delay.request_delay_time,
        "id": "",
        "orderId": govs_order.order_id
    }
    return await govs_api.new_api_request(api_url, body)


async def after_create_delay_request(response: HTTPResponse, retry_queue: asyncio.Queue[HTTPRequest]):
    """
    提交省12345后的处理程序。

    :param response: 响应对象
    :param retry_queue: 重试队列
    """
    echo_log(response.body.decode())
    echo_log('申请延期请求成功.')


async def create_delay(govs_delay: GovsApplicationForDelay, govs_order: GovsOrderMaster):
    """
    推送申请延期请求。

    :param govs_delay: 保存在数据库的申请延期对象
    :param govs_order: 数据库中的工单对象
    """
    try:
        delay_request = await get_create_delay_request(govs_delay, govs_order)
        queue = asyncio.Queue()
        await queue.put(delay_request)
        # 仅生产环境真实提交，其他环境不实际提交
        if apps.get_active_env() not in ('dev', '', None):
            delay_response_list = await requests.async_concurrency(queue, con_count=dock.CONCURRENCY_COUNT,
                                                                   retry=dock.MAX_RETRY_COUNT,
                                                                   after_request=after_create_delay_request)
            # 检查申请延期响应是否成功
            if len(delay_response_list) != 1:
                raise PushException("申请延期请求发生错误.", govs_delay.flow_token, 3)
            return_response = delay_response_list[0]
            return_response_data = return_response.body.decode()
            return_response_data = json.loads(return_response_data)
            if return_response_data.get('code') != 200:
                raise PushException("申请延期请求发生错误.", govs_delay.flow_token, 3)
        else:
            echo_log(f"非生产环境，不实际提交.")
        # 保存成功状态
        govs_delay.status = 1
        await govs_delay.async_save()
        # 申请延期请求提交后，通知申请延期成功
        await oa_result_notify.push_result_notify(
            govs_delay.flow_token,
            '申请延期成功',
            1
        )
    except PushException as e:
        # 任何异常都意味着失败，通知 OA
        echo_log(f'申请延期发生错误.', logging.ERROR)
        echo_log(e, logging.ERROR, is_log_exc=True)

        # 保存失败状态
        govs_delay.status = 0
        await govs_delay.async_save()

        # 申请延期发生异常，通知申请延期失败
        await oa_result_notify.push_result_notify(
            e.flow_token, f"{e}", e.return_code
        )
    except Exception as e:
        # 其他异常都意味着失败，通知 OA
        echo_log(f'申请延期发生错误.', logging.ERROR)
        echo_log(e, logging.ERROR, is_log_exc=True)