import requests
import time
import logging

# 配置日志
handlers = [logging.FileHandler('query_processor.log'), logging.StreamHandler()]
logging.basicConfig(
    level=logging.INFO,
    format='%(asctime)s - %(levelname)s - %(message)s',
    handlers=handlers
)
logger = logging.getLogger(__name__)

# API基础URL
BASE_URL = 'http://localhost:99'

# 演示数据处理函数
def process_query_data(query_data, parameters):
    """
    处理查询数据的演示函数
    这里使用演示代码代替实际的数据处理逻辑
    """
    # 获取用户ID，如果存在
    user_id = query_data.get('user_id', '未知')
    logger.info(f"处理查询数据: ID={query_data['id']}, 车牌号={query_data['plate_number']}, 用户ID={user_id}")
    
    # 这里是演示处理逻辑
    # 在实际应用中，这里应该是真实的数据处理代码
    logger.info(f"使用参数进行处理: {parameters}")
    
    # 模拟处理过程
    time.sleep(2)  # 模拟处理耗时
    
    # 返回模拟的处理结果（简单地将results_count设置为随机数1-5）
    # 实际应用中，应该根据真实处理结果返回相应的值
    results_count = 3  # 演示用的固定结果数
    logger.info(f"处理完成，结果数量: {results_count}")
    
    return results_count

# 读取参数配置
def get_parameters():
    """
    从后端API读取参数配置
    """
    try:
        url = f'{BASE_URL}/api/parameters'
        response = requests.get(url)
        response.raise_for_status()
        data = response.json()
        
        if data['success']:
            logger.info(f"成功获取参数配置: {data['data']}")
            return data['data']
        else:
            logger.error(f"获取参数配置失败: {data['error']}")
            return None
    except Exception as e:
        logger.error(f"获取参数配置时发生错误: {str(e)}")
        return None

# 获取待处理查询
def get_pending_queries():
    """
    从后端API获取待处理查询
    """
    try:
        url = f'{BASE_URL}/api/pending-queries'
        response = requests.get(url)
        response.raise_for_status()
        data = response.json()
        
        if data['success']:
            logger.info(f"成功获取待处理查询，共 {data['count']} 条")
            return data['data']
        else:
            logger.error(f"获取待处理查询失败: {data['error']}")
            return []
    except Exception as e:
        logger.error(f"获取待处理查询时发生错误: {str(e)}")
        return []

# 更新查询结果
def update_query_result(query_id, results_count):
    """
    更新查询结果到后端API
    """
    try:
        url = f'{BASE_URL}/api/update-query-result'
        data = {
            'id': query_id,
            'results_count': results_count
        }
        
        response = requests.post(url, json=data)
        response.raise_for_status()
        result = response.json()
        
        if result['success']:
            logger.info(f"成功更新查询结果: ID={query_id}, 结果数量={results_count}")
            return True
        else:
            logger.error(f"更新查询结果失败: {result['error']}")
            return False
    except Exception as e:
        logger.error(f"更新查询结果时发生错误: {str(e)}")
        return False

# 主处理函数
def main():
    logger.info("查询处理代码启动")
    
    # 获取参数配置
    parameters = get_parameters()
    if not parameters:
        logger.warning("无法获取参数配置，使用默认参数继续")
        # 使用默认参数继续
        parameters = {
            'param1': 'default1',
            'param2': 'default2',
            'param3': 'default3',
            'param4': 'default4',
            'param5': 'default5'
        }
    
    # 主循环
    while True:
        try:
            # 获取待处理查询
            pending_queries = get_pending_queries()
            
            # 处理每条查询
            for query in pending_queries:
                # 处理查询数据
                results_count = process_query_data(query, parameters)
                
                # 更新查询结果
                update_query_result(query['id'], results_count)
            
            # 等待一段时间后再次检查
            wait_time = 60  # 默认等待60秒
            # 如果有parameters参数，可以根据参数调整等待时间
            if parameters and 'polling_interval' in parameters:
                try:
                    wait_time = int(parameters['polling_interval'])
                except (ValueError, TypeError):
                    logger.warning(f"无效的轮询间隔参数: {parameters['polling_interval']}")
            
            logger.info(f"本次处理完成，等待 {wait_time} 秒后再次检查")
            time.sleep(wait_time)
            
        except KeyboardInterrupt:
            logger.info("查询处理器被用户中断")
            break
        except Exception as e:
            logger.error(f"处理过程中发生错误: {str(e)}")
            # 发生错误时，等待更短的时间后重试
            time.sleep(30)
    
    logger.info("查询处理器停止")

if __name__ == '__main__':
    main()