import asyncio
import logging

from tornado.httpclient import HTTPResponse, HTTPRequest
from sqlalchemy import select

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_save_sign import GovsSaveSign
from paste.core.logging import echo_log
from paste.web import requests


async def get_sign_request(govs_order: GovsOrderMaster):
    """
    创建省12345上工单确认签收的请求对象。方法仅创建请求对象，并未实际提交请求，具体由调度方法处理。

    :param govs_order: 工单对象
    :return: HTTPRequest 对象
    """
    api_url = '/orderhandler/claimTask/claimTask'
    body = {
        "orderId": govs_order.order_id,
        "orderNo": govs_order.order_no,
        "masterId": govs_order.master_id,
        "orderProcessId": govs_order.id,
        "taskId": govs_order.next_task_id,
        "flag": "签收"
    }
    return await govs_api.new_api_request(api_url, body)


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

    :param response: 响应对象
    :param retry_queue: 重试队列
    """
    echo_log(response.body.decode())
    govs_order = getattr(response.request, 'govs_order', None)
    if govs_order:
        govs_order.govs_sign = 1
        await govs_order.async_save()
        echo_log('省12345确认签收请求成功.')


async def sign_order(govs_sign: GovsSaveSign, govs_order: GovsOrderMaster):
    """
    推送工单确认签收请求。

    :param govs_sign: 保存在数据库的工单签收对象
    :param govs_order: 数据库中的工单对象
    """
    try:
        sign_request = await get_sign_request(govs_order)
        queue = asyncio.Queue()
        setattr(sign_request, 'govs_order', govs_order)
        await queue.put(sign_request)
        # 仅生产环境真实提交，其他环境不实际提交
        if apps.get_active_env() not in ('dev', '', None):
            sign_response_list = await requests.async_concurrency(queue, con_count=dock.CONCURRENCY_COUNT,
                                                                  retry=dock.MAX_RETRY_COUNT,
                                                                  after_request=after_sign_request)
            # 检查工单签收响应是否成功
            if len(sign_response_list) != 1:
                raise PushException("工单签收请求发生错误.", govs_sign.flow_token, 3)
        else:
            echo_log(f"非生产环境，不实际提交.")
        # 保存成功状态
        govs_sign.status = 1
        await govs_sign.async_save()
        # 工单签收请求提交后，通知工单签收成功
        await oa_result_notify.push_result_notify(
            govs_sign.flow_token,
            '工单签收成功',
            1
        )
    except PushException as e:
        # 任何异常都意味着失败，通知 OA
        echo_log(f'工单签收发生错误.', logging.ERROR)
        echo_log(e, logging.ERROR, is_log_exc=True)

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

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


async def sign_order_bypass_api(task_id_list: list):
    """
    不经过工单确认签收的api接口，签收指定的工单

    :param task_id_list: 工单id列表
    """
    try:
        query = select(GovsOrderMaster).where(GovsOrderMaster.id.in_(task_id_list))
        govs_orders = await GovsOrderMaster.orm_execute(query)
        sign_queue = asyncio.Queue()
        for row in govs_orders.all():
            sign_request = await get_sign_request(row[0])
            setattr(sign_request, 'govs_order', row[0])
            await sign_queue.put(sign_request)
        # 仅生产环境真实提交，其他环境不实际提交
        if apps.get_active_env() in ('dev', '', None):
            echo_log(f"非生产环境，不实际提交.")
            return
        await requests.async_concurrency(sign_queue, con_count=dock.CONCURRENCY_COUNT,
                                         retry=dock.MAX_RETRY_COUNT, after_request=after_sign_request)
    except Exception as e:
        echo_log(f'签收工单发生错误.', logging.ERROR)
        echo_log(e, logging.ERROR, is_log_exc=True)