/**
 * pdfIndexing.ts 순수 함수 로직 테스트
 *
 * functions에는 테스트 프레임워크가 없으므로 Jest 스타일로 작성.
 * nextapp vitest로도 실행 가능하도록 vitest/jest 양립 문법 사용.
 *
 * 테스트 항목:
 *  - Item 1  : metaDocId는 productId만 사용 (이중 prefix 없음)
 *  - Item 9  : embedWithRetry retry 로직
 *  - Item 13 : 스캔 PDF 감지 (페이지당 평균 50자 미만)
 *  - Item 19 : splitIntoChunks overlap 적용
 *  - Item 21 : 대용량 PDF(500페이지 초과) 분할 처리
 */

import { describe, it, expect, vi, beforeEach } from 'vitest';

// ============================================================
// pdfIndexing.ts 순수 함수 로직 재현
// (export되지 않으므로 동일 로직을 직접 복제하여 테스트)
// ============================================================

// 보험료/해지환급금 표 청킹 제외 패턴 (원본 동일)
const TABLE_EXCLUSION_PATTERNS = [
    /보험료\s*표/,
    /해지환급금\s*표/,
    /납입보험료.*원/,
    /연령.*남.*여/,
    /월납.*연납/,
];

function isTableContent(text: string): boolean {
    return TABLE_EXCLUSION_PATTERNS.some(p => p.test(text));
}

/**
 * Item 19: 단락 기준 청크 분할 (overlap 포함)
 * 원본 pdfIndexing.ts splitIntoChunks와 동일 로직
 */
function splitIntoChunks(text: string, maxLength = 750, overlap = 100): string[] {
    const paragraphs = text.split(/\n\n+/);
    const chunks: string[] = [];
    let current = '';

    for (const para of paragraphs) {
        // 보험료 표 내용 제외
        if (isTableContent(para)) continue;

        if ((current + para).length > maxLength && current) {
            chunks.push(current.trim());
            current = para;
        } else {
            current += (current ? '\n\n' : '') + para;
        }
    }
    if (current.trim()) chunks.push(current.trim());

    const filtered = chunks.filter(c => c.length > 50); // 50자 미만 제외

    // overlap이 0보다 크면 인접 청크 간 overlap 적용
    // 원본: prevChunk.slice(-overlap) + '\n\n' + filtered[i]
    if (overlap > 0 && filtered.length > 1) {
        for (let i = 1; i < filtered.length; i++) {
            const prevChunk = filtered[i - 1];
            const overlapText = prevChunk.slice(-overlap);
            filtered[i] = overlapText + '\n\n' + filtered[i];
        }
    }

    return filtered;
}

/**
 * Item 9: 임베딩 지수 백오프 retry 유틸 (원본 동일)
 * attempt 0 ~ maxRetries 까지 시도, 마지막 실패 시 throw
 * delay: 2^attempt * 1000ms (1초, 2초, 4초...)
 */
async function embedWithRetry(
    embedModel: { embedContent: (chunk: string) => Promise<any> },
    chunk: string,
    maxRetries = 3,
    delayFn: (ms: number) => Promise<void> = (ms) => new Promise(r => setTimeout(r, ms))
): Promise<any> {
    for (let attempt = 0; attempt <= maxRetries; attempt++) {
        try {
            return await embedModel.embedContent(chunk);
        } catch (err) {
            if (attempt === maxRetries) throw err;
            const delayMs = Math.pow(2, attempt) * 1000;
            await delayFn(delayMs);
        }
    }
}

/**
 * Item 1: metaDocId 생성 로직 재현
 * 원본: const metaDocId = productId; (productId만 사용, 이중 prefix 없음)
 */
function buildMetaDocId(productId: string): string {
    // 원본 코드: const metaDocId = productId;
    return productId;
}

/**
 * Item 21: 대용량 PDF 분할 처리 시뮬레이션
 * 500페이지 초과 시 200페이지씩 분할하여 청킹
 */
function processLargePdf(fullText: string, pageCount: number): string[] {
    let chunks: string[];
    if (pageCount > 500) {
        const pageMarkers = fullText.split(/(?=\[PAGE \d+\])/);
        const PAGE_SPLIT_SIZE = 200;
        chunks = [];
        for (let start = 0; start < pageMarkers.length; start += PAGE_SPLIT_SIZE) {
            const segmentPages = pageMarkers.slice(start, start + PAGE_SPLIT_SIZE);
            const segmentText = segmentPages.join('');
            const segmentChunks = splitIntoChunks(segmentText);
            chunks = chunks.concat(segmentChunks);
        }
    } else {
        chunks = splitIntoChunks(fullText);
    }
    return chunks;
}

// ============================================================
// 테스트
// ============================================================

describe('pdfIndexing 순수함수 로직', () => {

    // ----------------------------------------------------------
    // Item 1: metaDocId는 productId만 사용 (이중 prefix 없음)
    // ----------------------------------------------------------
    describe('Item 1 - metaDocId 통일 (productId만 사용)', () => {
        it('metaDocId는 productId와 동일', () => {
            const productId = '삼성life_퍼펙트종신_202403';
            const metaDocId = buildMetaDocId(productId);
            expect(metaDocId).toBe(productId);
        });

        it('metaDocId에 이중 prefix가 없음 (productId_ 로 시작하지 않음)', () => {
            const productId = 'kb손해_암보험_202406';
            const metaDocId = buildMetaDocId(productId);
            // 이중 prefix 형태(예: "productId_kb손해_암보험_202406")가 아닌지 확인
            expect(metaDocId).not.toMatch(/^productId_/);
            expect(metaDocId).toBe(productId);
        });

        it('companyId + productId 형태가 아님 (단순 productId)', () => {
            const companyId = '삼성life';
            const productId = '삼성life_퍼펙트종신_202403';
            const metaDocId = buildMetaDocId(productId);
            // "companyId_productId" 형태가 아닌지 확인
            expect(metaDocId).not.toBe(`${companyId}_${productId}`);
        });
    });

    // ----------------------------------------------------------
    // Item 9: embedWithRetry retry 로직
    // ----------------------------------------------------------
    describe('Item 9 - embedWithRetry retry 로직', () => {
        it('첫 번째 시도에 성공하면 retry 없이 결과 반환', async () => {
            const mockModel = {
                embedContent: vi.fn().mockResolvedValue({ embedding: { values: [0.1, 0.2] } }),
            };
            const noDelay = vi.fn().mockResolvedValue(undefined);

            const result = await embedWithRetry(mockModel, 'test chunk', 3, noDelay);

            expect(result.embedding.values).toEqual([0.1, 0.2]);
            expect(mockModel.embedContent).toHaveBeenCalledTimes(1);
            expect(noDelay).not.toHaveBeenCalled();
        });

        it('실패 후 재시도하여 성공 (2번째 시도)', async () => {
            const mockModel = {
                embedContent: vi.fn()
                    .mockRejectedValueOnce(new Error('일시적 오류'))
                    .mockResolvedValue({ embedding: { values: [0.3, 0.4] } }),
            };
            const noDelay = vi.fn().mockResolvedValue(undefined);

            const result = await embedWithRetry(mockModel, 'test chunk', 3, noDelay);

            expect(result.embedding.values).toEqual([0.3, 0.4]);
            expect(mockModel.embedContent).toHaveBeenCalledTimes(2);
            // 첫 번째 실패 후 delay 호출 확인 (2^0 * 1000 = 1000ms)
            expect(noDelay).toHaveBeenCalledWith(1000);
        });

        it('최대 재시도 횟수 초과 시 에러 throw', async () => {
            const mockModel = {
                embedContent: vi.fn().mockRejectedValue(new Error('지속적 오류')),
            };
            const noDelay = vi.fn().mockResolvedValue(undefined);
            const maxRetries = 3;

            await expect(
                embedWithRetry(mockModel, 'test chunk', maxRetries, noDelay)
            ).rejects.toThrow('지속적 오류');

            // 총 시도 횟수: attempt 0, 1, 2, 3 → 4번
            expect(mockModel.embedContent).toHaveBeenCalledTimes(maxRetries + 1);
        });

        it('지수 백오프 delay 패턴 확인 (1초, 2초, 4초)', async () => {
            const mockModel = {
                embedContent: vi.fn()
                    .mockRejectedValueOnce(new Error('오류1'))
                    .mockRejectedValueOnce(new Error('오류2'))
                    .mockRejectedValueOnce(new Error('오류3'))
                    .mockResolvedValue({ embedding: { values: [] } }),
            };
            const delayMs: number[] = [];
            const capturingDelay = (ms: number) => {
                delayMs.push(ms);
                return Promise.resolve();
            };

            await embedWithRetry(mockModel, 'chunk', 3, capturingDelay);

            // 지수 백오프: 2^0=1초, 2^1=2초, 2^2=4초
            expect(delayMs).toEqual([1000, 2000, 4000]);
        });

        it('maxRetries=0이면 재시도 없이 즉시 에러 throw', async () => {
            const mockModel = {
                embedContent: vi.fn().mockRejectedValue(new Error('즉시 실패')),
            };
            const noDelay = vi.fn().mockResolvedValue(undefined);

            await expect(
                embedWithRetry(mockModel, 'chunk', 0, noDelay)
            ).rejects.toThrow('즉시 실패');

            expect(mockModel.embedContent).toHaveBeenCalledTimes(1);
            expect(noDelay).not.toHaveBeenCalled();
        });
    });

    // ----------------------------------------------------------
    // Item 13: 스캔 PDF 감지 (페이지당 평균 50자 미만)
    // ----------------------------------------------------------
    describe('Item 13 - 스캔 PDF 감지', () => {
        it('페이지당 평균 50자 미만이면 스캔 PDF로 감지', () => {
            const fullText = 'Short text'; // 10자
            const pageCount = 10;
            const avgCharsPerPage = fullText.length / pageCount; // 1자
            expect(avgCharsPerPage).toBeLessThan(50);
        });

        it('페이지당 정확히 50자이면 스캔 PDF 아님 (경계값)', () => {
            const fullText = 'A'.repeat(500); // 500자
            const pageCount = 10;
            const avgCharsPerPage = fullText.length / pageCount; // 50자
            // 원본 조건: avgCharsPerPage < 50 이면 스캔 PDF
            expect(avgCharsPerPage).not.toBeLessThan(50);
        });

        it('정상 PDF는 스캔 감지 통과 (페이지당 충분한 텍스트)', () => {
            const fullText = 'A'.repeat(5000); // 5000자
            const pageCount = 10;
            const avgCharsPerPage = fullText.length / pageCount; // 500자
            expect(avgCharsPerPage).toBeGreaterThanOrEqual(50);
        });

        it('1페이지에 10자만 있으면 스캔 PDF 감지', () => {
            const fullText = '짧은텍스트'; // 5자
            const pageCount = 1;
            const avgCharsPerPage = pageCount > 0 ? fullText.length / pageCount : 0;
            expect(avgCharsPerPage).toBeLessThan(50);
        });

        it('pageCount가 0이면 avgCharsPerPage는 0 (스캔 PDF 감지)', () => {
            const fullText = 'some text';
            const pageCount = 0;
            const avgCharsPerPage = pageCount > 0 ? fullText.length / pageCount : 0;
            expect(avgCharsPerPage).toBeLessThan(50);
        });

        it('100페이지 PDF에 10000자 → 페이지당 100자 → 스캔 PDF 아님', () => {
            const fullText = 'A'.repeat(10000);
            const pageCount = 100;
            const avgCharsPerPage = fullText.length / pageCount; // 100자
            expect(avgCharsPerPage).toBeGreaterThanOrEqual(50);
        });
    });

    // ----------------------------------------------------------
    // Item 19: splitIntoChunks overlap 적용
    // ----------------------------------------------------------
    describe('Item 19 - 청킹 overlap 적용', () => {
        it('overlap=0이면 이전 청크 내용 미포함', () => {
            const part1 = 'A'.repeat(400);
            const part2 = 'B'.repeat(400);
            const text = part1 + '\n\n' + part2;
            const chunks = splitIntoChunks(text, 750, 0);
            expect(chunks.length).toBe(2);
            // 두 번째 청크가 첫 번째 청크 내용을 포함하지 않아야 함
            expect(chunks[1]).not.toContain('A');
        });

        it('overlap 적용 시 두 번째 청크가 첫 번째 청크 끝부분을 포함', () => {
            const part1 = 'Hello World '.repeat(70);  // ~840자
            const part2 = 'Goodbye World '.repeat(70); // ~980자
            const text = part1 + '\n\n' + part2;
            const chunks = splitIntoChunks(text, 750, 100);
            expect(chunks.length).toBe(2);
            // 두 번째 청크는 첫 번째 청크의 마지막 100자 + '\n\n' + 두 번째 청크 내용
            const firstChunkTail = chunks[0].slice(-100);
            expect(chunks[1]).toContain(firstChunkTail);
        });

        it('overlap 구분자는 \\n\\n (원본 코드 기준)', () => {
            const part1 = 'Alpha'.repeat(200); // 1000자
            const part2 = 'Beta'.repeat(200);  // 800자
            const text = part1 + '\n\n' + part2;
            const chunks = splitIntoChunks(text, 750, 50);
            expect(chunks.length).toBe(2);
            // overlap 구분자가 '\n\n' 인지 확인 (명세의 '\n...\n' 이 아닌 원본 '\n\n')
            expect(chunks[1]).toContain('\n\n');
        });

        it('50자 미만 청크는 필터링됨', () => {
            const text = 'Short\n\nAlso short text here is still small';
            const chunks = splitIntoChunks(text, 750, 0);
            // 두 단락 모두 50자 미만이므로 필터링
            expect(chunks.length).toBe(0);
        });

        it('단락이 maxLength 초과 시 분할됨', () => {
            const part1 = 'X'.repeat(400);
            const part2 = 'Y'.repeat(400);
            const part3 = 'Z'.repeat(400);
            const text = [part1, part2, part3].join('\n\n');
            const chunks = splitIntoChunks(text, 750, 0);
            // 각 단락이 400자이므로 750자 이내에서 최대 1개 단락씩 묶임
            expect(chunks.length).toBeGreaterThanOrEqual(2);
        });

        it('보험료 표 내용은 청킹에서 제외', () => {
            const normalPart = 'A'.repeat(200);
            const tablePart = '보험료 표 납입보험료 1만원'; // TABLE_EXCLUSION_PATTERNS 매칭
            const text = normalPart + '\n\n' + tablePart;
            const chunks = splitIntoChunks(text, 750, 0);
            // tablePart는 제외되어야 함
            chunks.forEach(chunk => {
                expect(chunk).not.toContain('보험료 표');
            });
        });
    });

    // ----------------------------------------------------------
    // Item 21: 대용량 PDF(500페이지 초과) 분할 처리
    // ----------------------------------------------------------
    describe('Item 21 - 대용량 PDF 200페이지씩 분할 처리', () => {
        /** 테스트용 페이지 마커가 있는 텍스트 생성 */
        function buildPagedText(pageCount: number, charsPerPage = 200): string {
            const pages: string[] = [];
            for (let i = 1; i <= pageCount; i++) {
                pages.push(`[PAGE ${i}]\n${'약관내용'.repeat(charsPerPage / 4)}`);
            }
            return pages.join('\n\n');
        }

        it('500페이지 이하이면 단일 처리 (분할 없음)', () => {
            const text = buildPagedText(100);
            const pageCount = 100;
            // 500 이하이면 processLargePdf가 단순 splitIntoChunks 호출
            const chunks = processLargePdf(text, pageCount);
            expect(chunks.length).toBeGreaterThan(0);
        });

        it('501페이지이면 200페이지씩 분할 처리', () => {
            // 501페이지 텍스트 생성 (각 페이지 충분한 텍스트)
            const text = buildPagedText(501, 200);
            const pageCount = 501;
            const chunks = processLargePdf(text, pageCount);
            // 분할 처리 후에도 청크가 생성됨
            expect(chunks.length).toBeGreaterThan(0);
        });

        it('정확히 500페이지이면 단일 처리', () => {
            const text = buildPagedText(500, 200);
            const pageCount = 500;
            const chunks500 = processLargePdf(text, pageCount);
            // 500페이지는 분할 없이 처리
            expect(chunks500.length).toBeGreaterThan(0);
        });

        it('대용량 PDF 분할 처리 결과가 단일 처리 결과와 동일한 청크 수를 가짐 (결합 동일성)', () => {
            // 작은 규모로 시뮬레이션: 600페이지 → 200페이지씩 3번 처리
            const sampleText = buildPagedText(60, 200); // 60페이지로 축소 테스트
            const pageCount = 600; // pageCount만 501 초과로 설정

            // processLargePdf는 pageCount > 500 조건으로 분기
            const chunksLarge = processLargePdf(sampleText, pageCount);
            // 단일 처리
            const chunksSingle = splitIntoChunks(sampleText);

            // 대용량 처리가 단일 처리보다 적거나 같은 청크를 생성할 수 있음
            // (분할 경계에서 청크 분리가 발생할 수 있음)
            expect(chunksLarge.length).toBeGreaterThan(0);
            expect(chunksSingle.length).toBeGreaterThan(0);
        });

        it('[PAGE N] 마커 기반으로 분할 수행', () => {
            // [PAGE N] 마커가 있어야 올바르게 분할됨
            const textWithMarkers = buildPagedText(10, 200);
            expect(textWithMarkers).toContain('[PAGE 1]');
            expect(textWithMarkers).toContain('[PAGE 10]');
        });
    });

});

// ============================================================
// structureAwareChunk 및 헬퍼 함수 로직 재현
// (export되지 않으므로 동일 로직을 직접 복제하여 테스트)
// ============================================================

const STRUCTURE_MAX_CHUNK_SIZE = 2000;
const STRUCTURE_OVERLAP_SIZE = 300;

const PROVISO_KEYWORDS_TEST = [
    '다만', '단,', '단 ', '그러나', '제외한다', '적용하지 않는다',
    '하지 아니한다', '아니한다', '제외됩니다', '적용되지 않습니다',
];

const EXCLUSION_KEYWORDS_TEST = [
    '면책', '부지급', '보장하지 아니', '보상하지 아니',
    '보장하지 않', '보상하지 않',
];

const ARTICLE_PATTERN_TEST = /(?=\n\s*제\s*[\d일이삼사오육칠팔구십백천만]+\s*조)/g;
const PARAGRAPH_PATTERN_TEST = /(?=\n\s*[①②③④⑤⑥⑦⑧⑨⑩⑪⑫⑬⑭⑮⑯⑰⑱⑲⑳⑴⑵⑶⑷⑸⑹⑺⑻⑼⑽])/g;

function mergeBlocksToSizeTest(blocks: string[], maxSize: number): string[] {
    const result: string[] = [];
    let current = '';

    for (const block of blocks) {
        const trimmed = block.trim();
        if (!trimmed) continue;
        if (isTableContent(trimmed)) continue;

        if (current && (current + '\n' + trimmed).length > maxSize) {
            result.push(current.trim());
            current = trimmed;
        } else {
            current += (current ? '\n' : '') + trimmed;
        }
    }
    if (current.trim()) result.push(current.trim());
    return result;
}

function splitBySubPatternsTest(text: string, maxSize: number): string[] {
    const SUB_PATTERNS = [
        /(?=\n\s*[가나다라마바사아자차카타파하]\s*\.)/g,
        /(?=\n\s*\(\d+\))/g,
        /(?=\n\s*\d+\.\s)/g,
    ];

    for (const pattern of SUB_PATTERNS) {
        const blocks = text.split(pattern);
        if (blocks.length > 1) {
            return mergeBlocksToSizeTest(blocks, maxSize);
        }
    }

    const result: string[] = [];
    for (let i = 0; i < text.length; i += maxSize) {
        const slice = text.slice(i, i + maxSize).trim();
        if (slice) result.push(slice);
    }
    return result;
}

function mergeProvisoclausesTest(chunks: string[], keywords: string[]): string[] {
    return chunks.map(chunk => {
        const sentences = chunk.split(/(?<=[\.\]\)。])\s+(?=[^\s])/);
        const merged: string[] = [];

        for (const sentence of sentences) {
            const startsWithProviso = keywords.some(kw => {
                const idx = sentence.indexOf(kw);
                return idx >= 0 && idx < 30;
            });

            if (startsWithProviso && merged.length > 0) {
                merged[merged.length - 1] += ' ' + sentence.trim();
            } else {
                merged.push(sentence);
            }
        }

        return merged.join(' ').trim();
    });
}

function mergeExclusionBlocksTest(chunks: string[], keywords: string[]): string[] {
    const isExclusionChunk = (c: string) => keywords.some(kw => c.includes(kw));

    const result: string[] = [];
    let i = 0;

    while (i < chunks.length) {
        if (!isExclusionChunk(chunks[i])) {
            result.push(chunks[i]);
            i++;
            continue;
        }

        let merged = chunks[i];
        let j = i + 1;

        while (j < chunks.length && isExclusionChunk(chunks[j])) {
            merged += '\n\n' + chunks[j];
            j++;
        }

        result.push(merged.trim());
        i = j;
    }

    return result;
}

function structureAwareChunkTest(text: string): string[] {
    if (!text || text.trim().length < 100) return [];

    const articleBlocks = text.split(ARTICLE_PATTERN_TEST);

    const hasArticles = articleBlocks.some(b =>
        /제\s*[\d일이삼사오육칠팔구십백천만]+\s*조/.test(b)
    );
    if (!hasArticles) return [];

    let rawChunks: string[] = [];

    for (const block of articleBlocks) {
        const trimmed = block.trim();
        if (!trimmed) continue;

        if (isTableContent(trimmed)) continue;

        if (trimmed.length <= STRUCTURE_MAX_CHUNK_SIZE) {
            rawChunks.push(trimmed);
        } else {
            const paragraphBlocks = trimmed.split(PARAGRAPH_PATTERN_TEST);

            if (paragraphBlocks.length <= 1) {
                const subBlocks = splitBySubPatternsTest(trimmed, STRUCTURE_MAX_CHUNK_SIZE);
                rawChunks = rawChunks.concat(subBlocks);
            } else {
                const merged = mergeBlocksToSizeTest(paragraphBlocks, STRUCTURE_MAX_CHUNK_SIZE);
                rawChunks = rawChunks.concat(merged);
            }
        }
    }

    rawChunks = mergeProvisoclausesTest(rawChunks, PROVISO_KEYWORDS_TEST);
    rawChunks = mergeExclusionBlocksTest(rawChunks, EXCLUSION_KEYWORDS_TEST);

    const filtered = rawChunks.filter(c => c.trim().length > 50);

    if (filtered.length === 0) return [];

    const withOverlap: string[] = [];
    for (let i = 0; i < filtered.length; i++) {
        let chunk = filtered[i];

        if (i > 0) {
            const prevTail = filtered[i - 1].slice(-STRUCTURE_OVERLAP_SIZE);
            chunk = prevTail + '\n\n' + chunk;
        }

        if (i < filtered.length - 1) {
            const nextHead = filtered[i + 1].slice(0, STRUCTURE_OVERLAP_SIZE);
            chunk = chunk + '\n\n' + nextHead;
        }

        withOverlap.push(chunk);
    }

    return withOverlap;
}

// ============================================================
// structureAwareChunk 테스트
// ============================================================

describe('structureAwareChunk 구조 인식 청킹', () => {

    // ----------------------------------------------------------
    // 테스트 1: "제X조" 패턴으로 조항 경계 분할
    // ----------------------------------------------------------
    describe('테스트 1 - "제X조" 패턴으로 조항 경계 분할', () => {
        it('2개 조항이 각각 별도 청크로 분할됨', () => {
            const text = [
                '제1조 (목적)',
                '이 약관은 피보험자에게 발생한 질병이나 상해로 인한 손해를 보상하는 것을 목적으로 합니다.',
                '이 약관에 따른 보험계약은 보험회사와 보험계약자 간의 계약에 따라 성립됩니다.',
                '',
                '제2조 (용어의 정의)',
                '이 약관에서 사용하는 용어의 정의는 다음과 같습니다.',
                '피보험자란 보험사고 발생의 객체가 되는 사람을 말합니다.',
            ].join('\n');

            const chunks = structureAwareChunkTest(text);

            expect(chunks.length).toBeGreaterThanOrEqual(2);
            expect(chunks.some(c => c.includes('제1조'))).toBe(true);
            expect(chunks.some(c => c.includes('제2조'))).toBe(true);
        });
    });

    // ----------------------------------------------------------
    // 테스트 2: 2000자 초과 조항 → 항(①②③) 단위 2차 분할
    // ----------------------------------------------------------
    describe('테스트 2 - 2000자 초과 조항은 항 단위로 2차 분할', () => {
        it('2500자 이상 조항이 ①②③ 경계에서 2개 이상 청크로 분할됨', () => {
            // 한글 문자 기준으로 2500자 이상이 되도록 충분히 반복
            const para1 = '가입자가 질병으로 인하여 병원에 입원하거나 통원 치료를 받은 경우에 해당 비용을 보상합니다. 보험가입금액 한도 내에서 실제 발생한 의료비를 지급합니다. '.repeat(12);
            const para2 = '선천성 질환, 자해, 전쟁, 업무상 재해 등 면책 사유에 해당하는 경우는 제외합니다. 보험계약 체결 전에 이미 진단 확정된 질병은 보장 대상에서 제외됩니다. '.repeat(12);
            const para3 = '보험계약자가 별도로 특약을 가입한 경우에는 해당 특약의 약관에서 정하는 바에 따라 보험금이 지급될 수 있습니다. 특약의 내용은 별도로 정합니다. '.repeat(8);

            const body =
                '① 보험회사는 다음 각 호의 어느 하나에 해당하는 사유로 보험금을 지급합니다. ' + para1
                + '\n② 제1항에도 불구하고 다음 각 호에 해당하는 경우에는 보험금을 지급하지 않습니다. ' + para2
                + '\n③ 제2항의 규정에도 불구하고 ' + para3;

            const text = '\n제1조 (보장내용)\n' + body;

            expect(text.length).toBeGreaterThan(2500);

            const chunks = structureAwareChunkTest(text);

            expect(chunks.length).toBeGreaterThanOrEqual(2);
        });
    });

    // ----------------------------------------------------------
    // 테스트 3: 단서조항 보존 ("다만" 키워드)
    // ----------------------------------------------------------
    describe('테스트 3 - 단서조항("다만") 보존', () => {
        it('"다만" 포함 문장이 이전 문장과 동일 청크에 존재', () => {
            // structureAwareChunk는 100자 이상이어야 처리됨
            const text = [
                '제1조 (보장내용)',
                '보험회사는 피보험자에게 발생한 질병으로 인한 입원 의료비를 보장합니다. '
                + '입원 기간 중 발생한 병원비, 수술비, 검사비 등 실제 소요된 비용을 보상합니다.',
                '다만 면책사항에 해당하는 경우에는 보장하지 않습니다.',
            ].join('\n');

            const chunks = structureAwareChunkTest(text);

            expect(chunks.length).toBeGreaterThan(0);
            // "다만"이 포함된 청크에 "보장합니다"도 함께 존재해야 함
            const provisoChunk = chunks.find(c => c.includes('다만'));
            expect(provisoChunk).toBeDefined();
            expect(provisoChunk).toContain('보장합니다');
        });
    });

    // ----------------------------------------------------------
    // 테스트 4: 면책/부지급 블록 강제 병합
    // ----------------------------------------------------------
    describe('테스트 4 - 면책/부지급 블록 강제 병합', () => {
        it('연속된 2개의 면책 조항이 하나의 청크로 병합됨', () => {
            const text = [
                '제3조 (면책사항)',
                '보험회사는 다음 각 호의 사유로 인한 손해에 대하여 면책합니다.',
                '고의, 자살, 전쟁, 내란, 폭동으로 인한 경우는 보장에서 제외됩니다.',
                '',
                '제4조 (면책사항 추가)',
                '면책 범위에 추가하여 다음 각 호에 해당하는 경우에도 보험금을 지급하지 않습니다.',
                '직업, 직무, 동호회 활동 중 발생한 손해는 면책입니다.',
            ].join('\n');

            const chunks = structureAwareChunkTest(text);

            // 면책 키워드를 포함하는 두 조항이 하나의 청크로 병합되어야 함
            const exclusionChunks = chunks.filter(c =>
                c.includes('면책') && c.includes('제3조') && c.includes('제4조')
            );
            expect(exclusionChunks.length).toBeGreaterThanOrEqual(1);
        });
    });

    // ----------------------------------------------------------
    // 테스트 5: 양방향 Overlap 300자 적용
    // ----------------------------------------------------------
    describe('테스트 5 - 양방향 Overlap 300자 적용', () => {
        it('2번째 청크에 1번째 청크 뒤 300자 + 3번째 청크 앞 300자가 포함됨', () => {
            // 각 조항이 300~500자가 되도록 구성
            const article1Body = '제1조 이 약관은 피보험자의 생명 또는 신체에 관한 보험사고가 발생한 경우 보험수익자에게 약정한 보험금을 지급함으로써 피보험자와 그 가족의 경제적 안정을 도모하는 것을 목적으로 합니다. 이 약관에서 사용하는 중요한 용어는 다음과 같이 정의합니다. 보험계약자는 보험회사와 계약을 체결하고 보험료를 납입할 의무를 지는 사람을 말합니다.';
            const article2Body = '제2조 보험회사는 보험계약자로부터 보험료를 받고 피보험자에게 보험사고가 발생한 경우 보험수익자에게 보험금을 지급합니다. 보험금 지급 사유가 발생하면 보험계약자 또는 보험수익자는 지체 없이 보험회사에 통지하여야 합니다. 보험금 청구 시 필요한 서류는 진단서, 진료비 영수증, 입퇴원 확인서 등입니다.';
            const article3Body = '제3조 보험계약의 성립을 위해서는 보험계약자의 청약과 보험회사의 승낙이 필요합니다. 보험회사는 청약을 받은 날로부터 30일 이내에 승낙 또는 거절의 통지를 하여야 합니다. 보험계약이 성립된 경우 보험증권을 교부하고 보험료를 영수합니다. 보험기간은 보험증권에 기재된 보험기간 개시일부터 만료일까지입니다.';

            const text = '\n' + article1Body + '\n' + article2Body + '\n' + article3Body;

            const chunks = structureAwareChunkTest(text);

            // 3개 청크가 생성되어야 overlap 검증 가능
            expect(chunks.length).toBeGreaterThanOrEqual(3);

            if (chunks.length >= 3) {
                // 2번째 청크(인덱스 1)는 1번째 청크(인덱스 0) 끝 300자를 앞에 포함해야 함
                const firstChunkTail = chunks[0].slice(-STRUCTURE_OVERLAP_SIZE);
                expect(chunks[1]).toContain(firstChunkTail);

                // 2번째 청크(인덱스 1)는 3번째 청크(인덱스 2) 앞 300자를 뒤에 포함해야 함
                const thirdChunkHead = chunks[2].slice(0, STRUCTURE_OVERLAP_SIZE);
                expect(chunks[1]).toContain(thirdChunkHead);
            }
        });
    });

    // ----------------------------------------------------------
    // 테스트 6: "제X조" 패턴 없으면 빈 배열 반환 (폴백 트리거)
    // ----------------------------------------------------------
    describe('테스트 6 - 조항 패턴 없으면 빈 배열 반환', () => {
        it('조항 패턴 없는 일반 텍스트는 빈 배열 반환', () => {
            const text = '이것은 일반적인 텍스트입니다. 조항 번호가 없는 문서입니다. '
                + '보험 약관 형식이 아닌 일반 안내문입니다. '
                + '특별한 구조 없이 작성된 내용입니다. '.repeat(5);

            const chunks = structureAwareChunkTest(text);

            expect(chunks).toEqual([]);
        });

        it('100자 미만 짧은 텍스트도 빈 배열 반환', () => {
            const text = '제1조 짧은 내용';

            const chunks = structureAwareChunkTest(text);

            expect(chunks).toEqual([]);
        });
    });

    // ----------------------------------------------------------
    // 테스트 7: isTableContent 표 내용 제외
    // ----------------------------------------------------------
    describe('테스트 7 - isTableContent 표 내용 제외', () => {
        it('보험료 표 내용이 청크에 포함되지 않음', () => {
            const tableContent = '보험료 표\n연령 남 여\n30세 10000원 9000원\n40세 15000원 14000원';
            const text = [
                '제1조 (목적)',
                '이 약관은 피보험자의 생명에 관한 보험사고 발생 시 보험금을 지급하는 것을 목적으로 합니다.',
                tableContent,
                '제2조 (보험금 지급)',
                '보험회사는 피보험자에게 보험사고가 발생한 경우 약정한 보험금을 지급합니다.',
            ].join('\n\n');

            const chunks = structureAwareChunkTest(text);

            chunks.forEach(chunk => {
                expect(chunk).not.toContain('보험료 표\n연령 남 여');
            });
        });
    });

    // ----------------------------------------------------------
    // 테스트 8: [PAGE N] 마커 보존
    // ----------------------------------------------------------
    describe('테스트 8 - [PAGE N] 마커 보존', () => {
        it('입력에 [PAGE 1] 마커가 있으면 결과 청크에 포함됨', () => {
            // [PAGE N] 마커를 조항 본문 내부에 포함시켜야 50자 이상 청크에 유지됨
            // ARTICLE_PATTERN은 '\n제X조' 앞에서 분할하므로, [PAGE N]은 조항 텍스트 안에 위치해야 함
            const text = [
                '[PAGE 1]',
                '제1조 (목적) [PAGE 1]',
                '이 약관은 피보험자의 생명 또는 신체에 관한 보험사고가 발생한 경우 보험수익자에게 약정한 보험금을 지급하는 것을 목적으로 합니다.',
                '보험계약자는 이 약관의 내용을 충분히 이해하고 보험계약을 체결하여야 합니다.',
            ].join('\n');

            const chunks = structureAwareChunkTest(text);

            expect(chunks.length).toBeGreaterThan(0);
            const hasPageMarker = chunks.some(c => c.includes('[PAGE 1]'));
            expect(hasPageMarker).toBe(true);
        });
    });

    // ----------------------------------------------------------
    // 테스트 9: splitBySubPatterns 가./나. 패턴 분할
    // ----------------------------------------------------------
    describe('테스트 9 - splitBySubPatterns 가./나. 패턴 분할', () => {
        it('2500자 텍스트에서 가./나./다. 경계로 분할됨', () => {
            const baseText = '제1조 (보장내용) 보험회사는 다음 각 호에 해당하는 경우 보험금을 지급합니다.\n';
            // 한글 문자 기준 충분히 반복하여 2500자 초과
            const gaSection = '가. 질병으로 인한 입원 의료비: 피보험자가 질병으로 인하여 병원에 입원하여 치료를 받은 경우 실제 발생한 의료비를 지급합니다. '
                + '입원 기간 동안 발생한 입원비, 수술비, 검사비, 약제비 등을 포함합니다. '.repeat(25);
            const naSection = '\n나. 상해로 인한 입원 의료비: 피보험자가 우연한 외래 사고로 인한 상해로 병원에 입원하여 치료를 받은 경우 실제 발생한 의료비를 지급합니다. '
                + '골절, 화상, 외상 등으로 인한 의료비가 포함됩니다. '.repeat(25);
            const daSection = '\n다. 통원 의료비: 피보험자가 질병 또는 상해로 병원에 통원하여 외래 치료를 받거나 처방전을 발급받은 경우 해당 의료비를 지급합니다. '
                + '통원 1회당 공제금액을 차감한 후 지급합니다. '.repeat(25);

            const fullText = baseText + gaSection + naSection + daSection;

            expect(fullText.length).toBeGreaterThan(2500);

            const result = splitBySubPatternsTest(fullText, STRUCTURE_MAX_CHUNK_SIZE);

            // 가/나/다 경계에서 분할되어 2개 이상의 블록이 생성됨
            expect(result.length).toBeGreaterThanOrEqual(2);
        });
    });

    // ----------------------------------------------------------
    // 테스트 10: mergeExclusionBlocks 연속 면책 블록 병합
    // ----------------------------------------------------------
    describe('테스트 10 - mergeExclusionBlocks 연속 면책 블록 병합', () => {
        it('연속되는 면책 청크 2개는 병합되고 일반 청크는 별도 유지', () => {
            const chunks = [
                '면책조항 내용1: 보험회사는 고의, 자살, 전쟁으로 인한 손해에 대해 면책합니다.',
                '부지급 사유 내용2: 다음 각 호에 해당하는 경우 보험금을 부지급합니다.',
                '일반 조항: 보험계약자는 보험료를 납입 기일 내에 납입하여야 합니다.',
            ];

            const result = mergeExclusionBlocksTest(chunks, EXCLUSION_KEYWORDS_TEST);

            // 처음 2개(면책/부지급)는 병합되어 1개가 되고, 3번째는 별도 유지
            expect(result.length).toBe(2);
            expect(result[0]).toContain('면책조항 내용1');
            expect(result[0]).toContain('부지급 사유 내용2');
            expect(result[1]).toContain('일반 조항');
        });

        it('면책 청크가 없으면 입력 그대로 반환', () => {
            const chunks = [
                '제1조 일반 약관 내용입니다.',
                '제2조 보험금 지급 기준입니다.',
                '제3조 계약 해지 절차입니다.',
            ];

            const result = mergeExclusionBlocksTest(chunks, EXCLUSION_KEYWORDS_TEST);

            expect(result.length).toBe(3);
            expect(result).toEqual(chunks);
        });

        it('모든 청크가 면책 키워드를 포함하면 하나로 병합됨', () => {
            const chunks = [
                '면책사항 1: 고의로 인한 손해는 보장하지 않습니다.',
                '면책사항 2: 전쟁으로 인한 손해도 면책입니다.',
                '면책사항 3: 자해로 인한 경우도 부지급 사유입니다.',
            ];

            const result = mergeExclusionBlocksTest(chunks, EXCLUSION_KEYWORDS_TEST);

            expect(result.length).toBe(1);
            expect(result[0]).toContain('면책사항 1');
            expect(result[0]).toContain('면책사항 2');
            expect(result[0]).toContain('면책사항 3');
        });
    });

});

// ============================================================
// CL-9: parseAppendixToMarkdownTable 로직 테스트
// ============================================================

/**
 * parseAppendixToMarkdownTable 로직 재현 (export 함수지만 모킹 환경에서 테스트)
 */
function parseAppendixToMarkdownTable(text: string): { markdown: string; parsedTable: { headers: string[]; rows: string[][] } } | null {
    const cleanText = text.replace(/\[PAGE \d+\]/g, '').trim();
    if (!cleanText) return null;

    const lines = cleanText.split('\n').map(l => l.trim()).filter(l => l.length > 0);
    if (lines.length < 2) return null;

    const delimiter = /\t|  +/;

    const splitLines = lines.map(line => line.split(delimiter).map(cell => cell.trim()).filter(cell => cell.length > 0));
    const multiColLines = splitLines.filter(cols => cols.length >= 2);

    if (multiColLines.length < lines.length * 0.5) return null;

    const headerIdx = splitLines.findIndex(cols => cols.length >= 2);
    if (headerIdx === -1) return null;

    const headers = splitLines[headerIdx];
    const colCount = headers.length;

    const rows: string[][] = [];
    for (let i = headerIdx + 1; i < splitLines.length; i++) {
        const cols = [...splitLines[i]];
        if (cols.length < 2) continue;
        if (cols.length < colCount) {
            while (cols.length < colCount) cols.push('');
        } else if (cols.length > colCount) {
            const extra = cols.splice(colCount - 1);
            cols.push(extra.join(' '));
        }
        rows.push(cols);
    }

    if (rows.length === 0) return null;

    const headerLine = '| ' + headers.join(' | ') + ' |';
    const separatorLine = '| ' + headers.map(() => '---').join(' | ') + ' |';
    const rowLines = rows.map(row => '| ' + row.join(' | ') + ' |');
    const markdown = [headerLine, separatorLine, ...rowLines].join('\n');

    return { markdown, parsedTable: { headers, rows } };
}

describe('CL-9: parseAppendixToMarkdownTable 별표 테이블 파싱', () => {

    it('탭 구분 테이블을 마크다운 테이블로 변환', () => {
        const text = '구분\t수술명\t수술코드\n1종\t제왕절개\tO001\n2종\t맹장수술\tO002\n3종\t담낭제거\tO003';
        const result = parseAppendixToMarkdownTable(text);

        expect(result).not.toBeNull();
        expect(result!.parsedTable.headers).toEqual(['구분', '수술명', '수술코드']);
        expect(result!.parsedTable.rows).toHaveLength(3);
        expect(result!.markdown).toContain('| 구분 | 수술명 | 수술코드 |');
        expect(result!.markdown).toContain('| 1종 | 제왕절개 | O001 |');
    });

    it('공백 구분(2+spaces) 테이블을 마크다운 테이블로 변환', () => {
        const text = '등급    장해내용    지급률\n1급    양안 시력상실    100%\n2급    한안 시력상실    80%';
        const result = parseAppendixToMarkdownTable(text);

        expect(result).not.toBeNull();
        expect(result!.parsedTable.headers).toEqual(['등급', '장해내용', '지급률']);
        expect(result!.parsedTable.rows).toHaveLength(2);
    });

    it('[PAGE N] 마커가 제거되고 정상 파싱', () => {
        const text = '[PAGE 5]\n구분\t내용\n1종\t입원\n2종\t통원';
        const result = parseAppendixToMarkdownTable(text);

        expect(result).not.toBeNull();
        expect(result!.markdown).not.toContain('[PAGE');
        expect(result!.parsedTable.rows).toHaveLength(2);
    });

    it('단일 열 텍스트는 테이블로 변환 실패 → null', () => {
        const text = '이것은 일반 텍스트입니다.\n별표 내용이지만 테이블 형태가 아닙니다.\n단순 문장 나열입니다.';
        const result = parseAppendixToMarkdownTable(text);

        expect(result).toBeNull();
    });

    it('빈 문자열 입력 → null', () => {
        expect(parseAppendixToMarkdownTable('')).toBeNull();
    });

    it('1줄만 있는 텍스트 → null (최소 헤더+1행 필요)', () => {
        expect(parseAppendixToMarkdownTable('구분\t내용')).toBeNull();
    });

    it('열 수가 다른 행은 정규화됨 (부족하면 빈 문자열)', () => {
        const text = '구분\t수술명\t코드\n1종\t제왕절개\tO001\n2종\t맹장수술';
        const result = parseAppendixToMarkdownTable(text);

        expect(result).not.toBeNull();
        // 2종 행의 코드 열이 빈 문자열로 채워져야 함
        const lastRow = result!.parsedTable.rows[result!.parsedTable.rows.length - 1];
        expect(lastRow).toHaveLength(3);
    });

    it('마크다운 테이블에 구분선 포함', () => {
        const text = '구분\t내용\n1\tA\n2\tB';
        const result = parseAppendixToMarkdownTable(text);

        expect(result).not.toBeNull();
        expect(result!.markdown).toContain('| --- | --- |');
    });
});