"""
目录层级识别模块
用于识别目录项的层级关系
"""

import re

try:
    from ..config.config_loader import get_config
except ImportError:
    from config.config_loader import get_config


class TOCLevelIdentifier:
    """目录层级识别器"""
    
    def __init__(self):
        self.config = get_config()
    
    def match_format_pattern(self, text: str):
        """
        匹配文本的格式模式
        
        参数:
            text: 待匹配的文本
            
        返回:
            匹配到的格式信息，包含pattern和template，如果未匹配则返回None
        """
        templates = self.config.format_patterns_templates
        
        for template_info in templates:
            pattern = template_info.get('pattern', '')
            if pattern and re.match(pattern, text):
                return {
                    'pattern': pattern,
                    'template': template_info.get('template', ''),
                    'name': template_info.get('name', '')
                }
        
        return None
    
    def get_format_key(self, format_info):
        """
        获取格式的唯一标识（用于格式比较）
        
        参数:
            format_info: 格式信息（包含pattern和template）
            
        返回:
            格式的唯一标识字符串
        """
        return format_info.get('template', '')
    
    def identify_levels(self, toc_items):
        """
        识别目录层级（使用新的逻辑：第一个项一定是一级目录）
        
        新逻辑：
        1. 第一个项一定是一级目录，找到适配它的正则规则
        2. 用这个规则找其他一级目录
        3. 明确所有一级目录后，递归处理每个一级目录的子项
        
        参数:
            toc_items: 目录项列表，每个项包含title和page
            
        返回:
            带层级信息的目录项列表
        """
        if not toc_items:
            return toc_items
        
        # 第一个项一定是一级目录
        first_item = toc_items[0]
        first_item['level'] = 1
        
        # 匹配第一个项的格式
        first_format_info = self.match_format_pattern(first_item['title'])
        if not first_format_info:
            # 如果无法匹配格式，将所有项都设为一级
            for item in toc_items[1:]:
                item['level'] = 1
            return toc_items
        
        # 获取第一个项的格式标识（template）
        first_format_key = self.get_format_key(first_format_info)
        
        # 找到所有一级目录（与第一个项同格式的项）
        level1_indices = [0]  # 第一个项
        
        for i in range(1, len(toc_items)):
            item = toc_items[i]
            item_format = self.match_format_pattern(item['title'])
            
            if item_format:
                item_format_key = self.get_format_key(item_format)
                # 比较格式标识是否相同（必须是完全相同的格式）
                if item_format_key == first_format_key:
                    item['level'] = 1
                    level1_indices.append(i)
        
        # 递归处理每个一级目录的子项
        for i in range(len(level1_indices)):
            level1_idx = level1_indices[i]
            
            # 确定子项的起始和结束索引
            if i < len(level1_indices) - 1:
                # 不是最后一个一级目录
                next_level1_idx = level1_indices[i + 1]
                child_start = level1_idx + 1
                child_end = next_level1_idx
            else:
                # 最后一个一级目录，子项到列表末尾
                child_start = level1_idx + 1
                child_end = len(toc_items)
            
            # 如果有子项，递归处理
            if child_start < child_end:
                self.identify_levels_recursive(toc_items, level=2, start_idx=child_start, end_idx=child_end)
        
        return toc_items
    
    def identify_levels_recursive(self, items, level: int, start_idx: int, end_idx: int):
        """
        递归识别目录层级（处理子项）
        
        参数:
            items: 所有目录项列表
            level: 当前层级
            start_idx: 当前处理的起始索引
            end_idx: 当前处理的结束索引（不包含）
        """
        if start_idx >= end_idx:
            return
        
        # 获取当前范围的子项
        current_items = items[start_idx:end_idx]
        if not current_items:
            return
        
        # 第一个项一定是当前层级
        first_item = current_items[0]
        first_item['level'] = level
        
        # 匹配第一个项的格式
        format_info = self.match_format_pattern(first_item['title'])
        if not format_info:
            # 如果无法匹配格式，将剩余项都设为当前层级
            for item in current_items[1:]:
                item['level'] = level
            return
        
        # 获取第一个项的格式标识
        first_format_key = self.get_format_key(format_info)
        
        # 找到所有同格式的项（同层级项）
        same_level_indices = [0]  # 第一个项
        
        for i in range(1, len(current_items)):
            item = current_items[i]
            item_format = self.match_format_pattern(item['title'])
            
            if item_format:
                item_format_key = self.get_format_key(item_format)
                # 比较格式标识是否相同（必须是完全相同的格式）
                if item_format_key == first_format_key:
                    same_level_indices.append(i)
                    item['level'] = level
        
        # 处理每个同层级项之间的子项
        for i in range(len(same_level_indices)):
            current_level_idx = start_idx + same_level_indices[i]
            current_level_item = items[current_level_idx]
            
            # 确定子项的起始和结束索引
            if i < len(same_level_indices) - 1:
                # 不是最后一个同层级项
                next_level_idx = start_idx + same_level_indices[i + 1]
                child_start = current_level_idx + 1
                child_end = next_level_idx
            else:
                # 最后一个同层级项，子项到当前范围的末尾
                child_start = current_level_idx + 1
                child_end = end_idx
            
            # 如果有子项，递归处理
            if child_start < child_end:
                # 递归处理子项，让子项自己识别层级
                self.identify_levels_recursive(items, level + 1, child_start, child_end)


