"ProcessDocumentTypes": {
  "Type": "Map",                              // Map State 선언
  "ItemsPath": "$.fileIndexes.body.collections",  // 순회할 배열 지정
  "MaxConcurrency": 2,                        // 동시 실행 수 제한
  "Parameters": {                             // 각 반복에 전달할 파라미터
    "workspace.$": "$.workspace",             // 원본 데이터에서 복사
    "file_type.$": "$$.Map.Item.Value.file_type"  // 현재 배열 요소의 값
  },
  "Iterator": {                               // 각 요소에 대해 실행할 State들
    "StartAt": "ProcessDocumentBatch",
    "States": { ... }
  }
}

{
  "StartAt": "Entr2",
  "States": {
    "Entr2": {
      "Type": "Task",
      "ResultPath": "$.fileIndexes",   // 결과를 fileIndexes에 저장
      "Next": "ProcessDocumentTypes"
    },
    "ProcessDocumentTypes": {
      "Type": "Map",
      "ItemsPath": "$.fileIndexes.body.collections",  // [{file_type, files}]
      "Iterator": {
        "StartAt": "ProcessDocumentBatch",
        "States": {
          "ProcessDocumentBatch": {
            "Type": "Map",
            "ItemsPath": "$.files",  // [{index: 0}, {index: 1}, ...]
            "MaxConcurrency": 18,
            "Iterator": {
              "StartAt": "Entr3Task",
              "States": {
                "Entr3Task": { "Next": "Entr4Task" },
                "Entr4Task": { "Next": "Entr5Task" },
                "Entr5Task": { "End": true }
              }
            }
          }
        }
      }
    }
  }
}

def request_dp(self, file_path: Path, endpoint_name: str = None) -> dict:
    # SageMaker Endpoint 호출 (Upstage Document Parse)
    m = MultipartEncoder(fields={
        'document': (file_path.name, open(file_path, 'rb')),
        'model': 'document-parse',
        'ocr': 'auto',              # OCR 자동 적용
        'coordinates': 'true',       # 좌표 정보 포함
        'output_formats': '["text"]'
    })

    response = self.runtime_sm_client.invoke_endpoint(
        EndpointName=endpoint_name,
        ContentType=m.content_type,
        Body=m.to_string()
    )
    return json.loads(response["Body"].read())

def analyze_pages(self, file_path, params):
    toc_list = []
    current_heading = None

    for page in extracted_pages:
        for element in page["elements"]:
            text = element["content"]["text"]
            category = element["category"]  # heading1, paragraph, table...

            # heading1이고 TOC 패턴에 맞으면 새 섹션 시작
            if category == "heading1" and self.check_toc_header(text):
                if current_heading:
                    toc_list.append({
                        "title": current_heading["title"],
                        "page_no": current_heading["page_no"],
                        "body": current_body  # 해당 섹션의 본문
                    })
                current_heading = {"title": text, "page_no": page_no}
                current_body = ""
            else:
                current_body += text + "\n"  # 본문에 추가

class TocExtractor(FeatureExtractor):
    def __init__(self, model_id="anthropic.claude-3-5-sonnet-20240620-v1:0"):
        self.client = boto3.client('bedrock-runtime')

    def _extract(self, text: str) -> str:
        prompt = f"""
# MISSION
- Act as a Table Of Contents(TOC) extractor
- Create a TOC Tree from the input

# RULES
- Use '#' to represent depth (max 6)
- Identifier format: 'id.id.id.' always ending with '.'
- Output markdown formatted TOC

# INPUT
{text}

# OUTPUT FORMAT

# 1. Section Title
## 1.1. Subsection
### 1.1.1. Sub-subsection

"""
        response = self.client.invoke_model(
            modelId=self.model_id,
            body=json.dumps({"messages": [{"role": "user", "content": prompt}]})
        )

{
  "source_id": "3f30285548c6668704245fc8d974da21...",
  "name": "Technical_Specification.pdf",
  "category": "Volume 4 - Technical Reference",
  "total_pages": 156,
  "pages": {
    "1": { "page_no": 1, "text": "..." },
    "2": { "page_no": 2, "text": "..." }
  },
  "toc_list": [
    { "title": "1. Introduction", "page_no": 1, "body": "..." },
    { "title": "2. Scope", "page_no": 5, "body": "..." }
  ],
  "toc_tree": {
    "identifier": "root",
    "children": [
      {
        "identifier": "1.",
        "title": "Introduction",
        "body": "...",
        "children": [...]
      }
    ]
  },
  "processing_status": "COMPLETED"
}

# 입력: 라인별로 분리된 텍스트
context = """
01.1 General Requirements
1The contractor shall...
2All materials must...
...
"""

prompt = f"""
# MISSION
- Act as a Document Analyzer
- Group lines into contextually related paragraphs

# RULES
- Each paragraph must contain enough content to understand a single context
- Related content MUST be kept together in one paragraph
- Include introductory text, structured content, and conclusions together

# OUTPUT FORMAT

    
        0
        1
    
    
        2
        ...
    

"""

def create_chunk_iterator(self, source: Source, checkpoint, checkpoint_manager):
    """TOC Tree를 순회하며 각 노드를 청킹"""
    toc_tree = source.toc_tree

    # 루트 노드 처리
    if toc_tree.get("body"):
        yield from self._process_toc_node_iterator(toc_tree, ...)

    # 자식 노드들 재귀 처리
    if "children" in toc_tree:
        for node in toc_tree["children"]:
            yield from self._process_node_and_children(node, ...)

def _process_toc_node_iterator(self, toc_node, ...):
    """단일 TOC 노드(섹션)를 청킹"""
    body_lines = toc_node.get("body", "").split('\n')

    # LLM 기반 청킹 (ContextualizedChunkingStrategy)
    chunks_buffer = list(self.chunking_strategy.chunk_text(body_lines))

    for chunk_text in chunks_buffer:
        chunk = Chunk.create(
            source_id=source.source_id,
            chunk_no=self._current_chunk_no,
            text=chunk_text,
            metadata=metadata  # 섹션 정보 포함
        )
        yield chunk

def _process_node_and_children(self, node, checkpoint, checkpoint_manager, ...):
    node_identifier = self._get_node_id(node)

    # 이미 처리된 노드인지 확인
    if checkpoint.is_node_processed(node_identifier):
        if self._verify_node_processing(source_id, node_identifier):
            return  # 이미 처리됨, 스킵

    # 노드 처리 후 체크포인트 저장
    self._save_node_results(source_id, node_identifier, results)
    checkpoint.processed_nodes[node_identifier] = datetime.now()
    checkpoint_manager.save_checkpoint(checkpoint)

class KeywordExtractor(FeatureExtractor):
    def _extract(self, document: Document, feature_repository) -> List[Feature]:
        chunk_text = feature_repository.get_feature(doc_id, "chunk_text_eng")

        prompt = f"""
# MISSION: Extract key information from ITB construction documents

# TARGET ITEMS
* Project Name, Location, Scope of Works, Time for Completion,
* Contract price, Bid Bond, Performance Bond, Technical Items...

# INPUT TEXT
{chunk_text}

# OUTPUT FORMAT

value1, value2, value3, ...

"""
        response = self.client.invoke_model(modelId="claude-3-haiku", ...)
        keywords = self._parse_response(response)  # ["Taiba IPP", "power generation", ...]

        return [Feature.create(doc_id=document.doc_id, name="keywords", value=keywords)]