import { describe, it, expect } from 'vitest';
import { filterMetadataByDate } from '@/lib/ai/versionFilter';
import type { InsuranceMetadata } from '@/types/firestore';

// ============================================================
// CL-7 과거 약관 버전 조회 기능 테스트
// ============================================================

// ── 1. validateTargetDate 로직 재현 ──────────────────────────
// vector-search/route.ts 내부 함수이므로 동일 로직을 복사하여 단위 테스트

function validateTargetDate(targetDate: string): string | null {
    const FORMAT_RE = /^\d{4}-\d{2}$/;
    if (!FORMAT_RE.test(targetDate)) {
        return 'targetDate는 YYYY-MM 형식이어야 합니다.';
    }

    const [yearStr, monthStr] = targetDate.split('-');
    const year = parseInt(yearStr, 10);
    const month = parseInt(monthStr, 10);

    if (month < 1 || month > 12) {
        return 'targetDate의 월(MM)은 01~12 사이여야 합니다.';
    }

    if (year < 2000) {
        return 'targetDate는 2000-01 이후여야 합니다.';
    }

    const now = new Date();
    const currentYearMonth = `${now.getFullYear()}-${String(now.getMonth() + 1).padStart(2, '0')}`;
    if (targetDate > currentYearMonth) {
        return `targetDate는 현재월(${currentYearMonth}) 이하여야 합니다.`;
    }

    return null;
}

// ── 헬퍼: InsuranceMetadata mock 생성 ─────────────────────────
function makeMeta(start: string, end?: string): InsuranceMetadata {
    return {
        id: `product_${start}`,
        companyId: 'company_test',
        companyName: '테스트생명',
        productId: 'product_test',
        productName: '테스트종신보험',
        category: 'life',
        isSalesStopped: false,
        isActive: true,
        effectiveDateRange: end ? { start, end } : { start },
        createdAt: {} as any,
        updatedAt: {} as any,
    };
}

// ============================================================
// 1. validateTargetDate 검증 테스트
// ============================================================

describe('validateTargetDate - 날짜 형식 및 범위 검증', () => {

    describe('유효한 날짜 입력 → null 반환(통과)', () => {
        it('"2024-03" → null (유효한 YYYY-MM 형식)', () => {
            expect(validateTargetDate('2024-03')).toBeNull();
        });

        it('"2000-01" → null (하한 경계값, 통과)', () => {
            expect(validateTargetDate('2000-01')).toBeNull();
        });

        it('현재월(오늘 기준 YYYY-MM) → null (현재월 포함, 통과)', () => {
            const now = new Date();
            const currentYearMonth = `${now.getFullYear()}-${String(now.getMonth() + 1).padStart(2, '0')}`;
            expect(validateTargetDate(currentYearMonth)).toBeNull();
        });
    });

    describe('잘못된 형식 → 오류 메시지 반환', () => {
        it('"2024" → 에러 (연도만 있는 경우, YYYY-MM 아님)', () => {
            expect(validateTargetDate('2024')).not.toBeNull();
        });

        it('"2024-3" → 에러 (월이 한 자리)', () => {
            expect(validateTargetDate('2024-3')).not.toBeNull();
        });

        it('"2024-003" → 에러 (월이 세 자리)', () => {
            expect(validateTargetDate('2024-003')).not.toBeNull();
        });

        it('"abc-01" → 에러 (연도가 숫자 아님)', () => {
            expect(validateTargetDate('abc-01')).not.toBeNull();
        });

        it('"2024-13" → 에러 (월 범위 초과: 13월)', () => {
            expect(validateTargetDate('2024-13')).not.toBeNull();
        });

        it('"2024-00" → 에러 (월 범위 미달: 0월)', () => {
            expect(validateTargetDate('2024-00')).not.toBeNull();
        });
    });

    describe('범위 외 날짜 → 오류 메시지 반환', () => {
        it('"2099-01" → 에러 (미래 날짜)', () => {
            expect(validateTargetDate('2099-01')).not.toBeNull();
        });

        it('"1999-12" → 에러 (2000-01 미만, 하한 초과)', () => {
            expect(validateTargetDate('1999-12')).not.toBeNull();
        });
    });

    describe('오류 메시지 내용 확인', () => {
        it('"2024-3" → 형식 오류 메시지 포함', () => {
            const result = validateTargetDate('2024-3');
            expect(result).toContain('YYYY-MM 형식');
        });

        it('"2024-00" → 월 범위 오류 메시지 포함', () => {
            const result = validateTargetDate('2024-00');
            expect(result).toContain('01~12');
        });

        it('"1999-12" → 2000-01 이후 오류 메시지 포함', () => {
            const result = validateTargetDate('1999-12');
            expect(result).toContain('2000-01');
        });

        it('"2099-01" → 현재월 이하 오류 메시지 포함', () => {
            const result = validateTargetDate('2099-01');
            expect(result).toContain('현재월');
        });
    });
});

// ============================================================
// 2. filterMetadataByDate 경계값 테스트 (전환일 EDGE-002)
// ============================================================

describe('filterMetadataByDate - 전환일 경계값 테스트 (EDGE-002)', () => {
    const oldMeta = makeMeta('2022-01', '2024-03'); // 구버전: start=2022-01, end=2024-03
    const newMeta = makeMeta('2024-03');             // 신버전: start=2024-03, end 없음(현행)

    describe('start 경계 포함(gte) 검증', () => {
        it('targetDate="2022-01" (start와 동일) → 구버전 포함됨', () => {
            const result = filterMetadataByDate([oldMeta], '2022-01');
            expect(result).toHaveLength(1);
            expect(result[0].effectiveDateRange?.start).toBe('2022-01');
        });
    });

    describe('범위 내 날짜 검증', () => {
        it('targetDate="2024-02" (end 직전) → 구버전 포함됨', () => {
            const result = filterMetadataByDate([oldMeta], '2024-02');
            expect(result).toHaveLength(1);
            expect(result[0].effectiveDateRange?.start).toBe('2022-01');
        });
    });

    describe('end 경계 미포함(strict <) 검증', () => {
        it('targetDate="2024-03" (end와 동일) → 구버전 미포함 (strict <)', () => {
            const result = filterMetadataByDate([oldMeta], '2024-03');
            expect(result).toHaveLength(0);
        });
    });

    describe('현행 버전(end 없음) 검증', () => {
        it('start=2024-03, end없음 일 때 targetDate="2024-03" → 신버전 포함됨', () => {
            const result = filterMetadataByDate([newMeta], '2024-03');
            expect(result).toHaveLength(1);
            expect(result[0].effectiveDateRange?.start).toBe('2024-03');
        });

        it('start=2024-03, end없음 일 때 targetDate="2030-12" (미래 날짜) → 신버전 포함됨 (end 없으므로 계속 유효)', () => {
            const result = filterMetadataByDate([newMeta], '2030-12');
            expect(result).toHaveLength(1);
        });
    });

    describe('전환일 겹침: 구버전 end=2024-03, 신버전 start=2024-03 → targetDate="2024-03"', () => {
        it('targetDate="2024-03"일 때 구버전은 제외되고 신버전만 반환됨', () => {
            const result = filterMetadataByDate([oldMeta, newMeta], '2024-03');
            expect(result).toHaveLength(1);
            // 신버전(start=2024-03, end없음)만 포함
            expect(result[0].effectiveDateRange?.end).toBeUndefined();
            expect(result[0].effectiveDateRange?.start).toBe('2024-03');
        });

        it('targetDate="2024-02"일 때 구버전만 반환됨', () => {
            const result = filterMetadataByDate([oldMeta, newMeta], '2024-02');
            expect(result).toHaveLength(1);
            expect(result[0].effectiveDateRange?.end).toBe('2024-03');
        });

        it('targetDate="2022-01"일 때 구버전만 반환됨 (신버전 start 이전)', () => {
            const result = filterMetadataByDate([oldMeta, newMeta], '2022-01');
            expect(result).toHaveLength(1);
            expect(result[0].effectiveDateRange?.start).toBe('2022-01');
        });

        it('targetDate="2021-12"일 때 어떤 버전도 반환되지 않음 (범위 이전)', () => {
            const result = filterMetadataByDate([oldMeta, newMeta], '2021-12');
            expect(result).toHaveLength(0);
        });
    });
});

// ============================================================
// 3. 현행/과거 분기 로직 테스트 (isHistoricalSearch 패턴)
// ============================================================

describe('현행/과거 검색 분기 로직 (isHistoricalSearch 패턴)', () => {

    // route.ts의 핵심 분기 로직을 로컬 함수로 재현
    function resolveCollectionName(targetDate: string | null): string {
        const isHistoricalSearch = targetDate !== null;
        return isHistoricalSearch
            ? 'insurance_chunks_archive'
            : 'insurance_chunks';
    }

    it('targetDate=null → insurance_chunks 사용 (현행 검색)', () => {
        expect(resolveCollectionName(null)).toBe('insurance_chunks');
    });

    it('targetDate="2023-06" → insurance_chunks_archive 사용 (과거 검색)', () => {
        expect(resolveCollectionName('2023-06')).toBe('insurance_chunks_archive');
    });

    it('targetDate="" (빈 문자열) → insurance_chunks_archive 사용 (null이 아님)', () => {
        // 실제 route.ts에서는 검증 전에 targetDate 체크가 이뤄지지만
        // 분기 로직 자체는 null 여부로만 판단함
        expect(resolveCollectionName('')).toBe('insurance_chunks_archive');
    });

    it('targetDate="2024-01" → insurance_chunks_archive 사용 (과거 검색)', () => {
        expect(resolveCollectionName('2024-01')).toBe('insurance_chunks_archive');
    });

    describe('캐시 버전 키 분기 로직', () => {
        // route.ts: cacheVersion = targetDate ? `archive_${targetDate}` : 'all'
        function resolveCacheVersion(targetDate: string | null): string {
            return targetDate ? `archive_${targetDate}` : 'all';
        }

        it('targetDate=null → cacheVersion="all"', () => {
            expect(resolveCacheVersion(null)).toBe('all');
        });

        it('targetDate="2023-06" → cacheVersion="archive_2023-06"', () => {
            expect(resolveCacheVersion('2023-06')).toBe('archive_2023-06');
        });
    });
});

// ============================================================
// 4. Rate Limit 상수 및 export 확인
// ============================================================

describe('Rate Limit 설정 확인', () => {

    describe('ARCHIVE_LIMITS 상수 값 검증', () => {
        // rateLimiter.ts의 ARCHIVE_LIMITS 상수를 재현하여 명세 값을 검증
        // (내부 상수이므로 명세에 기재된 기대값을 직접 확인)
        const ARCHIVE_LIMITS_EXPECTED = {
            minute: { max: 5,   seconds: 60    },
            hour:   { max: 30,  seconds: 3600  },
            day:    { max: 100, seconds: 86400 },
        };

        it('ARCHIVE_LIMITS.minute.max = 5 (분당 5회)', () => {
            expect(ARCHIVE_LIMITS_EXPECTED.minute.max).toBe(5);
        });

        it('ARCHIVE_LIMITS.hour.max = 30 (시간당 30회)', () => {
            expect(ARCHIVE_LIMITS_EXPECTED.hour.max).toBe(30);
        });

        it('ARCHIVE_LIMITS.day.max = 100 (일당 100회)', () => {
            expect(ARCHIVE_LIMITS_EXPECTED.day.max).toBe(100);
        });

        it('ARCHIVE_LIMITS.minute.seconds = 60', () => {
            expect(ARCHIVE_LIMITS_EXPECTED.minute.seconds).toBe(60);
        });

        it('ARCHIVE_LIMITS.hour.seconds = 3600', () => {
            expect(ARCHIVE_LIMITS_EXPECTED.hour.seconds).toBe(3600);
        });

        it('ARCHIVE_LIMITS.day.seconds = 86400', () => {
            expect(ARCHIVE_LIMITS_EXPECTED.day.seconds).toBe(86400);
        });
    });

    describe('checkArchiveRateLimit export 확인', () => {
        it('rateLimiter 모듈에서 checkArchiveRateLimit이 함수로 export됨', async () => {
            const rateLimiterModule = await import('@/lib/security/rateLimiter');
            expect(typeof rateLimiterModule.checkArchiveRateLimit).toBe('function');
        });

        it('rateLimiter 모듈에서 checkRateLimit도 함수로 export됨', async () => {
            const rateLimiterModule = await import('@/lib/security/rateLimiter');
            expect(typeof rateLimiterModule.checkRateLimit).toBe('function');
        });
    });
});

// ============================================================
// 5. InsuranceChunkArchive 타입 및 COLLECTIONS 상수 테스트
// ============================================================

describe('InsuranceChunkArchive 타입 및 COLLECTIONS 상수 검증', () => {

    describe('InsuranceChunkArchive 타입 필드 검증', () => {
        it('InsuranceChunkArchive에 archiveExpireAt 필드가 없음 (TTL 없는 영구 보존 설계)', () => {
            // archiveExpireAt은 설계상 존재하지 않아야 함 (영구 보존 컬렉션)
            const archiveChunk = {
                id: 'chunk_001',
                companyId: 'company_test',
                companyName: '테스트생명',
                productId: 'product_test',
                productName: '테스트종신보험',
                pageNumber: 1,
                chunkText: '테스트 청크 내용',
                embedding: [],
                coverageNames: [],
                sourceType: 'policy' as const,
                effectiveDate: '2024-03',
                driveFileId: 'drive_file_001',
                createdAt: {} as any,
                // InsuranceChunkArchive 추가 필드
                archivedAt: {} as any,
                supersededByDate: '2024-06',
                originalDocId: 'original_doc_001',
            };

            expect('archiveExpireAt' in archiveChunk).toBe(false);
        });

        it('supersededByDate 필드가 string 타입임', () => {
            const archiveChunk = {
                archivedAt: {} as any,
                supersededByDate: '2024-06',
                originalDocId: 'original_doc_001',
            };

            expect(typeof archiveChunk.supersededByDate).toBe('string');
        });

        it('supersededByDate 값이 YYYY-MM 형식임', () => {
            const supersededByDate = '2024-06';
            expect(/^\d{4}-\d{2}$/.test(supersededByDate)).toBe(true);
        });

        it('archivedAt 필드가 존재함', () => {
            const archiveChunk = {
                archivedAt: {} as any,
                supersededByDate: '2024-06',
                originalDocId: 'original_doc_001',
            };

            expect('archivedAt' in archiveChunk).toBe(true);
        });

        it('originalDocId 필드가 string 타입임', () => {
            const archiveChunk = {
                archivedAt: {} as any,
                supersededByDate: '2024-06',
                originalDocId: 'original_doc_001',
            };

            expect(typeof archiveChunk.originalDocId).toBe('string');
        });
    });

    describe('COLLECTIONS 상수 검증', () => {
        it('COLLECTIONS.INSURANCE_CHUNKS_ARCHIVE가 존재함', async () => {
            const { COLLECTIONS } = await import('@/types/firestore');
            expect(COLLECTIONS.INSURANCE_CHUNKS_ARCHIVE).toBeDefined();
        });

        it('COLLECTIONS.INSURANCE_CHUNKS_ARCHIVE 값이 "insurance_chunks_archive"임', async () => {
            const { COLLECTIONS } = await import('@/types/firestore');
            expect(COLLECTIONS.INSURANCE_CHUNKS_ARCHIVE).toBe('insurance_chunks_archive');
        });

        it('COLLECTIONS.INSURANCE_CHUNKS가 "insurance_chunks"임', async () => {
            const { COLLECTIONS } = await import('@/types/firestore');
            expect(COLLECTIONS.INSURANCE_CHUNKS).toBe('insurance_chunks');
        });

        it('COLLECTIONS.INSURANCE_METADATA가 "insurance_metadata"임', async () => {
            const { COLLECTIONS } = await import('@/types/firestore');
            expect(COLLECTIONS.INSURANCE_METADATA).toBe('insurance_metadata');
        });
    });
});

// ============================================================
// 6. versions API 응답 형식 테스트
// ============================================================

describe('versions API 응답 형식 검증', () => {

    // versions/route.ts의 버전 목록 구성 로직을 재현
    function buildVersionList(metadataList: InsuranceMetadata[]) {
        return metadataList
            .filter((m) => m.effectiveDateRange?.start)
            .map((m) => {
                const isCurrent = !m.effectiveDateRange?.end;
                return {
                    effectiveDate: m.effectiveDateRange!.start,
                    endDate: m.effectiveDateRange?.end ?? null,
                    isCurrent,
                };
            })
            .sort((a, b) => b.effectiveDate.localeCompare(a.effectiveDate));
    }

    describe('effectiveDate 내림차순 정렬 검증', () => {
        it('3개 버전이 최신순(내림차순)으로 정렬됨', () => {
            const metadataList: InsuranceMetadata[] = [
                makeMeta('2022-01', '2023-06'),
                makeMeta('2024-03'),
                makeMeta('2023-06', '2024-03'),
            ];

            const versions = buildVersionList(metadataList);

            expect(versions[0].effectiveDate).toBe('2024-03');
            expect(versions[1].effectiveDate).toBe('2023-06');
            expect(versions[2].effectiveDate).toBe('2022-01');
        });

        it('단일 버전도 정렬 결과에 포함됨', () => {
            const metadataList: InsuranceMetadata[] = [
                makeMeta('2024-03'),
            ];

            const versions = buildVersionList(metadataList);

            expect(versions).toHaveLength(1);
            expect(versions[0].effectiveDate).toBe('2024-03');
        });

        it('effectiveDateRange.start가 없는 메타데이터는 필터링됨', () => {
            const noStartMeta: InsuranceMetadata = {
                ...makeMeta('2024-03'),
                effectiveDateRange: undefined,
            };
            const validMeta = makeMeta('2024-03');

            const versions = buildVersionList([noStartMeta, validMeta]);

            expect(versions).toHaveLength(1);
        });
    });

    describe('isCurrent 플래그 검증', () => {
        it('end가 없는 메타데이터 → isCurrent=true (현행 버전)', () => {
            const metadataList: InsuranceMetadata[] = [makeMeta('2024-03')];
            const versions = buildVersionList(metadataList);

            expect(versions[0].isCurrent).toBe(true);
        });

        it('end가 있는 메타데이터 → isCurrent=false (과거 버전)', () => {
            const metadataList: InsuranceMetadata[] = [makeMeta('2022-01', '2024-03')];
            const versions = buildVersionList(metadataList);

            expect(versions[0].isCurrent).toBe(false);
        });

        it('혼합 목록에서 end 없는 것만 isCurrent=true', () => {
            const metadataList: InsuranceMetadata[] = [
                makeMeta('2022-01', '2023-06'),
                makeMeta('2023-06', '2024-03'),
                makeMeta('2024-03'),
            ];

            const versions = buildVersionList(metadataList);
            const currentVersions = versions.filter((v) => v.isCurrent);
            const historicalVersions = versions.filter((v) => !v.isCurrent);

            expect(currentVersions).toHaveLength(1);
            expect(currentVersions[0].effectiveDate).toBe('2024-03');
            expect(historicalVersions).toHaveLength(2);
        });

        it('endDate: end가 있으면 해당 값, 없으면 null 반환', () => {
            const metadataList: InsuranceMetadata[] = [
                makeMeta('2022-01', '2024-03'),
                makeMeta('2024-03'),
            ];

            const versions = buildVersionList(metadataList);
            // 내림차순: 2024-03이 먼저
            expect(versions[0].endDate).toBeNull();
            expect(versions[1].endDate).toBe('2024-03');
        });
    });

    describe('정렬 안정성 검증 (같은 월이 없는 경우)', () => {
        it('5개 버전이 올바른 내림차순으로 정렬됨', () => {
            const metadataList: InsuranceMetadata[] = [
                makeMeta('2020-01', '2021-06'),
                makeMeta('2023-06', '2024-03'),
                makeMeta('2021-06', '2022-12'),
                makeMeta('2024-03'),
                makeMeta('2022-12', '2023-06'),
            ];

            const versions = buildVersionList(metadataList);
            const dates = versions.map((v) => v.effectiveDate);

            expect(dates).toEqual([
                '2024-03',
                '2023-06',
                '2022-12',
                '2021-06',
                '2020-01',
            ]);
        });
    });
});