import json
from docx import Document
from docx.oxml.shared import qn


def docx_to_json(docx_path):
    print(f"\n开始解析文档: {docx_path}")
    doc = Document(docx_path)

    result = []
    para_index = 0
    table_index = 0

    print(f"文档包含 {len(doc.paragraphs)} 个段落和 {len(doc.tables)} 个表格")

    for element in doc.element.body:
        if element.tag.endswith('p'):
            paragraph = doc.paragraphs[para_index]
            print(f"\n处理段落 {para_index}: {paragraph.text[:50]}...")
            para_data = process_paragraph(paragraph)
            result.append({
                "type": "text",
                "content": para_data
            })
            para_index += 1
        elif element.tag.endswith('tbl'):
            table = doc.tables[table_index]
            print(f"\n处理表格 {table_index} ({len(table.rows)}行×{len(table.columns)}列)")
            table_data = process_table_with_merge_info(table)
            result.append({
                "type": "table",
                "content": table_data
                # 移除了bold属性，加粗信息现在由每个run单独记录
            })
            table_index += 1

    print("\n文档解析完成!")
    return result

def process_table_with_merge_info(table):
    """处理表格并包含合并信息、行高列宽和完整格式"""
    table_data = {
        "rows": len(table.rows),
        "cols": len(table.columns),
        "cells": [],
        "merged_cells": [],
        "row_heights": [None] * len(table.rows),
        "col_widths": [None] * len(table.columns)
    }

    # 先处理所有单元格内容
    cell_data_matrix = []
    for i, row in enumerate(table.rows):
        row_data = []
        for j, cell in enumerate(row.cells):
            cell_data = {
                "row": i,
                "col": j,
                "content": process_cell_content(cell),
                "alignment": get_cell_alignment(cell),  # 获取单元格对齐
                "vertical_align": get_vertical_alignment(cell),  # 新增垂直对齐
                "border": get_cell_border(cell),
                "shading": get_cell_shading(cell),  # 新增背景色
                "margins": get_cell_margins(cell),  # 新增边距
                "is_merged": False,
                "merge_info": None
            }
            row_data.append(cell_data)
            
            # 记录行高列宽（最后一个单元格时记录）
            if j == len(row.cells) - 1 and row.height is not None:
                table_data["row_heights"][i] = row.height.inches
            if i == len(table.rows) - 1 and table.columns[j].width is not None:
                table_data["col_widths"][j] = table.columns[j].width.inches
                
        cell_data_matrix.append(row_data)

    # 检测合并单元格
    merge_ranges = []
    for i, row in enumerate(table.rows):
        for j, cell in enumerate(row.cells):
            # 跳过已经处理过的合并单元格
            if any((i >= r1 and i <= r2 and j >= c1 and j <= c2) for (r1, r2, c1, c2) in merge_ranges):
                continue

            # 查找相同单元格地址的范围
            r2 = i
            c2 = j
            
            # 水平方向查找
            while c2 + 1 < table_data["cols"] and table.rows[i].cells[c2 + 1]._tc is cell._tc:
                c2 += 1
            
            # 垂直方向查找
            while r2 + 1 < table_data["rows"] and table.rows[r2 + 1].cells[j]._tc is cell._tc:
                r2 += 1
            
            # 如果找到合并区域
            if r2 > i or c2 > j:
                merge_ranges.append((i, r2, j, c2))
                
                # 更新主单元格信息
                cell_data_matrix[i][j]["is_merged"] = True
                cell_data_matrix[i][j]["merge_info"] = {
                    "is_primary": True,
                    "merge_range": f"{i},{j}-{r2},{c2}"
                }
                
                # 添加到合并单元格列表
                table_data["merged_cells"].append({
                    "start_row": i,
                    "start_col": j,
                    "end_row": r2,
                    "end_col": c2,
                    "content": process_cell_content(cell)
                })
                
                # 更新被合并单元格信息
                for r in range(i, r2 + 1):
                    for c in range(j, c2 + 1):
                        if r != i or c != j:  # 跳过主单元格
                            cell_data_matrix[r][c]["is_merged"] = True
                            cell_data_matrix[r][c]["merge_info"] = {
                                "is_primary": False,
                                "merge_range": f"{i},{j}-{r2},{c2}"
                            }

    # 将处理后的单元格数据添加到结果中
    table_data["cells"] = cell_data_matrix

    return table_data

def get_vertical_alignment(cell):
    """获取单元格垂直对齐方式"""
    try:
        tcPr = cell._element.tcPr
        if tcPr is not None:
            vAlign = tcPr.find(qn('w:vAlign'))
            if vAlign is not None:
                align_map = {
                    'top': 'top',
                    'center': 'center',
                    'bottom': 'bottom'
                }
                return align_map.get(vAlign.get(qn('w:val')), 'top')
    except:
        print("获取垂直对齐方式失败")
        pass
    return 'top'  # 默认顶部对齐

def get_cell_shading(cell):
    """获取单元格背景色"""
    try:
        tcPr = cell._element.tcPr
        if tcPr is not None:
            shading = tcPr.find(qn('w:shd'))
            if shading is not None:
                color = shading.get(qn('w:fill'))
                if color:
                    return {
                        'color': color,
                        'theme': shading.get(qn('w:themeColor'), '')
                    }
    except:
        pass
    return None

def get_cell_margins(cell):
    """获取单元格边距"""
    margins = {}
    try:
        tcPr = cell._element.tcPr
        if tcPr is not None:
            for side in ['top', 'left', 'bottom', 'right']:
                margin = tcPr.find(qn(f'w:tcMar/w:{side}'))
                if margin is not None:
                    margins[side] = {
                        'w': margin.get(qn('w:w')),
                        'type': margin.get(qn('w:type'))
                    }
    except:
        pass
    return margins if margins else None

def process_cell_content(cell):
    """处理单元格内容，直接调用段落处理函数"""
    cell_content = []
    for para in cell.paragraphs:
        # 复用段落处理逻辑
        para_data = process_paragraph(para)
        cell_content.append(para_data)
    return cell_content

def has_page_break(run):
    """检查run是否包含分页符"""
    xml = run._element.xml
    return ('w:br' in xml and 'type="page"' in xml) or '\x0c' in run.text

def process_paragraph(paragraph):
    para_data = {
        "alignment": get_alignment_with_fallback(paragraph),
        "runs": []
    }

    print(f"段落对齐方式: {para_data['alignment']}")

    for run in paragraph.runs:
        run_data = {
            "text": run.text,
            "font": get_font_info(run, paragraph),
            "style": run.style.name if run.style else None,
            "has_page_break": has_page_break(run)
        }
        para_data["runs"].append(run_data)

    print(f"段落包含 {len(para_data['runs'])} 个文本运行(runs)")
    return para_data

def get_alignment_with_fallback(paragraph):
    # 首先尝试直接从段落属性获取
    try:
        if paragraph.alignment is not None:
            alignment_map = {
                0: "left",
                1: "center",
                2: "right",
                3: "justify"
            }
            result = alignment_map.get(paragraph.alignment, "left")
            print(f"从paragraph.alignment获取对齐方式: {result}")
            return result
    except:
        # 如果段落alignment为None，尝试从样式获取
        try:
            p_pr = paragraph.style.element.xpath('w:pPr')[0]
            if p_pr.xpath('w:jc'):
                jc_attr = p_pr.xpath('w:jc')[0].attrib
                align_map = {
                    "left": "left",
                    "center": "center",
                    "right": "right",
                    "both": "justify",
                    "start": "left",
                    "end": "right"
                }
                result = align_map.get(jc_attr[qn('w:val')], "left")
                print(f"从段落样式w:jc获取对齐方式: {result}")
                return result
        except Exception as e:
            print(f"获取对齐方式失败: {str(e)}")

    print("使用默认对齐方式(left)")
    return "left"

def get_font_info(run, paragraph):
    font = run.font
    font_info = {
        "name": None,
        "size": None,
        "bold": font.bold if font.bold is not None else False,  # 默认为False
        "italic": font.italic,
        "underline": font.underline,
        "color": get_color_info(run, paragraph)
    }

    # 处理字体大小
    if font.size:
        font_info["size"] = font.size.pt
    else:
        try:
            p_rpr = paragraph.style.element.xpath('w:rPr')[0]
            if p_rpr.xpath('w:sz'):
                sz_attr = p_rpr.xpath('w:sz')[0].attrib
                font_info["size"] = int(sz_attr[qn('w:val')]) / 2  # 转换为pt
                print(f"从段落样式获取字体大小: {font_info['size']}pt")
        except Exception as e:
            print(f"获取字体大小失败: {str(e)}")
            font_info["size"] = 11  # 默认值

    # 处理字体名称
    if font.name:
        font_info["name"] = font.name
        print(f"从run.font获取字体: {font.name}")
    else:
        try:
            p_rpr = paragraph.style.element.xpath('w:rPr')[0]
            if p_rpr.xpath('w:rFonts'):
                try:
                    font_info["name"] = p_rpr.xpath('w:rFonts')[0].attrib[qn("w:eastAsia")]
                    print(f"从段落样式w:eastAsia获取字体: {font_info['name']}")
                except:
                    font_info["name"] = p_rpr.xpath('w:rFonts')[0].attrib[qn("w:ascii")]
                    print(f"从段落样式w:ascii获取字体: {font_info['name']}")
        except Exception as e:
            print(f"获取字体失败: {str(e)}")
            font_info["name"] = "Calibri"  # 默认值

    return font_info

def get_color_info(run, paragraph):
    """增强版颜色获取，优先从run获取，失败则从段落样式获取"""
    color_info = None
    
    # 1. 首先尝试从run.font获取颜色
    try:
        if run.font.color and hasattr(run.font.color, 'rgb'):
            color = run.font.color
            color_info = {
                "r": (color.rgb >> 16) & 0xff,
                "g": (color.rgb >> 8) & 0xff,
                "b": color.rgb & 0xff
            }
            print(f"从run.font获取颜色: RGB({color_info['r']}, {color_info['g']}, {color_info['b']})")
    except Exception as e:
        print(f"从run.font获取颜色失败: {str(e)}")
    
    # 2. 如果run颜色为空，尝试从段落样式中获取
    if color_info is None:
        try:
            p_rpr = paragraph.style.element.xpath('w:rPr')[0]
            if p_rpr.xpath('w:color'):
                color_attr = p_rpr.xpath('w:color')[0].attrib
                if 'w:val' in color_attr:
                    hex_color = color_attr[qn('w:val')]
                    if hex_color.startswith('FF'):
                        hex_color = hex_color[2:]
                    rgb = tuple(int(hex_color[i:i+2], 16) for i in (0, 2, 4))
                    color_info = {
                        "r": rgb[0],
                        "g": rgb[1],
                        "b": rgb[2]
                    }
                    print(f"从段落样式获取颜色: RGB{rgb}")
        except Exception as e:
            print(f"从段落样式获取颜色失败: {str(e)}")
    
    return color_info

def get_cell_alignment(cell):
    if cell.paragraphs:
        return get_alignment_with_fallback(cell.paragraphs[0])
    return "left"

def get_cell_border(cell):
    # 默认返回实线边框
    default_border = {
        "top": {"style": "single", "size": 4, "color": "000000"},
        "bottom": {"style": "single", "size": 4, "color": "000000"},
        "left": {"style": "single", "size": 4, "color": "000000"},
        "right": {"style": "single", "size": 4, "color": "000000"}
    }
    
    try:
        # 尝试获取实际边框设置
        tcPr = cell._element.tcPr
        if tcPr is None:
            return default_border
            
        borders = {}
        for side in ['top', 'bottom', 'left', 'right']:
            border = tcPr.xpath(f'w:tcBorders/w:{side}')
            if border:
                border = border[0]
                border_style = border.get(qn('w:val'), 'single')
                border_size = border.get(qn('w:sz'), '4')
                border_color = border.get(qn('w:color'), '000000')
                borders[side] = {
                    "style": border_style,
                    "size": int(border_size),
                    "color": border_color
                }
            else:
                borders[side] = default_border[side]
        
        return borders
    except Exception as e:
        print(f"获取单元格边框失败: {str(e)}, 使用默认边框")
        return default_border

def process_cell(cell):
    cell_content = []
    print(f"处理单元格，包含 {len(cell.paragraphs)} 个段落")

    for para in cell.paragraphs:
        cell_content.append(process_paragraph(para))

    return cell_content

if __name__ == "__main__":
    docx_path = r'D:\work\报告扫描\source.docx'
    json_data = docx_to_json(docx_path)

    with open("output.json", "w", encoding="utf-8") as f:
        json.dump(json_data, f, ensure_ascii=False, indent=2)

    print("转换完成，结果已保存到output.json")