# 文档处理工具
from tools.document_tools import (
    create_document, add_documents,add_table_and_replace,
    add_table_to_document,process_images_table,
)

# 内容处理工具
from tools.content_tools import (
    add_picture,split_table_by_row_content,
    search_and_replace,add_picture_to_table
)

from tools.get_pictures import (
    make_Thumbnail,resize_and_reduce_quality,
    get_picture_nums,find_image,collect_defect_data,
    process_picture_data,get_records_with_pic
)

from tools.Get_Json import (
    get_project_info,get_jizu_info,
    get_jizu_shigong_info,get_weather,
    get_part_picture,get_yepian_xiangqing,
    check_pic_url,get_full_picture_url,
    get_defect_record_list
)

from tools.dataproccess import (
    caculate_work_days,add_dynamic_table,
    get_year_month,merge_info,
)

import asyncio

from core.tables import fill_tables

from tools.defines import *
import os, re, datetime
from pathlib import Path

async def generate_report(base_info, baogao_info):
    #获取模板编号、模板名称
    num_to_chinese = {1 : '一', 2 : '二', 3 : '三', 4 : '四', 5 : '五', 6 : '六', 7 : '七', 8 : '八', 9 : '九', 10 : '十', 11 : '十一', 12 : '十二'}
    cover_encode = "encode"
    cover_project = "project"
    baogao_name1 = "baogaoname1"
    baogao_name2 = "baogaoname2"
    company_name_yi = "company_name_yi"
    cover_date = "time"
    TITLE_OF_REPORT = "companyencode"
    jiegou_xuhao = 'num'
    
    print(f"获取到参数：基本信息：{base_info}\n\n报告信息：{baogao_info}")

    try:
        base_info = merge_info(base_info, DEFAULT_BASE_INFO)
        turbine_id = base_info['turbine_id']
        
        jizu_data = get_jizu_info(turbine_id)
        project_data = get_project_info(jizu_data['projectId'])
        shigong_data = get_jizu_shigong_info(turbine_id)

        fengchang_name = project_data['farmName']
        Yi_company = project_data['inspectionUnit']
        yi_fuzeren = project_data['inspectionContact']
        yi_phone = project_data['inspectionPhone']
        fengchang_location = project_data['farmAddress']
        Jia_company = project_data['client']
        jia_fuzeren = project_data['clientContact']
        jia_phone = project_data['clientPhone']
        jizu_num = project_data['scale']
        jizu_xinghao = project_data['turbineModel']
        project_name = project_data['projectName']
        jizu_bianhao = jizu_data["turbineName"]
        start_date = project_data['startDate']
        end_date = project_data['endDate']
        cover_url = project_data['coverUrl']
        gongqi = caculate_work_days(start_date, end_date)
    except Exception as e:
        print(f"数据库的项目-机组基本信息获取失败：{e}")
        return
        
    try:
        baogao_date = datetime.datetime.now().strftime("%Y年%m月%d日 %H:%M")   #现在的时间
        date_year_month = get_year_month(baogao_date)
        
        #前端信息
        baogao_info = merge_info(baogao_info, DEFAULT_BAOGAO_INFO)

        key_words= re.compile('|'.join(map(re.escape, baogao_info['key_words'].split(',')))) #关键字

        shengcheng_dir = baogao_info['shengcheng_dir']     #路径
        muban_dir = baogao_info['muban_dir']  #路径
        if muban_dir == "" or shengcheng_dir == "":
            print("未配置模板/生成路径，请检查配置")
            return
        if_waibu = baogao_info["if_waibu"] 
        if_neibu = baogao_info["if_neibu"]
        if_fanglei = baogao_info["if_fanglei"]
            
        quexian_type = baogao_info['quexian_enum']
        
        dianxing_type = baogao_info['dianxing_enum']

        other_type = baogao_info["other_enum"]

        jiancha_renyuan = baogao_info['jiancha_renyuan'] #检查人员，目前是从命令行参数获取,需要完善
        check_date = baogao_info['check_date']
        if check_date == None:
            check_date = "未获取"
        baogao_bianzhi = baogao_info["userName"]
        baogao_shenghe = baogao_info["baogaoCheck"]
        Jiancha_date = baogao_info["check_date"]
        data_processor = baogao_info["data_processor"]
        coverurl = baogao_info["coverurl"]
        

        #数据库拉取信息
        # Jiancha_date = shigong_data["startTime"].replace("T", " ")   #检查日期
        # image_count = shigong_data['imageCount']  #从施工方案获取的图片数量，待定!!!
        # temperature = shigong_data['temperature']   #温度
        # wind_speed = shigong_data['windSpeed'] #风速
        # weather = get_weather(shigong_data["weatherCode"])   #天气 不从此接口获取，待定！！！
        
        #拉取部件、图片数据
        part_data, picture_data = get_part_picture(turbine_id)
        
        #获取叶片信息
        print(part_data)
        Yepians = []
        yepian_to_find = ["叶片1","叶片2","叶片3"]
        #依次获取叶片1，2，3的信息（未考虑多个同叶片的信息情况，正常情况下不会发生）
        for name in yepian_to_find:
            # 找到第一个匹配的部件并添加到列表中
            for part in part_data:
                if part['partName'] == name:
                    Yepians.append(part)
        print(Yepians)
        Y1_info = get_yepian_xiangqing(Yepians[0]["partId"])
        Y_Code = [yepian["partCode"] for yepian in Yepians]
        partManufacturer = Y1_info["partManufacturer"]
        print(f"找到叶片号{Y_Code},厂商{partManufacturer}")
        
        image_source_to_find = []
        baogao_label = []
        renyuan_peizhi = []
        gongzuo_neirong = []
        shigong_fangan = []
        shebei_peizhi = []
        beizhu = []
        jiancha = []
        neirong = []
        #获取对应枚举字段
        if if_waibu:
            baogao_label.append("外观")
            image_source_to_find.append(baogao_info['waibu_enum'])
            if baogao_info["shigong_fangan"] == None:
                print("未传入施工方案,使用已有枚举")
                renyuan_peizhi.append(SHIGONG_FANGAN_ENUM.WAIBU.RENYUAN_PEIZHI)
                gongzuo_neirong.append(SHIGONG_FANGAN_ENUM.WAIBU.GONGZUO_NEIRONG)
                shebei_peizhi.append(SHIGONG_FANGAN_ENUM.WAIBU.SHEBEI_PEIZHI)
                shigong_fangan.append(SHIGONG_FANGAN_ENUM.WAIBU.SHIGONG_FANGAN)
            else:
                pass  #待添加如果从平台传入枚举，但目前没必要，如果这种枚举标准信息库有更好的优化则可以实现
            jiancha.append("无人机近距离外观检查")
            neirong.append(f"、".join(Y_Code) + f"共{len(Y_Code)}支叶片的前缘、后缘、迎风面、背风面。")
        if if_neibu:
            baogao_label.append("内部")
            image_source_to_find.append(baogao_info['neibu_enum'])
            if baogao_info["shigong_fangan"] == None:
                renyuan_peizhi.append(SHIGONG_FANGAN_ENUM.NEIBU.RENYUAN_PEIZHI)
                gongzuo_neirong.append(SHIGONG_FANGAN_ENUM.NEIBU.GONGZUO_NEIRONG)
                shebei_peizhi.append(SHIGONG_FANGAN_ENUM.NEIBU.SHEBEI_PEIZHI)
                shigong_fangan.append(SHIGONG_FANGAN_ENUM.NEIBU.SHIGONG_FANGAN)
            else:
                pass
            jiancha.append("人工内部拍摄")
            neirong.append(f"、".join(Y_Code) +  f"共{len(Y_Code)}支叶片的内部导雷卡、腹板、透光、人孔盖版、叶根盖板...")
        if if_fanglei:
            baogao_label.append("防雷")
            image_source_to_find.append(baogao_info['fanglei_enum'])
            if baogao_info["shigong_fangan"] == None:
                renyuan_peizhi.append(SHIGONG_FANGAN_ENUM.FANGLEI.YEPIAN.RENYUAN_PEIZHI)
                gongzuo_neirong.append(SHIGONG_FANGAN_ENUM.FANGLEI.YEPIAN.GONGZUO_NEIRONG)
                shebei_peizhi.append(SHIGONG_FANGAN_ENUM.FANGLEI.YEPIAN.SHEBEI_PEIZHI)
                shigong_fangan.append(SHIGONG_FANGAN_ENUM.FANGLEI.YEPIAN.SHIGONG_FANGAN)
            else:
                pass
            jiancha.append("人工防雷")
            neirong.append(f"轮毂至塔基导通、内部导线线阻、外部导线线阻...")
            
        #获取缺陷图列表和典型图列表
        (defect_pictures, typical_pictures, 
         other_pictures, normal_picture_num) = process_picture_data(picture_data, image_source_to_find, 
                                                                    quexian_type, dianxing_type, other_type)
        print(f"\n\n\n缺陷图片列表:{defect_pictures}\n\n\n典型图片列表:{typical_pictures}\n\n\n")
        
        #获取过滤后所有缺陷图的id
        defect_pictures_id = [pic for pic in defect_pictures]
        #获取所有缺陷记录
        defect_records = get_defect_record_list()
        #获取缺陷记录中对应图片的记录
        defect_records_with_pic, error_pic_with_no_record = get_records_with_pic(defect_records, defect_pictures_id)
        print(f"对应缺陷图的缺陷记录列表:{defect_records_with_pic}\n 没有缺陷记录但是是缺陷图片的列表:{error_pic_with_no_record}")
    except Exception as e:
        print(f"报告基本信息获取失败：{e}")
        return

    output_doc = None
    head_num = 1
    ###封面创建###
    cover_dirs = [os.path.join(muban_dir,"fengmian1.docx"),os.path.join(muban_dir,"fengmian.jpg"),os.path.join(muban_dir,"fengmian2.docx")]
    #输出目录
    baogao_name = "叶片" + "、".join(baogao_label) + "检查报告"
    output_dir = os.path.normpath(f"{shengcheng_dir}/{project_name}项目{baogao_name}{jizu_bianhao}{baogao_date.split(' ')[0]}版.docx")
    
    version = 1
    while os.path.exists(output_dir):
        if version != 1:
            output_dir = output_dir.replace(f"版{version - 1}",f"版{version}")
        else:
            output_dir = output_dir.replace("版",f"版{version}")
        version += 1

    mianzhe_shengming = f"本报告仅涵盖{'、'.join(baogao_label)}检测内容"

    #创建文档、添加封面
    print(await create_document(output_dir))
    print(add_documents(output_dir, cover_dirs[0]))
    if check_pic_url(coverurl):  #手动导入封面图片测试用
        print(await add_picture(output_dir, get_full_picture_url(coverurl), width = 6.41, height = 4))
    elif check_pic_url(cover_url):
        print(await add_picture(output_dir, get_full_picture_url(cover_url), width = 6.41, height = 4))
    else:
        print(await add_picture(output_dir, cover_dirs[1]))
    print(add_documents(output_dir, cover_dirs[2]))
    print("封面创建成功")

    #更改文档信息
    print(await search_and_replace(output_dir, TITLE_OF_REPORT, jizu_bianhao))
    print(await search_and_replace(output_dir, baogao_name1, baogao_name))
    print(await search_and_replace(output_dir, baogao_name2, baogao_name))
    print(await search_and_replace(output_dir, company_name_yi, Yi_company))
    print(await search_and_replace(output_dir, cover_project, fengchang_name))
    print(await search_and_replace(output_dir, cover_encode, jizu_bianhao))
    print(await search_and_replace(output_dir, cover_date, date_year_month))
    print(await search_and_replace(output_dir, 'bianzhi', baogao_bianzhi))
    print(await search_and_replace(output_dir, 'shenghe', baogao_shenghe))
    print(await search_and_replace(output_dir, 'mianzhe_shengming', mianzhe_shengming))
    
    total_table_num = 0
    #项目概况表
    print("开始添加项目概况表")
    XIANG_MU_GAI_KUANG = os.path.join(muban_dir,"xiangmugaikuo.docx")
    print(f"查找模板，找到模板：{XIANG_MU_GAI_KUANG}")
    project_location = fengchang_location
    company_name_jia = Jia_company
    fuzeren = yi_fuzeren
    phone_fuzeren = yi_phone
    xiangmuguige = jizu_num
    Yi_company = Yi_company
    XIANGMU_GAIKUO = list(list("" for i in range(6)) for j in range(5))
    XIANGMU_GAIKUO[0][1] = fengchang_name
    XIANGMU_GAIKUO[0][4] = project_location
    XIANGMU_GAIKUO[1][1] = company_name_jia
    XIANGMU_GAIKUO[1][4] = Yi_company
    XIANGMU_GAIKUO[2][1] = jia_fuzeren
    XIANGMU_GAIKUO[2][4] = fuzeren
    XIANGMU_GAIKUO[3][2] = jia_phone
    XIANGMU_GAIKUO[3][5] = phone_fuzeren
    XIANGMU_GAIKUO[4][1] = jizu_xinghao
    XIANGMU_GAIKUO[4][3] = xiangmuguige
    XIANGMU_GAIKUO[4][5] = gongqi
    print("建立表结构完毕，开始插入模板")
    #添加项目概况表
    print(f"输出路径:{output_dir}，模板路径:{XIANG_MU_GAI_KUANG},插入数据：{XIANGMU_GAIKUO}")
    output_doc, message = await add_table_to_document(output_dir, XIANG_MU_GAI_KUANG,5,5,total_table_num,XIANGMU_GAIKUO)
    print(message)
    print("模板插入完毕，开始替换内容")
    total_table_num  += 1
    print(await search_and_replace(output_dir, jiegou_xuhao, num_to_chinese[head_num]))
    head_num += 1

    #检查方案描述
    FANGAN_JIANCHA_DIR = os.path.join(muban_dir,"checkmethod.docx")
    list_to_replace = {
        'renyuan_peizhi' : "\n".join(renyuan_peizhi),
        'shebei_peizhi' : "\n".join(shebei_peizhi),
        'shigong_fangan' : "\n".join(shigong_fangan),
        'gongzuo_neirong' : "\n".join(gongzuo_neirong),
        'beizhu' : beizhu,
        'num' : num_to_chinese[head_num],
    }
    print(await add_table_and_replace(output_dir, FANGAN_JIANCHA_DIR, 0, list_to_replace))
    print(split_table_by_row_content(output_dir, output_dir, total_table_num))
    total_table_num  += 1
    head_num += 1


    JIANCHA_XINGXI_DIR = os.path.join(muban_dir,"checkinfo.docx")
    JIANCHA_XINGXI = list(list("" for i in range(4)) for j in range(9))
    JIANCHA_XINGXI[0][1] = jiancha_renyuan
    try:
        JIANCHA_XINGXI[1][1] = Jiancha_date.split('T')[0]
    except:
        JIANCHA_XINGXI[1][1] = "格式不对或无数据"
    JIANCHA_XINGXI[1][3] = jizu_bianhao
    JIANCHA_XINGXI[2][1] = "风力发电机组" + baogao_name
    JIANCHA_XINGXI[2][3] = "、".join(jiancha)
    JIANCHA_XINGXI[3][2] = partManufacturer
    JIANCHA_XINGXI[4][1] = '叶片型号:' + jizu_xinghao
    JIANCHA_XINGXI[5][1] = Y_Code[0] if len(Y_Code) > 0 else "无"
    JIANCHA_XINGXI[6][1] = Y_Code[1] if len(Y_Code) > 1 else "无"
    JIANCHA_XINGXI[7][1] = Y_Code[2] if len(Y_Code) > 2 else "无"
    JIANCHA_XINGXI[8][0] = "本次" + "、".join(_ for _ in jiancha) + f"检查，采集叶片图片{normal_picture_num}张，内容覆盖" + ";".join(_ for _ in neirong)
    #新建检查信息表
    output_doc, message = await add_table_to_document(output_dir, JIANCHA_XINGXI_DIR,9,4,total_table_num ,JIANCHA_XINGXI,False)
    print(message)
    print(await search_and_replace(output_dir, jiegou_xuhao, num_to_chinese[head_num]))
    head_num += 1
    total_table_num  += 1

    # 添加成果递交表
    CHENGGUO_DIJIAO_DIR = os.path.join(muban_dir,"chengguo_sub.docx")
    CHENGGUO_DIJIAO = list(list("" for i in range(4)) for j in range(6))
    CHENGGUO_DIJIAO[0][1] = jiancha_renyuan 
    CHENGGUO_DIJIAO[1][1] = jia_fuzeren
    try:
        CHENGGUO_DIJIAO[2][1] = Jiancha_date.split('T')[0]
    except:
        CHENGGUO_DIJIAO[2][1] = "格式不对或无数据"
    CHENGGUO_DIJIAO[3][1] = data_processor
    CHENGGUO_DIJIAO[4][1] = baogao_bianzhi
    CHENGGUO_DIJIAO[5][1] = baogao_shenghe
    try:
        CHENGGUO_DIJIAO[2][3] = Jiancha_date.split('T')[1]
    except:
        CHENGGUO_DIJIAO[2][3] = "格式不对或无数据"
    CHENGGUO_DIJIAO[3][3] = baogao_date.split(' ')[0]
    CHENGGUO_DIJIAO[4][3] = baogao_date.split(' ')[0]
    CHENGGUO_DIJIAO[5][3] = "未审核"

    output_doc, message = await add_table_to_document(output_dir, CHENGGUO_DIJIAO_DIR,5,5,total_table_num,CHENGGUO_DIJIAO,True,0.04)
    print(message)
    print(await search_and_replace(output_dir, jiegou_xuhao, num_to_chinese[head_num]))
    head_num += 1
    total_table_num  += 1

    #检查情况汇总表（文字信息）
    
    try:
        #获取缺陷信息
        """
        需要获取：
        Y1、Y2、Y3叶片的缺陷数量，缺陷字典{描述：图片路径}
        和数据库连接需要的新增异常处理：
        目前逻辑为找到图片后，找缺陷类型的图片，通过图片id查找对应缺陷记录
        如果没有找到，要返回对应异常，即已选出（标注）缺陷图，但未填写对应缺陷信息的异常返回。
        最后将无异常的图片入队缺陷字典（同数量），有异常的图片再另存。
        """
        
        Y1_quexian_dict = {}
        Y2_quexian_dict = {}
        Y3_quexian_dict = {}
        Y1_quexian_num = Y1_quexian_dict.keys()
        Y2_quexian_num = Y2_quexian_dict.keys()
        Y3_quexian_num = Y3_quexian_dict.keys()
        weak_num_Y1 = f"{Y_Code[0] if len(Y_Code) > 0 else '无'}叶片共发现缺陷{Y1_quexian_num}处"
        weak_num_Y2 = f"{Y_Code[1] if len(Y_Code) > 1 else '无'}叶片共发现缺陷{Y2_quexian_num}处"
        weak_num_Y3 = f"{Y_Code[2] if len(Y_Code) > 2 else '无'}叶片共发现缺陷{Y3_quexian_num}处"
    except Exception as e:
        print(f"缺陷图获取失败：{e}")
        return
    
    #添加检查情况汇总表
    JIANCHA_HUIZONG_DIR = os.path.join(muban_dir,"total_check.docx")
    JIANCHA_HUIZONG = list(list("" for i in range(3)) for j in range(4))

    JIANCHA_HUIZONG[1][0] = weak_num_Y1
    JIANCHA_HUIZONG[2][0] = weak_num_Y2
    JIANCHA_HUIZONG[3][0] = weak_num_Y3
    JIANCHA_HUIZONG[1][1] = "\n".join(neirong)
    JIANCHA_HUIZONG[2][1] = "\n".join(neirong)
    JIANCHA_HUIZONG[3][1] = "\n".join(neirong)
    JIANCHA_HUIZONG[1][2] = "\n".join([f"{i+1}.{name}" for i, (name, path) in enumerate(Y1_quexian_dict.items())]) if Y1_quexian_num else '未发现明显影响风力发电机组正常运行的缺陷'
    JIANCHA_HUIZONG[2][2] = "\n".join([f"{i+1}.{name}" for i, (name, path) in enumerate(Y2_quexian_dict.items())]) if Y2_quexian_num else '未发现明显影响风力发电机组正常运行的缺陷'
    JIANCHA_HUIZONG[3][2] = "\n".join([f"{i+1}.{name}" for i, (name, path) in enumerate(Y3_quexian_dict.items())]) if Y3_quexian_num else '未发现明显影响风力发电机组正常运行的缺陷'
    output_doc, message = await add_table_to_document(output_dir, JIANCHA_HUIZONG_DIR,4,3,total_table_num,JIANCHA_HUIZONG,False,ALIGMENT='LEFT')
    print(message)
    print(await search_and_replace(output_dir, jiegou_xuhao, num_to_chinese[head_num]))
    total_table_num  += 1
    head_num += 1
    
    #主要部位图片展示表/检查内容表
    #获取典型图信息
    search_file_list = ["外汇总","内汇总","防汇总"]
    try:
        picture_Y1_num, Y1_dict = collect_defect_data(Y1, Picture_dir, ifwaibu, ifneibu, search_file_list, iffanglei)  
        picture_Y2_num, Y2_dict = collect_defect_data(Y2, Picture_dir, ifwaibu, ifneibu, search_file_list, iffanglei)  
        picture_Y3_num, Y3_dict = collect_defect_data(Y3, Picture_dir, ifwaibu, ifneibu, search_file_list, iffanglei)  
    except Exception as e:
        print(f"获取缺陷图失败：{e}")
    print(f"图片、文字数量：{picture_Y1_num} {picture_Y2_num} {picture_Y3_num}")
    JIANCHA_NEIRONG_TOTAL_NUM = picture_Y1_num+ picture_Y2_num + picture_Y3_num
    col ,row = 3, 0
    JIANCHA_NEIRONG_PICTURES_TABLE = os.path.join(muban_dir,"check2.docx")
    JIANCHA_NEIRONG_Y1_DIR = os.path.join(muban_dir,"check_content.docx")
    JIANCHA_NEIRONG_Y1 = list(list("" for _ in range(3)) for j in range(1))
    JIANCHA_NEIRONG_Y1[0][0] = f"叶片1：{Y1}检查内容"
    print(f"Y1标题内容：{JIANCHA_NEIRONG_Y1}")
    JIANCHA_NEIRONG_Y2_DIR = os.path.join(muban_dir,"check3.docx")
    JIANCHA_NEIRONG_Y2 = list(list("" for _ in range(3)) for j in range(1))
    JIANCHA_NEIRONG_Y2[0][0] = f"叶片2：{Y2}检查内容"
    print(f"Y2标题内容：{JIANCHA_NEIRONG_Y2}")
    JIANCHA_NEIRONG_Y3_DIR = os.path.join(muban_dir,"check3.docx")
    JIANCHA_NEIRONG_Y3 = list(list("" for _ in range(3)) for j in range(1))
    JIANCHA_NEIRONG_Y3[0][0] = f"叶片3：{Y3}检查内容"
    print(f"Y3标题内容：{JIANCHA_NEIRONG_Y3}")
    print(f"当前表格序号为 {total_table_num}")
    print(key_words)
    output_doc, message = await add_table_to_document(output_dir, JIANCHA_NEIRONG_Y1_DIR,1,3,total_table_num,JIANCHA_NEIRONG_Y1,True, 1)
    print(message)
    total_table_num += 1
    
    total_table_num = await process_images_table(Y1_dict, output_dir, total_table_num, JIANCHA_NEIRONG_PICTURES_TABLE, key_words)
    
    output_doc, message = await add_table_to_document(output_dir, JIANCHA_NEIRONG_Y2_DIR,1,3,total_table_num,JIANCHA_NEIRONG_Y2,True, 1)
    print(message)    
    total_table_num += 1
    
    total_table_num = await process_images_table(Y2_dict, output_dir, total_table_num, JIANCHA_NEIRONG_PICTURES_TABLE, key_words)
    
    output_doc, message = await add_table_to_document(output_dir, JIANCHA_NEIRONG_Y3_DIR,1,3,total_table_num,JIANCHA_NEIRONG_Y3,True, 1)
    print(message)  
    total_table_num += 1
    
    total_table_num = await process_images_table(Y3_dict, output_dir, total_table_num, JIANCHA_NEIRONG_PICTURES_TABLE, key_words)
    print(await search_and_replace(output_dir, jiegou_xuhao, num_to_chinese[head_num]))
    head_num += 1

    # #缺陷详情
    # QUEXIAN_XIANGQING_DIR = os.path.join(muban_dir,"check_check.docx")
    # QUEXIAN_XIANGQING_TITLE_DIR = os.path.join(muban_dir,"check_check_title.docx")
    
    # Y_tables = [Y1_quexian_dict,Y2_quexian_dict,Y3_quexian_dict]
    # Y1_table_list = []
    # Y2_table_list = []
    # Y3_table_list = []
    # table_lists = [Y1_table_list, Y2_table_list, Y3_table_list]

    # for i, (table_list, Y_dict) in enumerate(zip(table_lists, Y_tables)):
    #     for image_name, image_path in Y_dict.items():
    #         # 从图片名解析各个字段
    #         parts = image_name.split('_')
    #         if len(parts) >= 8:  # 确保有7个部分
    #             defect_type = parts[1]
    #             defect_location = parts[2]
    #             defect_size = parts[3]
    #             visibility = parts[4]
    #             urgency = parts[5]
    #             severity = parts[6]
    #             repair_suggestion = parts[7]
                
    #             print(f"获取第{i+1}个叶片的缺陷图: {image_path}")
                
    #             table_list.append({
    #                 "QueXianLeiXing": defect_type,
    #                 "QueXianWeiZhi": defect_location,
    #                 "QueXianChiCun": defect_size,
    #                 "WeiZongDengJi": severity,
    #                 "Tupian_Dir": image_path,
    #                 "visibility": visibility,
    #                 "urgency": urgency,
    #                 "repair_suggestion": repair_suggestion.split('.')[0],  # 新增维修建议字段
    #             })
    #         else:
    #             table_list.append({
    #                 "QueXianLeiXing": "图片命名有误",
    #                 "QueXianWeiZhi": "图片命名有误",
    #                 "QueXianChiCun": "图片命名有误",
    #                 "WeiZongDengJi": "图片命名有误",
    #                 "Tupian_Dir": image_path,
    #                 "visibility": "图片命名有误",
    #                 "urgency": "图片命名有误",
    #                 "repair_suggestion": "图片命名有误",  # 新增维修建议字段
    #             })
    
    
    # Y1_TABLES, Y1_TABLES_PICTURES = fill_tables(table_lists[0],4,5,len(table_lists[0]),Y1)
    # Y2_TABLES, Y2_TABLES_PICTURES = fill_tables(table_lists[1],4,5,len(table_lists[1]),Y2)
    # Y3_TABLES, Y3_TABLES_PICTURES = fill_tables(table_lists[2],4,5,len(table_lists[2]),Y3)
    # print(add_documents(output_dir, QUEXIAN_XIANGQING_TITLE_DIR))
    # print(await search_and_replace(output_dir, jiegou_xuhao, num_to_chinese[head_num]))
    # head_num += 1
    # table_num = 0
    # Xu_Hao = 0
    # total_table_num,table_num,Xu_Hao = await add_dynamic_table(output_doc,output_dir,table_num,Y1_TABLES,QUEXIAN_XIANGQING_DIR,Y1_TABLES_PICTURES,4,5,total_table_num,False,xuhao=Xu_Hao)
    # total_table_num,table_num,Xu_Hao = await add_dynamic_table(output_doc,output_dir,table_num,Y2_TABLES,QUEXIAN_XIANGQING_DIR,Y2_TABLES_PICTURES,4,5,total_table_num,False,xuhao=Xu_Hao)
    # total_table_num,table_num,Xu_Hao = await add_dynamic_table(output_doc,output_dir,table_num,Y3_TABLES,QUEXIAN_XIANGQING_DIR,Y3_TABLES_PICTURES,4,5,total_table_num,False,xuhao=Xu_Hao)
    
    
    #总结
    ZONG_JIE_DIR = os.path.join(muban_dir,"result.docx")
    ZONG_JIE_BEFORE = "result"
    ZONG_JIE = baogao_info['baogao_zongjie']
    print(add_documents(output_dir, ZONG_JIE_DIR))
    print(await search_and_replace(output_dir, ZONG_JIE_BEFORE, ZONG_JIE))
    print(await search_and_replace(output_dir, 'company_yi', Yi_company))
    print(await search_and_replace(output_dir, 'baogao_date', baogao_date.split(' ')[0]))
    print(await search_and_replace(output_dir, jiegou_xuhao, num_to_chinese[head_num]))

import argparse

def parse_arguments():
    parser = argparse.ArgumentParser(description='报告生成工具')
    
    # 设置默认值
    default_json1 = {
        "turbine_id": "183463dbf40d9278549a76b82b175dd9",
    }
    default_json2 = {
        'shengcheng_dir': r"",
        'muban_dir': r"",
        "dianxing_enum" : "TYPICAL",  # 典型图的枚举值
        "quexian_enum" : "DEFECT",    # 缺陷图的枚举值
        "other_enum" : "OTHER",       # 其他图的枚举值
        "waibu_enum" : "out-work",
        "neibu_enum" : "in-work",
        "fanglei_enum" : "lightning-protection-work",
        "if_waibu" : True,
        "if_neibu" : True,
        "if_fanglei" : True,
        "userName" : "admin",
        "baogaoCheck" : "未审核",
        'key_words': '缺,损,裂,脱,污',    #关键字，用于汇总图的名字包含缺陷时标红，匹配逻辑为正则匹配单个字则为红  后续可优化
        
        "data_processor" : "未获取",
        "shigong_fangan" : None,
        'jiancha_renyuan': '未获取',
        "check_date" : None,
        "coverurl" : None,
    }
    
    parser.add_argument('--turbine_id', '--id', dest='turbine_id', default=default_json1['turbine_id'], 
                       help='''风机ID，默认为测试项目："183463dbf40d9278549a76b82b175dd9"
                       用于获取机组关联的所有静态信息与图片''')
    parser.add_argument('--output_dir', '--out', dest='output_dir', default=default_json2['shengcheng_dir'],
                       help='输出目录，必填项')
    parser.add_argument('--template_dir', '--tpl', dest='template_dir', default=default_json2['muban_dir'],
                       help='模板目录，必填项,用于获取模板文件,模板文件在同目录下的muban文件夹')
    parser.add_argument('--data_processor', '--dp', dest='data_processor', default=default_json2['data_processor'],
                       help='数据处理人')
    parser.add_argument('--jiancha_renyuan', '--jc', dest='jiancha_renyuan', default=default_json2['jiancha_renyuan'],
                       help='检查人')
    parser.add_argument('--check_date', '--cdate', dest='check_date', default=default_json2['check_date'],
                        help='检查日期,格式为YYYY-MM-DD HH:MM:SS')
    parser.add_argument('--username', '--user', dest='username', default=default_json2['userName'],
                        help='报告生成人,默认为admin')
    parser.add_argument('--if_waibu', '--waibu', dest='if_waibu', default=default_json2['if_waibu'],
                        help='报告是否包含外部检测,默认为True')
    parser.add_argument('--if_neibu', '--neibu', dest='if_neibu', default=default_json2['if_neibu'],
                        help='报告是否包含内部检测,默认为True')
    parser.add_argument('--if_fanglei', '--fanglei', dest='if_fanglei', default=default_json2['if_fanglei'],
                        help='报告是否包含防雷检测,默认为True')
    parser.add_argument('--reportchecker', '--rc', dest='baogaoCheck', default=default_json2['baogaoCheck'],
                        help='报告审核状态,默认为未审核')
    parser.add_argument('--dianxing_enum', '--dx', dest='dianxing_enum', default=default_json2['dianxing_enum'],
                        help='典型图的枚举值,默认为TYPICAL')
    parser.add_argument('--quexian_enum', '--qx', dest='quexian_enum', default=default_json2['quexian_enum'],
                        help='缺陷图的枚举值,默认为DEFECT')
    parser.add_argument('--other_enum', '--other', dest='other_enum', default=default_json2['other_enum'],
                        help='其他图的枚举值,默认为OTHER')
    parser.add_argument('--waibu_enum', '--wb', dest='waibu_enum', default=default_json2['waibu_enum'],
                        help='外部检测的枚举值,默认为out_work')
    parser.add_argument('--neibu_enum', '--nb', dest='neibu_enum', default=default_json2['neibu_enum'],
                        help='内部检测的枚举值,默认为in_work')
    parser.add_argument('--fanglei_enum', '--fb', dest='fanglei_enum', default=default_json2['fanglei_enum'],
                        help='防雷检测的枚举值,默认为lightning-protection-work')
    parser.add_argument('--keywords', '--kw', dest='keywords', default=default_json2['key_words'],
                        help='关键字，用于汇总图的名字包含缺陷时标红，匹配逻辑为正则匹配单个字则为红  后续可优化')
    parser.add_argument('--coverurl', default=default_json2['coverurl'], help='封面图片url,指定coverurl则不使用模板中的封面图片')

    return parser.parse_args()

def main():
    args = parse_arguments()
    
    json_data1 = {
        "turbine_id": args.turbine_id,
    }
    
    json_data2 = {
        'shengcheng_dir': args.output_dir,
        'muban_dir': args.template_dir,
        "dianxing_enum" : args.dianxing_enum,  # 典型图的枚举值
        "quexian_enum" : args.quexian_enum,    # 缺陷图的枚举值
        "other_enum" : args.other_enum,       # 其他图的枚举值
        "waibu_enum" : args.waibu_enum,
        "neibu_enum" : args.neibu_enum,
        "fanglei_enum" : args.fanglei_enum,
        "if_waibu" : args.if_waibu,
        "if_neibu" : args.if_neibu,
        "if_fanglei" : args.if_fanglei,
        "userName" : args.username,
        "baogaoCheck" : args.baogaoCheck,
        'key_words': args.keywords,    #关键字，用于汇总图的名字包含缺陷时标红，匹配逻辑为正则匹配单个字则为红  后续可优化
        "shigong_fangan" : None,
        'jiancha_renyuan': args.jiancha_renyuan,
        "check_date" : args.check_date,
        "data_processor" : args.data_processor,
        "coverurl" : args.coverurl,
    }
    
    json_data2['shengcheng_dir'] = r"/home/dtyx/桌面/yhh/Report_Generate_Server/output"
    json_data2['muban_dir'] = r"/home/dtyx/桌面/yhh/Report_Generate_Server/muban"

    asyncio.run(generate_report(json_data1, json_data2))
    print('文档生成完毕')

if __name__ == '__main__':
    main()