"""
财务报表解析器主模块
"""

import logging
import io
import sys
from typing import Dict, Any, Optional, TypedDict, List
from pathlib import Path
import tempfile
import pdfplumber
import os

from .transfrom_table_to_json import transfrom_table_to_json

logger = logging.getLogger(__name__)


class TableInfo(TypedDict):
    """表格信息类型定义"""
    table: List[List[str]]  # 表格数据
    page_number: int        # 页码
    table_index: int        # 表格在页面中的索引
    position: str           # 位置描述
    bbox: tuple[float, float, float, float]  # 边界框坐标 (x0, y0, x1, y1)
    x0: float              # 左边界x坐标
    y0: float              # 上边界y坐标
    x1: float              # 右边界x坐标
    y1: float              # 下边界y坐标
    width: float           # 表格宽度
    height: float          # 表格高度


class FinancialReportParser:
    """
    财务报表解析器类
    
    用于解析各种格式的财务报表文件，包括 PDF、Excel 等。
    """
    
    def __init__(self):
        """
        初始化解析器
        
        Args:
            config: 配置字典，包含解析参数
        """
        self.logger = logger
        self.report_json = {}
        self.table_info = {}

    def parse_all_tables(self, content: bytes) -> List[TableInfo]:
        if content is None:
            raise ValueError("content 不能为空，必须是PDF的字节内容")
        """
        提取PDF中的所有表格
        Args:
            content (bytes): PDF文件的字节内容
        Returns:
            List[TableInfo]: 包含表格数据、位置信息和坐标信息的字典列表
        """
        with tempfile.NamedTemporaryFile(suffix='.pdf', delete=False) as tmp_file:
            tmp_file.write(content)
            tmp_path = tmp_file.name

        tables_with_positions = []
        try:
            with pdfplumber.open(tmp_path) as pdf:
                for page_num, page in enumerate(pdf.pages):
                    # 使用find_tables获取表格的边界框信息
                    table_objects = page.find_tables()
                    page_tables = page.extract_tables()
                    
                    for table_idx, (table, table_obj) in enumerate(zip(page_tables, table_objects)):
                        if table:  # 只添加非空表格
                            # 获取表格边界框
                            bbox = table_obj.bbox
                            # bbox格式: (x0, y0, x1, y1) - 左上角和右下角坐标
                            table_info = {
                                'table': table,
                                'page_number': page_num + 1,  # 页码从1开始
                                'table_index': table_idx + 1,  # 表格在页面中的索引
                                'position': f"第{page_num + 1}页第{table_idx + 1}个表格",
                                'bbox': bbox,  # 表格边界框坐标 (x0, y0, x1, y1)
                                'x0': bbox[0],  # 左边界x坐标
                                'y0': bbox[1],  # 上边界y坐标
                                'x1': bbox[2],  # 右边界x坐标
                                'y1': bbox[3],  # 下边界y坐标
                                'width': bbox[2] - bbox[0],  # 表格宽度
                                'height': bbox[3] - bbox[1],  # 表格高度
                            }
                            tables_with_positions.append(table_info)
        except Exception as e:
            print(f"❌ PDF解析失败: {str(e)}")
            print(f"   内容长度: {len(content)} 字节")
            print(f"   内容前100字节: {content[:100]}")
            return []
        finally:
            # 确保临时文件被删除
            try:
                os.unlink(tmp_path)
            except:
                pass

        return tables_with_positions
    
    def is_row_has_number_column(self, row):
        """
        判断一行中是否有某个单元格是数字（或金额字符串，支持逗号和小数点）
        """
        for cell in row:
            if cell is None or cell == "" or (cell and str(cell).replace(',', '').replace('.', '', 1).replace('-', '', 1).isdigit()):
                return True
        return False
    
    def convert_table_to_json(self, table: List[List[str]], table_info: Optional[TableInfo] = None):
        """
        将表格转换为JSON格式（包含表格类型识别）
        """
        if not table:
            return "未知"
        
        return transfrom_table_to_json(table, table_info)

    def merge_multi_page_tables(self, tables_with_positions: List[TableInfo]) -> List[TableInfo]:
        """
        合并多页表格
        """
        merged_tables = []
        last_table_info = None
        
        for table_info in tables_with_positions:
            table = table_info['table']
            if not table:
                continue
            first_row = table[0]
            # 判断当前表格第一行是否有数字列
            if last_table_info and len(first_row) == len(last_table_info['table'][0]) and self.is_row_has_number_column(first_row):
                # 跨页，合并（不去掉第一行）
                last_table_info['table'].extend(table)
                # 更新位置信息，表示这是跨页表格
                last_table_info['position'] += f" + 第{table_info['page_number']}页第{table_info['table_index']}个表格"
                
                # 更新边界框信息：左上角用第一个表格，右下角用当前表格
                # 保持左上角坐标不变（第一个表格的左上角）
                # 更新右下角坐标为当前表格的右下角
                last_table_info['x1'] = table_info['x1']  # 右边界用当前表格
                last_table_info['y1'] = table_info['y1']  # 下边界用当前表格
                last_table_info['bbox'] = (
                    last_table_info['x0'],  # 左边界（第一个表格）
                    last_table_info['y0'],  # 上边界（第一个表格）
                    table_info['x1'],       # 右边界（当前表格）
                    table_info['y1']        # 下边界（当前表格）
                )
                # 重新计算宽度和高度
                last_table_info['width'] = last_table_info['x1'] - last_table_info['x0']
                last_table_info['height'] = last_table_info['y1'] - last_table_info['y0']
            else:
                last_table_info = table_info.copy()
                merged_tables.append(last_table_info)
        
        return merged_tables

    def parse_pdf(self, content: bytes) -> dict:
        """
        解析PDF内容，提取财务报表数据
        """
        # 创建临时文件
        with tempfile.NamedTemporaryFile(delete=False, suffix='.pdf') as temp_file:
            temp_file.write(content)
            temp_file_path = temp_file.name
        
        try:
            # 解析所有表格
            all_tables = self.parse_all_tables(content)
            
            # 合并多页表格
            merged_tables = self.merge_multi_page_tables(all_tables)
            # 处理每个表格
            results = []
            for table_info in merged_tables:
                # 添加PDF内容到table_info中，用于提取表格上方文本
                table_info['pdf_content'] = content
                
                # 识别表格类型并转换为JSON
                table_json = self.convert_table_to_json(table_info['table'], table_info)
                
                if table_json:
                    results.append(table_json)
            
            # 合并所有结果
            final_result = {}
            for result in results:
                for key, value in result.items():
                    if key not in final_result:
                        final_result[key] = value
                    elif isinstance(value, dict) and isinstance(final_result[key], dict):
                        final_result[key].update(value)
            print(final_result)
            return final_result
            
        finally:
            # 清理临时文件
            if os.path.exists(temp_file_path):
                os.unlink(temp_file_path)
    
    def get_version(self) -> str:
        """
        获取解析器版本
        
        Returns:
            版本字符串
        """
        from . import __version__
        return __version__ 