using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Runtime.InteropServices; // COM 객체 해제를 위해 필요
using System.Threading;
using System.Threading.Tasks;
using Teigha.DatabaseServices;
using Teigha.Geometry;
using Teigha.Runtime;
using Excel = Microsoft.Office.Interop.Excel;
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;

namespace DwgExtractorManual.Models
{
    /// <summary>
    /// DWG 파일에서 Excel로 데이터 내보내기 클래스
    /// AttributeReference, AttributeDefinition, DBText, MText 추출 지원
    /// </summary>
    internal class ExportExcel : IDisposable
    {
        // ODA 서비스 객체 (managed by singleton)
        private Services appServices;

        // Excel COM 객체들
        private Excel.Application excelApplication;
        private Excel.Workbook workbook1;
        private Excel.Worksheet titleBlockSheet;  // Title Block용 시트
        private Excel.Worksheet textEntitiesSheet; // Text Entities용 시트
        private Excel.Workbook mappingWorkbook; // 매핑 데이터용 워크북
        private Excel.Worksheet mappingSheet; // 매핑 데이터용 시트

        readonly List<string> MapKeys;


        // 각 시트의 현재 행 번호
        private int titleBlockCurrentRow = 2; // 헤더가 1행이므로 데이터는 2행부터 시작
        private int textEntitiesCurrentRow = 2; // 헤더가 1행이므로 데이터는 2행부터 시작
        private int mappingDataCurrentRow = 2; // 헤더가 1행이므로 데이터는 2행부터 시작

        // 매핑 데이터 저장용 딕셔너리 - (AILabel, DwgTag, DwgValue, PdfValue)
        private Dictionary<string, Dictionary<string, (string, string, string, string)>> FileToMapkeyToLabelTagValuePdf = new Dictionary<string, Dictionary<string, (string, string, string, string)>>();

        private FieldMapper fieldMapper;
        // 생성자: ODA 및 Excel 초기화
        public ExportExcel()
        {
            try
            {
                Debug.WriteLine("🔄 FieldMapper 로딩 중: mapping_table_json.json...");
                fieldMapper = FieldMapper.LoadFromFile("fletimageanalysis/mapping_table_json.json");
                Debug.WriteLine("✅ FieldMapper 로딩 성공");
                MapKeys = fieldMapper.GetAllDocAiKeys();
                Debug.WriteLine($"📊 총 DocAI 키 개수: {MapKeys?.Count ?? 0}");
                
                // 매핑 테스트 (디버깅용)
                TestFieldMapper();
            }
            catch (System.Exception ex)
            {
                Debug.WriteLine($"❌ FieldMapper 로딩 오류:");
                Debug.WriteLine($"   메시지: {ex.Message}");
                Debug.WriteLine($"   예외 타입: {ex.GetType().Name}");
                if (ex.InnerException != null)
                {
                    Debug.WriteLine($"   내부 예외: {ex.InnerException.Message}");
                }
                Debug.WriteLine($"   스택 트레이스: {ex.StackTrace}");
                throw;
            }
            
            Debug.WriteLine("🔄 ODA 초기화 중...");
            InitializeTeighaServices();
            Debug.WriteLine("🔄 Excel 초기화 중...");
            InitializeExcel();
        }

        // 필드 매퍼 테스트
        private void TestFieldMapper()
        {
            Debug.WriteLine("[DEBUG] Testing field mapper...");
            
            // 몇 가지 알려진 expressway 필드로 테스트
            var testFields = new[] { "TD_DNAME_MAIN", "TD_DWGNO", "TD_DWGCODE", "TB_MTITIL"};
            
            foreach (var field in testFields)
            {
                var aiLabel = fieldMapper.ExpresswayToAilabel(field);
                var docAiKey = fieldMapper.AilabelToDocAiKey(aiLabel);
                Debug.WriteLine($"[DEBUG] Field: {field} -> AILabel: {aiLabel} -> DocAiKey: {docAiKey}");
            }
        }

        // Teigha 서비스 초기화 (싱글톤 사용)
        private void InitializeTeighaServices()
        {
            try
            {
                Debug.WriteLine("[DEBUG] TeighaServicesManager를 통한 Services 획득 중...");
                appServices = TeighaServicesManager.Instance.AcquireServices();
                Debug.WriteLine($"[DEBUG] Services 획득 성공. Reference Count: {TeighaServicesManager.Instance.ReferenceCount}");
            }
            catch (Teigha.Runtime.Exception ex)
            {
                Debug.WriteLine($"[DEBUG] Teigha Services 초기화 실패: {ex.Message}");
                throw;
            }
        }

        // Excel 애플리케이션 및 워크시트 초기화
        private void InitializeExcel()
        {
            try
            {
                var excelApp = new Excel.Application();
                excelApplication = excelApp;
                excelApplication.Visible = false; // WPF에서는 숨김 처리
                Excel.Workbook workbook = excelApp.Workbooks.Add();
                workbook1 = workbook;

                // Title Block Sheet 설정 (기본 Sheet1)
                titleBlockSheet = (Excel.Worksheet)workbook.Sheets[1];
                titleBlockSheet.Name = "Title Block";
                SetupTitleBlockHeaders();

                // Text Entities Sheet 추가
                textEntitiesSheet = (Excel.Worksheet)workbook.Sheets.Add();
                textEntitiesSheet.Name = "Text Entities";
                SetupTextEntitiesHeaders();

                // 매핑 데이터용 워크북 및 시트 생성
                mappingWorkbook = excelApp.Workbooks.Add();
                mappingSheet = (Excel.Worksheet)mappingWorkbook.Sheets[1];
                mappingSheet.Name = "Mapping Data";
                SetupMappingHeaders();
            }
            catch (System.Exception ex)
            {
                Debug.WriteLine($"Excel 초기화 중 오류 발생: {ex.Message}");
                ReleaseExcelObjects();
                throw;
            }
        }

        // Title Block 시트 헤더 설정
        private void SetupTitleBlockHeaders()
        {
            titleBlockSheet.Cells[1, 1] = "Type";      // 예: AttributeReference, AttributeDefinition
            titleBlockSheet.Cells[1, 2] = "Name";      // BlockReference 이름 또는 BlockDefinition 이름
            titleBlockSheet.Cells[1, 3] = "Tag";       // Attribute Tag
            titleBlockSheet.Cells[1, 4] = "Prompt";    // Attribute Prompt
            titleBlockSheet.Cells[1, 5] = "Value";     // Attribute 값 (TextString)
            titleBlockSheet.Cells[1, 6] = "Path";      // 원본 DWG 파일 전체 경로
            titleBlockSheet.Cells[1, 7] = "FileName";  // 원본 DWG 파일 이름만

            // 헤더 행 스타일
            Excel.Range headerRange = titleBlockSheet.Range["A1:G1"];
            headerRange.Font.Bold = true;
            headerRange.Interior.Color = System.Drawing.ColorTranslator.ToOle(System.Drawing.Color.LightBlue);
        }

        // Text Entities 시트 헤더 설정
        private void SetupTextEntitiesHeaders()
        {
            textEntitiesSheet.Cells[1, 1] = "Type";      // DBText, MText
            textEntitiesSheet.Cells[1, 2] = "Layer";     // Layer 이름
            textEntitiesSheet.Cells[1, 3] = "Text";      // 실제 텍스트 내용
            textEntitiesSheet.Cells[1, 4] = "Path";      // 원본 DWG 파일 전체 경로
            textEntitiesSheet.Cells[1, 5] = "FileName";  // 원본 DWG 파일 이름만

            // 헤더 행 스타일
            Excel.Range headerRange = textEntitiesSheet.Range["A1:E1"];
            headerRange.Font.Bold = true;
            headerRange.Interior.Color = System.Drawing.ColorTranslator.ToOle(System.Drawing.Color.LightGreen);
        }

        // 매핑 데이터 시트 헤더 설정
        private void SetupMappingHeaders()
        {
            mappingSheet.Cells[1, 1] = "FileName";   // 파일 이름
            mappingSheet.Cells[1, 2] = "MapKey";     // 매핑 키
            mappingSheet.Cells[1, 3] = "AILabel";    // AI 라벨
            mappingSheet.Cells[1, 4] = "DwgTag";    // DWG Tag
            mappingSheet.Cells[1, 5] = "Att_value";  // DWG 값
            mappingSheet.Cells[1, 6] = "Pdf_value";  // PDF 값 (현재는 빈 값)

            // 헤더 행 스타일
            Excel.Range headerRange = mappingSheet.Range["A1:F1"];
            headerRange.Font.Bold = true;
            headerRange.Interior.Color = System.Drawing.ColorTranslator.ToOle(System.Drawing.Color.LightYellow);
        }

        /// <summary>
        /// 단일 DWG 파일에서 AttributeReference/AttributeDefinition 데이터를 추출하여
        /// 초기화된 Excel 워크시트에 추가합니다.
        /// </summary>
        /// <param name="filePath">처리할 DWG 파일 경로</param>
        /// <param name="progress">진행 상태 보고를 위한 IProgress 객체</param>
        /// <param name="cancellationToken">작업 취소를 위한 CancellationToken</param>
        /// <returns>성공 시 true, 실패 시 false 반환</returns>
        public bool ExportDwgToExcel(string filePath, IProgress<double> progress = null, CancellationToken cancellationToken = default)
        {
            Debug.WriteLine($"[DEBUG] ExportDwgToExcel 시작: {filePath}");
            
            if (excelApplication == null)
            {
                Debug.WriteLine("❌ Excel이 초기화되지 않았습니다.");
                return false;
            }

            if (!File.Exists(filePath))
            {
                Debug.WriteLine($"❌ 파일이 존재하지 않습니다: {filePath}");
                return false;
            }

            try
            {
                Debug.WriteLine("[DEBUG] 진행률 0% 보고");
                progress?.Report(0);
                cancellationToken.ThrowIfCancellationRequested();

                Debug.WriteLine("[DEBUG] ODA Database 객체 생성 중...");
                // ODA Database 객체 생성 및 DWG 파일 읽기
                using (var database = new Database(false, true))
                {
                    Debug.WriteLine($"[DEBUG] DWG 파일 읽기 시도: {filePath}");
                    database.ReadDwgFile(filePath, FileOpenMode.OpenForReadAndWriteNoShare, false, null);
                    Debug.WriteLine("[DEBUG] DWG 파일 읽기 성공");

                    cancellationToken.ThrowIfCancellationRequested();
                    Debug.WriteLine("[DEBUG] 진행률 10% 보고");
                    progress?.Report(10);

                    Debug.WriteLine("[DEBUG] 트랜잭션 시작 중...");
                    using (var tran = database.TransactionManager.StartTransaction())
                    {
                        Debug.WriteLine("[DEBUG] BlockTable 접근 중...");
                        var bt = tran.GetObject(database.BlockTableId, OpenMode.ForRead) as BlockTable;
                        Debug.WriteLine("[DEBUG] ModelSpace 접근 중...");
                        using (var btr = tran.GetObject(bt[BlockTableRecord.ModelSpace], OpenMode.ForRead) as BlockTableRecord)
                        {
                            int totalEntities = btr.Cast<ObjectId>().Count();
                            Debug.WriteLine($"[DEBUG] 총 엔티티 수: {totalEntities}");
                            int processedCount = 0;

                            foreach (ObjectId entId in btr)
                            {
                                cancellationToken.ThrowIfCancellationRequested();

                                using (var ent = tran.GetObject(entId, OpenMode.ForRead) as Entity)
                                {
                                    // Layer 이름 가져오기 (공통)
                                    string layerName = GetLayerName(ent.LayerId, tran, database);
                                    var fileName = Path.GetFileNameWithoutExtension(database.Filename);

                                    // 파일명 유효성 검사
                                    if (string.IsNullOrEmpty(fileName))
                                    {
                                        fileName = "Unknown_File";
                                        Debug.WriteLine($"[DEBUG] Using default filename: {fileName}");
                                    }

                                    // 파일별 매핑 딕셔너리 초기화
                                    if (!FileToMapkeyToLabelTagValuePdf.ContainsKey(fileName))
                                    {
                                        FileToMapkeyToLabelTagValuePdf[fileName] = new Dictionary<string, (string, string, string, string)>();
                                    }

                                    // AttributeDefinition 추출
                                    if (ent is AttributeDefinition attDef)
                                    {
                                        titleBlockSheet.Cells[titleBlockCurrentRow, 1] = attDef.GetType().Name;
                                        titleBlockSheet.Cells[titleBlockCurrentRow, 2] = attDef.BlockName;
                                        titleBlockSheet.Cells[titleBlockCurrentRow, 3] = attDef.Tag;
                                        titleBlockSheet.Cells[titleBlockCurrentRow, 4] = attDef.Prompt;
                                        titleBlockSheet.Cells[titleBlockCurrentRow, 5] = attDef.TextString;
                                        titleBlockSheet.Cells[titleBlockCurrentRow, 6] = database.Filename;
                                        titleBlockSheet.Cells[titleBlockCurrentRow, 7] = Path.GetFileName(database.Filename);
                                        titleBlockCurrentRow++;

                                        var tag = attDef.Tag;
                                        var aiLabel = fieldMapper.ExpresswayToAilabel(tag);
                                        var mapKey = fieldMapper.AilabelToDocAiKey(aiLabel);
                                        var attValue = attDef.TextString;
                                        Debug.WriteLine($"[DEBUG] AttributeDefinition - Tag: {tag}, AILabel: {aiLabel}, MapKey: {mapKey}");

                                        // 매핑 데이터 저장
                                        if (!string.IsNullOrEmpty(aiLabel))
                                        {
                                            // mapKey가 null이면 aiLabel을 mapKey로 사용
                                            var finalMapKey = mapKey ?? aiLabel;
                                            FileToMapkeyToLabelTagValuePdf[fileName][finalMapKey] = (aiLabel, tag, attValue, "");
                                            Debug.WriteLine($"[DEBUG] Added mapping: {tag} -> {aiLabel} (MapKey: {finalMapKey})");
                                        }
                                        else
                                        {
                                            // aiLabel이 null이면 tag를 사용하여 저장
                                            var finalMapKey = mapKey ?? tag;
                                            if (!string.IsNullOrEmpty(finalMapKey))
                                            {
                                                FileToMapkeyToLabelTagValuePdf[fileName][finalMapKey] = (tag, tag, attValue, "");
                                                Debug.WriteLine($"[DEBUG] Added unmapped tag: {tag} -> {tag} (MapKey: {finalMapKey})");
                                            }
                                            else
                                            {
                                                Debug.WriteLine($"[DEBUG] Skipped empty tag for AttributeDefinition");
                                            }
                                        }
                                    }
                                    // BlockReference 및 그 안의 AttributeReference 추출
                                    else if (ent is BlockReference blr)
                                    {
                                        foreach (ObjectId attId in blr.AttributeCollection)
                                        {
                                            cancellationToken.ThrowIfCancellationRequested();

                                            using (var attRef = tran.GetObject(attId, OpenMode.ForRead) as AttributeReference)
                                            {
                                                if (attRef != null && attRef.TextString.Trim() != "")
                                                {
                                                    titleBlockSheet.Cells[titleBlockCurrentRow, 1] = attRef.GetType().Name;
                                                    titleBlockSheet.Cells[titleBlockCurrentRow, 2] = blr.Name;
                                                    titleBlockSheet.Cells[titleBlockCurrentRow, 3] = attRef.Tag;
                                                    titleBlockSheet.Cells[titleBlockCurrentRow, 4] = GetPromptFromAttributeReference(tran, blr, attRef.Tag);

                                                    titleBlockSheet.Cells[titleBlockCurrentRow, 5] = attRef.TextString;
                                                    titleBlockSheet.Cells[titleBlockCurrentRow, 6] = database.Filename;
                                                    titleBlockSheet.Cells[titleBlockCurrentRow, 7] = Path.GetFileName(database.Filename);
                                                    titleBlockCurrentRow++;

                                                    var tag = attRef.Tag;
                                                    var aiLabel = fieldMapper.ExpresswayToAilabel(tag);
                                                    if (aiLabel == null) continue;
                                                    var mapKey = fieldMapper.AilabelToDocAiKey(aiLabel);
                                                    var attValue = attRef.TextString;

                                                    Debug.WriteLine($"[DEBUG] AttributeReference - Tag: {tag}, AILabel: {aiLabel}, MapKey: {mapKey}");

                                                    // 매핑 데이터 저장
                                                    if (!string.IsNullOrEmpty(aiLabel))
                                                    {
                                                        // mapKey가 null이면 aiLabel을 mapKey로 사용
                                                        var finalMapKey = mapKey ?? aiLabel;
                                                        FileToMapkeyToLabelTagValuePdf[fileName][finalMapKey] = (aiLabel, tag, attValue, "");
                                                        Debug.WriteLine($"[DEBUG] Added mapping: {tag} -> {aiLabel} (MapKey: {finalMapKey})");
                                                    }
                                                    else
                                                    {
                                                        // aiLabel이 null이면 tag를 사용하여 저장
                                                        var finalMapKey = mapKey ?? tag;
                                                        if (!string.IsNullOrEmpty(finalMapKey))
                                                        {
                                                            FileToMapkeyToLabelTagValuePdf[fileName][finalMapKey] = (tag, tag, attValue, "");
                                                            Debug.WriteLine($"[DEBUG] Added unmapped tag: {tag} -> {tag} (MapKey: {finalMapKey})");
                                                        }
                                                        else
                                                        {
                                                            Debug.WriteLine($"[DEBUG] Skipped empty tag for AttributeReference");
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                    // DBText 엔티티 추출 (별도 시트)
                                    else if (ent is DBText dbText)
                                    {
                                        textEntitiesSheet.Cells[textEntitiesCurrentRow, 1] = "DBText"; // Type
                                        textEntitiesSheet.Cells[textEntitiesCurrentRow, 2] = layerName; // Layer
                                        textEntitiesSheet.Cells[textEntitiesCurrentRow, 3] = dbText.TextString; // Text
                                        textEntitiesSheet.Cells[textEntitiesCurrentRow, 4] = database.Filename; // Path
                                        textEntitiesSheet.Cells[textEntitiesCurrentRow, 5] = Path.GetFileName(database.Filename); // FileName
                                        textEntitiesCurrentRow++;
                                    }
                                    // MText 엔티티 추출 (별도 시트)
                                    else if (ent is MText mText)
                                    {
                                        textEntitiesSheet.Cells[textEntitiesCurrentRow, 1] = "MText"; // Type
                                        textEntitiesSheet.Cells[textEntitiesCurrentRow, 2] = layerName; // Layer
                                        textEntitiesSheet.Cells[textEntitiesCurrentRow, 3] = mText.Contents; // Text
                                        textEntitiesSheet.Cells[textEntitiesCurrentRow, 4] = database.Filename; // Path
                                        textEntitiesSheet.Cells[textEntitiesCurrentRow, 5] = Path.GetFileName(database.Filename); // FileName
                                        textEntitiesCurrentRow++;
                                    }
                                }

                                // write values in new excel file with FileToMapkeyToLabelTag

                                processedCount++;
                                double currentProgress = 10.0 + (double)processedCount / totalEntities * 80.0;
                                progress?.Report(Math.Min(currentProgress, 90.0));
                            }
                        }

                        tran.Commit();
                    }

                    Debug.WriteLine($"[DEBUG] Transaction committed. Total mapping entries collected: {FileToMapkeyToLabelTagValuePdf.Sum(f => f.Value.Count)}");
                    
                    // 매핑 데이터를 Excel 시트에 기록
                    Debug.WriteLine("[DEBUG] 매핑 데이터를 Excel에 기록 중...");
                    WriteMappingDataToExcel();
                    Debug.WriteLine("[DEBUG] 매핑 데이터 Excel 기록 완료");
                }

                progress?.Report(100);
                return true;
            }
            catch (OperationCanceledException)
            {
                Debug.WriteLine("❌ 작업이 취소되었습니다.");
                progress?.Report(0);
                return false;
            }
            catch (Teigha.Runtime.Exception ex)
            {
                progress?.Report(0);
                Debug.WriteLine($"❌ DWG 파일 처리 중 Teigha 오류 발생:");
                Debug.WriteLine($"   메시지: {ex.Message}");
                Debug.WriteLine($"   ErrorStatus: {ex.ErrorStatus}");
                if (ex.InnerException != null)
                {
                    Debug.WriteLine($"   내부 예외: {ex.InnerException.Message}");
                }
                Debug.WriteLine($"   스택 트레이스: {ex.StackTrace}");
                return false;
            }
            catch (System.Exception ex)
            {
                progress?.Report(0);
                Debug.WriteLine($"❌ 일반 오류 발생:");
                Debug.WriteLine($"   메시지: {ex.Message}");
                Debug.WriteLine($"   예외 타입: {ex.GetType().Name}");
                if (ex.InnerException != null)
                {
                    Debug.WriteLine($"   내부 예외: {ex.InnerException.Message}");
                }
                Debug.WriteLine($"   스택 트레이스: {ex.StackTrace}");
                return false;
            }
        }

        // 매핑 데이터를 Excel 시트에 기록
        private void WriteMappingDataToExcel()
        {
            try
            {
                int currentRow = 2; // 헤더 다음 행부터 시작
                
                Debug.WriteLine($"[DEBUG] Writing mapping data to Excel. Total files: {FileToMapkeyToLabelTagValuePdf.Count}");
                Debug.WriteLine($"[DEBUG] 시작 행: {currentRow}");

            foreach (var fileEntry in FileToMapkeyToLabelTagValuePdf)
            {
                string fileName = fileEntry.Key;
                var mappingData = fileEntry.Value;
                
                Debug.WriteLine($"[DEBUG] Processing file: {fileName}, entries: {mappingData.Count}");

                foreach (var mapEntry in mappingData)
                {
                    string mapKey = mapEntry.Key;
                    (string aiLabel, string dwgTag, string attValue, string pdfValue) = mapEntry.Value;
                    
                    // null 값 방지
                    if (string.IsNullOrEmpty(fileName) || string.IsNullOrEmpty(mapKey))
                    {
                        Debug.WriteLine($"[DEBUG] Skipping entry with null/empty values: fileName={fileName}, mapKey={mapKey}");
                        continue;
                    }

                    Debug.WriteLine($"[DEBUG] Writing row {currentRow}: {fileName} | {mapKey} | {aiLabel} | {dwgTag} | PDF: {pdfValue}");

                    try
                    {
                        mappingSheet.Cells[currentRow, 1] = fileName;                    // FileName
                        mappingSheet.Cells[currentRow, 2] = mapKey;                     // MapKey
                        mappingSheet.Cells[currentRow, 3] = aiLabel ?? "";             // AILabel
                        mappingSheet.Cells[currentRow, 4] = dwgTag ?? "";              // DwgTag
                        mappingSheet.Cells[currentRow, 5] = attValue ?? "";            // DwgValue (Att_value)
                        mappingSheet.Cells[currentRow, 6] = pdfValue ?? "";            // PdfValue (Pdf_value)
                        
                        Debug.WriteLine($"[DEBUG] Row {currentRow} written successfully");
                    }
                    catch (System.Exception ex)
                    {
                        Debug.WriteLine($"❌ Error writing row {currentRow}: {ex.Message}");
                    }

                    currentRow++;
                }
            }
            
                Debug.WriteLine($"[DEBUG] Mapping data written to Excel. Total rows: {currentRow - 2}");
                Debug.WriteLine($"[DEBUG] 최종 행 번호: {currentRow}");
            }
            catch (System.Exception ex)
            {
                Debug.WriteLine($"❌ 매핑 데이터 Excel 기록 중 오류:");
                Debug.WriteLine($"   메시지: {ex.Message}");
                Debug.WriteLine($"   예외 타입: {ex.GetType().Name}");
                if (ex.InnerException != null)
                {
                    Debug.WriteLine($"   내부 예외: {ex.InnerException.Message}");
                }
                Debug.WriteLine($"   스택 트레이스: {ex.StackTrace}");
                throw; // 상위 메서드로 예외 전파
            }
        }

        /// <summary>
        /// 기존 Excel 파일을 열어 JSON 파일의 PDF 분석 결과로 매핑 시트를 업데이트합니다.
        /// </summary>
        /// <param name="excelFilePath">기존 Excel 파일 경로</param>
        /// <param name="jsonFilePath">PDF 분석 결과 JSON 파일 경로</param>
        /// <returns>성공 시 true, 실패 시 false</returns>
        public bool UpdateExistingExcelWithJson(string excelFilePath, string jsonFilePath)
        {
            try
            {
                Debug.WriteLine($"[DEBUG] 기존 Excel 파일 업데이트 시작: {excelFilePath}");
                
                if (!File.Exists(excelFilePath))
                {
                    Debug.WriteLine($"❌ Excel 파일이 존재하지 않습니다: {excelFilePath}");
                    return false;
                }
                
                if (!File.Exists(jsonFilePath))
                {
                    Debug.WriteLine($"❌ JSON 파일이 존재하지 않습니다: {jsonFilePath}");
                    return false;
                }

                Debug.WriteLine($"[DEBUG] Excel 애플리케이션 초기화 중...");
                
                // 기존 Excel 파일 열기
                if (excelApplication == null)
                {
                    excelApplication = new Excel.Application();
                    excelApplication.Visible = false;
                    Debug.WriteLine("[DEBUG] 새 Excel 애플리케이션 생성됨");
                }

                Debug.WriteLine($"[DEBUG] Excel 파일 열기 시도: {excelFilePath}");
                mappingWorkbook = excelApplication.Workbooks.Open(excelFilePath);
                Debug.WriteLine("[DEBUG] Excel 파일 열기 성공");
                
                Debug.WriteLine("[DEBUG] 'Mapping Data' 시트 찾는 중...");
                mappingSheet = (Excel.Worksheet)mappingWorkbook.Sheets["Mapping Data"];
                
                if (mappingSheet == null)
                {
                    Debug.WriteLine("❌ 'Mapping Data' 시트를 찾을 수 없습니다.");
                    // 사용 가능한 시트 목록 출력
                    Debug.WriteLine("사용 가능한 시트:");
                    foreach (Excel.Worksheet sheet in mappingWorkbook.Sheets)
                    {
                        Debug.WriteLine($"  - {sheet.Name}");
                    }
                    return false;
                }

                Debug.WriteLine("✅ 기존 Excel 파일 열기 성공");
                
                // JSON에서 PDF 값 업데이트
                Debug.WriteLine("[DEBUG] JSON 파싱 및 업데이트 시작");
                bool result = UpdateMappingSheetFromJson(jsonFilePath);
                
                Debug.WriteLine($"[DEBUG] 업데이트 결과: {result}");
                return result;
            }
            catch (System.Exception ex)
            {
                Debug.WriteLine($"❌ 기존 Excel 파일 업데이트 중 오류:");
                Debug.WriteLine($"   메시지: {ex.Message}");
                Debug.WriteLine($"   예외 타입: {ex.GetType().Name}");
                if (ex.InnerException != null)
                {
                    Debug.WriteLine($"   내부 예외: {ex.InnerException.Message}");
                }
                Debug.WriteLine($"   스택 트레이스: {ex.StackTrace}");
                return false;
            }
        }

        /// <summary>
        /// JSON 파일에서 PDF 분석 결과를 읽어 Excel 매핑 시트의 Pdf_value 컬럼을 업데이트합니다.
        /// </summary>
        /// <param name="jsonFilePath">PDF 분석 결과 JSON 파일 경로</param>
        /// <returns>성공 시 true, 실패 시 false</returns>
        public bool UpdateMappingSheetFromJson(string jsonFilePath)
        {
            try
            {
                Debug.WriteLine($"[DEBUG] JSON 파일에서 PDF 값 업데이트 시작: {jsonFilePath}");
                
                if (!File.Exists(jsonFilePath))
                {
                    Debug.WriteLine($"❌ JSON 파일이 존재하지 않습니다: {jsonFilePath}");
                    return false;
                }

                if (mappingSheet == null)
                {
                    Debug.WriteLine("❌ 매핑 시트가 초기화되지 않았습니다.");
                    return false;
                }

                // JSON 파일 읽기 및 정리
                string jsonContent = File.ReadAllText(jsonFilePath, System.Text.Encoding.UTF8);
                Debug.WriteLine($"[DEBUG] JSON 파일 크기: {jsonContent.Length} bytes");
                
                // JSON 내용 정리 (주석 제거 등)
                jsonContent = CleanJsonContent(jsonContent);
                
                JObject jsonData;
                try
                {
                    jsonData = JObject.Parse(jsonContent);
                }
                catch (Newtonsoft.Json.JsonReaderException jsonEx)
                {
                    Debug.WriteLine($"❌ JSON 파싱 오류: {jsonEx.Message}");
                    Debug.WriteLine($"❌ JSON 내용 미리보기 (첫 500자):");
                    Debug.WriteLine(jsonContent.Length > 500 ? jsonContent.Substring(0, 500) + "..." : jsonContent);
                    throw new System.Exception($"PDF 분석 JSON 파일 파싱 실패: {jsonEx.Message}\n파일: {jsonFilePath}");
                }
                
                var results = jsonData["results"] as JArray;
                if (results == null)
                {
                    Debug.WriteLine("❌ JSON에서 'results' 배열을 찾을 수 없습니다.");
                    Debug.WriteLine($"❌ JSON 루트 키들: {string.Join(", ", jsonData.Properties().Select(p => p.Name))}");
                    return false;
                }

                int updatedCount = 0;
                int totalEntries = 0;

                foreach (JObject result in results)
                {
                    var fileInfo = result["file_info"];
                    var pdfAnalysis = result["pdf_analysis"];
                    
                    if (fileInfo == null || pdfAnalysis == null) continue;

                    string fileName = fileInfo["name"]?.ToString();
                    if (string.IsNullOrEmpty(fileName)) continue;

                    // 파일 확장자 제거
                    string fileNameWithoutExt = Path.GetFileNameWithoutExtension(fileName);
                    Debug.WriteLine($"[DEBUG] Processing PDF file: {fileNameWithoutExt}");

                    // PDF 분석 결과의 각 필드 처리
                    foreach (var property in pdfAnalysis.Cast<JProperty>())
                    {
                        string aiLabel = property.Name; // 예: "설계공구_Station_col1"
                        var valueObj = property.Value as JObject;
                        
                        if (valueObj == null) continue;

                        string pdfValue = valueObj["value"]?.ToString();
                        if (string.IsNullOrEmpty(pdfValue)) continue;

                        totalEntries++;
                        Debug.WriteLine($"[DEBUG] Searching for match: FileName={fileNameWithoutExt}, AILabel={aiLabel}, Value={pdfValue}");

                        // Excel 시트에서 매칭되는 행 찾기 및 업데이트
                        if (UpdateExcelRow(fileNameWithoutExt, aiLabel, pdfValue))
                        {
                            updatedCount++;
                            Debug.WriteLine($"✅ Updated: {fileNameWithoutExt} -> {aiLabel} = {pdfValue}");
                        }
                        else
                        {
                            Debug.WriteLine($"⚠️ No match found: {fileNameWithoutExt} -> {aiLabel}");
                        }
                    }
                }

                Debug.WriteLine($"[DEBUG] PDF 값 업데이트 완료: {updatedCount}/{totalEntries} 업데이트됨");
                return true;
            }
            catch (System.Exception ex)
            {
                Debug.WriteLine($"❌ JSON에서 PDF 값 업데이트 중 오류:");
                Debug.WriteLine($"   메시지: {ex.Message}");
                Debug.WriteLine($"   예외 타입: {ex.GetType().Name}");
                if (ex.InnerException != null)
                {
                    Debug.WriteLine($"   내부 예외: {ex.InnerException.Message}");
                }
                Debug.WriteLine($"   스택 트레이스: {ex.StackTrace}");
                return false;
            }
        }

        /// <summary>
        /// Excel 매핑 시트에서 FileName과 AILabel이 매칭되는 행을 찾아 Pdf_value를 업데이트합니다.
        /// </summary>
        /// <param name="fileName">파일명 (확장자 제외)</param>
        /// <param name="aiLabel">AI 라벨 (예: "설계공구_Station_col1")</param>
        /// <param name="pdfValue">PDF에서 추출된 값</param>
        /// <returns>업데이트 성공 시 true</returns>
        private bool UpdateExcelRow(string fileName, string aiLabel, string pdfValue)
        {
            try
            {
                // Excel 시트의 마지막 사용된 행 찾기
                Excel.Range usedRange = mappingSheet.UsedRange;
                if (usedRange == null) return false;

                int lastRow = usedRange.Rows.Count;
                
                // 2행부터 검색 (1행은 헤더)
                for (int row = 2; row <= lastRow; row++)
                {
                    // Column 1: FileName, Column 3: AILabel 확인
                    var cellFileName = mappingSheet.Cells[row, 1]?.Value?.ToString() ?? "";
                    var cellAiLabel = mappingSheet.Cells[row, 3]?.Value?.ToString() ?? "";
                    
                    Debug.WriteLine($"[DEBUG] Row {row}: FileName='{cellFileName}', AILabel='{cellAiLabel}'");
                    
                    // 매칭 확인 (대소문자 구분 없이)
                    if (string.Equals(cellFileName.Trim(), fileName.Trim(), StringComparison.OrdinalIgnoreCase) &&
                        string.Equals(cellAiLabel.Trim(), aiLabel.Trim(), StringComparison.OrdinalIgnoreCase))
                    {
                        // Column 6: Pdf_value에 값 기록
                        mappingSheet.Cells[row, 6] = pdfValue;
                        Debug.WriteLine($"[DEBUG] Updated row {row}, column 6 with value: {pdfValue}");
                        return true;
                    }
                }
                
                return false; // 매칭되는 행을 찾지 못함
            }
            catch (System.Exception ex)
            {
                Debug.WriteLine($"❌ Excel 행 업데이트 중 오류: {ex.Message}");
                return false;
            }
        }

        // Paste the helper function from above here
        public string GetPromptFromAttributeReference(Transaction tr, BlockReference blockref, string tag)
        {

            string prompt = null;


            BlockTableRecord blockDef = tr.GetObject(blockref.BlockTableRecord, OpenMode.ForRead) as BlockTableRecord;
            if (blockDef == null) return null;

            foreach (ObjectId objId in blockDef)
            {
                AttributeDefinition attDef = tr.GetObject(objId, OpenMode.ForRead) as AttributeDefinition;
                if (attDef != null)
                {
                    if (attDef.Tag.Equals(tag, System.StringComparison.OrdinalIgnoreCase))
                    {
                        prompt = attDef.Prompt;
                        break;
                    }
                }
            }


            return prompt;
        }

        /// <summary>
        /// 현재 열려있는 Excel 워크북을 저장합니다.
        /// </summary>
        /// <returns>성공 시 true, 실패 시 false</returns>
        public bool SaveExcel()
        {
            try
            {
                if (mappingWorkbook != null)
                {
                    mappingWorkbook.Save();
                    Debug.WriteLine("✅ Excel 파일 저장 완료");
                    return true;
                }
                
                if (workbook1 != null)
                {
                    workbook1.Save();
                    Debug.WriteLine("✅ Excel 파일 저장 완료");
                    return true;
                }
                
                Debug.WriteLine("❌ 저장할 워크북이 없습니다.");
                return false;
            }
            catch (System.Exception ex)
            {
                Debug.WriteLine($"❌ Excel 파일 저장 중 오류: {ex.Message}");
                return false;
            }
        }

        /// <summary>
        /// 매핑 워크북만 저장하고 닫습니다 (완전한 매핑용).
        /// </summary>
        /// <param name="savePath">저장할 파일 경로</param>
        public void SaveMappingWorkbookOnly(string savePath)
        {
            try
            {
                Debug.WriteLine($"[DEBUG] 매핑 워크북 저장 시작: {savePath}");
                
                if (mappingWorkbook == null)
                {
                    Debug.WriteLine("❌ 매핑 워크북이 초기화되지 않았습니다.");
                    return;
                }

                string directory = Path.GetDirectoryName(savePath);
                if (!string.IsNullOrEmpty(directory) && !Directory.Exists(directory))
                {
                    Directory.CreateDirectory(directory);
                }

                // 매핑 워크북만 저장 (Excel 2007+ 형식으로)
                mappingWorkbook.SaveAs(savePath, 
                    FileFormat: Excel.XlFileFormat.xlOpenXMLWorkbook,
                    AccessMode: Excel.XlSaveAsAccessMode.xlNoChange);
                
                Debug.WriteLine($"✅ 매핑 워크북 저장 완료: {Path.GetFileName(savePath)}");
            }
            catch (System.Exception ex)
            {
                Debug.WriteLine($"❌ 매핑 워크북 저장 중 오류: {ex.Message}");
                Debug.WriteLine($"   스택 트레이스: {ex.StackTrace}");
                throw;
            }
        }

        /// <summary>
        /// 현재 Excel 워크북을 지정된 경로에 저장하고 Excel 애플리케이션을 종료합니다.
        /// </summary>
        /// <param name="savePath">Excel 파일을 저장할 전체 경로</param>
        public void SaveAndCloseExcel(string savePath)
        {
            if (workbook1 == null) return;

            try
            {
                string directory = Path.GetDirectoryName(savePath);
                if (!string.IsNullOrEmpty(directory) && !Directory.Exists(directory))
                {
                    Directory.CreateDirectory(directory);
                }

                workbook1.SaveAs(savePath, AccessMode: Excel.XlSaveAsAccessMode.xlNoChange);

                // 매핑 데이터 워크북도 저장
                if (mappingWorkbook != null)
                {
                    string mappingPath = Path.Combine(directory, Path.GetFileNameWithoutExtension(savePath) + "_Mapping.xlsx");
                    mappingWorkbook.SaveAs(mappingPath, AccessMode: Excel.XlSaveAsAccessMode.xlNoChange);
                }
            }
            catch (System.Exception ex)
            {
                Debug.WriteLine($"Excel 파일 저장 중 오류 발생: {ex.Message}");
            }
            finally
            {
                CloseExcelObjects();
            }
        }

        /// <summary>
        /// Excel 객체들을 닫습니다 (저장하지 않음).
        /// </summary>
        public void CloseExcelObjectsWithoutSaving()
        {
            try
            {
                Debug.WriteLine("[DEBUG] Excel 객체 정리 시작");
                
                if (workbook1 != null)
                {
                    try { workbook1.Close(false); }
                    catch { }
                }
                if (mappingWorkbook != null)
                {
                    try { mappingWorkbook.Close(false); }
                    catch { }
                }
                if (excelApplication != null)
                {
                    try { excelApplication.Quit(); }
                    catch { }
                }

                ReleaseExcelObjects();
                
                Debug.WriteLine("✅ Excel 객체 정리 완료");
            }
            catch (System.Exception ex)
            {
                Debug.WriteLine($"❌ Excel 객체 정리 중 오류: {ex.Message}");
            }
        }

        private void CloseExcelObjects()
        {
            if (workbook1 != null)
            {
                try { workbook1.Close(false); }
                catch { }
            }
            if (mappingWorkbook != null)
            {
                try { mappingWorkbook.Close(false); }
                catch { }
            }
            if (excelApplication != null)
            {
                try { excelApplication.Quit(); }
                catch { }
            }

            ReleaseExcelObjects();
        }

        private void ReleaseExcelObjects()
        {
            ReleaseComObject(titleBlockSheet);
            ReleaseComObject(textEntitiesSheet);
            ReleaseComObject(mappingSheet);
            ReleaseComObject(workbook1);
            ReleaseComObject(mappingWorkbook);
            ReleaseComObject(excelApplication);

            titleBlockSheet = null;
            textEntitiesSheet = null;
            mappingSheet = null;
            workbook1 = null;
            mappingWorkbook = null;
            excelApplication = null;
        }

        private void ReleaseComObject(object obj)
        {
            try
            {
                if (obj != null && Marshal.IsComObject(obj))
                {
                    Marshal.ReleaseComObject(obj);
                }
            }
            catch (System.Exception)
            {
                // 해제 중 오류 발생 시 무시
            }
            finally
            {
                obj = null;
            }
        }

        /// <summary>
        /// Layer ID로부터 Layer 이름을 가져옵니다.
        /// </summary>
        /// <param name="layerId">Layer ObjectId</param>
        /// <param name="transaction">현재 트랜잭션</param>
        /// <param name="database">데이터베이스 객체</param>
        /// <returns>Layer 이름 또는 빈 문자열</returns>
        private string GetLayerName(ObjectId layerId, Transaction transaction, Database database)
        {
            try
            {
                using (var layerTableRecord = transaction.GetObject(layerId, OpenMode.ForRead) as LayerTableRecord)
                {
                    return layerTableRecord?.Name ?? "";
                }
            }
            catch (System.Exception ex)
            {
                Debug.WriteLine($"Layer 이름 가져오기 오류: {ex.Message}");
                return "";
            }
        }

        /// <summary>
        /// 매핑 딕셔너리를 JSON 파일로 저장합니다.
        /// </summary>
        /// <param name="filePath">저장할 JSON 파일 경로</param>
        public void SaveMappingDictionary(string filePath)
        {
            try
            {
                Debug.WriteLine($"[DEBUG] 매핑 딕셔너리 저장 시작: {filePath}");
                
                // 딕셔너리를 직렬화 가능한 형태로 변환
                var serializableData = new Dictionary<string, Dictionary<string, object>>();
                
                foreach (var fileEntry in FileToMapkeyToLabelTagValuePdf)
                {
                    var fileData = new Dictionary<string, object>();
                    foreach (var mapEntry in fileEntry.Value)
                    {
                        fileData[mapEntry.Key] = new
                        {
                            AILabel = mapEntry.Value.Item1,
                            DwgTag = mapEntry.Value.Item2,
                            DwgValue = mapEntry.Value.Item3,
                            PdfValue = mapEntry.Value.Item4
                        };
                    }
                    serializableData[fileEntry.Key] = fileData;
                }
                
                // JSON으로 직렬화
                string jsonContent = JsonConvert.SerializeObject(serializableData, Formatting.Indented);
                File.WriteAllText(filePath, jsonContent, System.Text.Encoding.UTF8);
                
                Debug.WriteLine($"✅ 매핑 딕셔너리 저장 완료: {Path.GetFileName(filePath)}");
                Debug.WriteLine($"📊 저장된 파일 수: {FileToMapkeyToLabelTagValuePdf.Count}");
                
            }
            catch (System.Exception ex)
            {
                Debug.WriteLine($"❌ 매핑 딕셔너리 저장 중 오류:");
                Debug.WriteLine($"   메시지: {ex.Message}");
                Debug.WriteLine($"   스택 트레이스: {ex.StackTrace}");
                throw;
            }
        }

        /// <summary>
        /// JSON 파일에서 매핑 딕셔너리를 로드합니다.
        /// </summary>
        /// <param name="filePath">로드할 JSON 파일 경로</param>
        public void LoadMappingDictionary(string filePath)
        {
            try
            {
                Debug.WriteLine($"[DEBUG] 매핑 딕셔너리 로드 시작: {filePath}");
                
                if (!File.Exists(filePath))
                {
                    Debug.WriteLine($"⚠️ 매핑 파일이 존재하지 않습니다: {filePath}");
                    return;
                }
                
                string jsonContent = File.ReadAllText(filePath, System.Text.Encoding.UTF8);
                Debug.WriteLine($"[DEBUG] JSON 내용 길이: {jsonContent.Length}");
                
                // JSON 내용 정리 (주석 제거 등)
                jsonContent = CleanJsonContent(jsonContent);
                
                Dictionary<string, Dictionary<string, JObject>> deserializedData;
                try
                {
                    deserializedData = JsonConvert.DeserializeObject<Dictionary<string, Dictionary<string, JObject>>>(jsonContent);
                }
                catch (Newtonsoft.Json.JsonReaderException jsonEx)
                {
                    Debug.WriteLine($"❌ JSON 파싱 오류: {jsonEx.Message}");
                    Debug.WriteLine($"❌ JSON 내용 미리보기 (첫 500자):");
                    Debug.WriteLine(jsonContent.Length > 500 ? jsonContent.Substring(0, 500) + "..." : jsonContent);
                    throw new System.Exception($"매핑 JSON 파일 파싱 실패: {jsonEx.Message}\n파일: {filePath}");
                }
                
                // 새로운 딕셔너리 초기화
                FileToMapkeyToLabelTagValuePdf.Clear();
                Debug.WriteLine("[DEBUG] 기존 딕셔너리 초기화됨");
                
                if (deserializedData != null)
                {
                    Debug.WriteLine($"[DEBUG] 역직렬화된 파일 수: {deserializedData.Count}");
                    
                    foreach (var fileEntry in deserializedData)
                    {
                        Debug.WriteLine($"[DEBUG] 파일 처리 중: {fileEntry.Key}");
                        var fileData = new Dictionary<string, (string, string, string, string)>();
                        
                        foreach (var mapEntry in fileEntry.Value)
                        {
                            var valueObj = mapEntry.Value;
                            string aiLabel = valueObj["AILabel"]?.ToString() ?? "";
                            string dwgTag = valueObj["DwgTag"]?.ToString() ?? "";
                            string dwgValue = valueObj["DwgValue"]?.ToString() ?? "";
                            string pdfValue = valueObj["PdfValue"]?.ToString() ?? "";
                            
                            fileData[mapEntry.Key] = (aiLabel, dwgTag, dwgValue, pdfValue);
                            Debug.WriteLine($"[DEBUG] 항목 로드: {mapEntry.Key} -> AI:{aiLabel}, DWG:{dwgTag}, PDF:{pdfValue}");
                        }
                        
                        FileToMapkeyToLabelTagValuePdf[fileEntry.Key] = fileData;
                        Debug.WriteLine($"[DEBUG] 파일 {fileEntry.Key}: {fileData.Count}개 항목 로드됨");
                    }
                }
                
                Debug.WriteLine($"✅ 매핑 딕셔너리 로드 완료");
                Debug.WriteLine($"📊 로드된 파일 수: {FileToMapkeyToLabelTagValuePdf.Count}");
                Debug.WriteLine($"📊 총 항목 수: {FileToMapkeyToLabelTagValuePdf.Sum(f => f.Value.Count)}");
                
            }
            catch (System.Exception ex)
            {
                Debug.WriteLine($"❌ 매핑 딕셔너리 로드 중 오류:");
                Debug.WriteLine($"   메시지: {ex.Message}");
                Debug.WriteLine($"   스택 트레이스: {ex.StackTrace}");
                throw;
            }
        }

        /// <summary>
        /// 매핑 딕셔너리 데이터를 Excel 시트에 기록합니다 (완전한 매핑용).
        /// </summary>
        public void WriteCompleteMapping()
        {
            try
            {
                Debug.WriteLine("[DEBUG] WriteCompleteMapping 시작");
                Debug.WriteLine($"[DEBUG] 매핑 딕셔너리 항목 수: {FileToMapkeyToLabelTagValuePdf.Count}");
                
                if (FileToMapkeyToLabelTagValuePdf.Count == 0)
                {
                    Debug.WriteLine("⚠️ 매핑 딕셔너리가 비어있습니다.");
                    return;
                }

                if (mappingSheet == null)
                {
                    Debug.WriteLine("❌ 매핑 시트가 초기화되지 않았습니다.");
                    return;
                }

                Debug.WriteLine($"[DEBUG] 매핑 시트 이름: {mappingSheet.Name}");
                Debug.WriteLine($"[DEBUG] 전체 데이터 항목 수: {FileToMapkeyToLabelTagValuePdf.Sum(f => f.Value.Count)}");

                // 샘플 데이터 출력 (처음 3개)
                int sampleCount = 0;
                foreach (var fileEntry in FileToMapkeyToLabelTagValuePdf.Take(2))
                {
                    Debug.WriteLine($"[DEBUG] 파일: {fileEntry.Key}");
                    foreach (var mapEntry in fileEntry.Value.Take(3))
                    {
                        var (aiLabel, dwgTag, dwgValue, pdfValue) = mapEntry.Value;
                        Debug.WriteLine($"[DEBUG]   {mapEntry.Key} -> AI:{aiLabel}, DWG:{dwgTag}, DWGVAL:{dwgValue}, PDF:{pdfValue}");
                        sampleCount++;
                    }
                }

                // 기존 WriteMappingDataToExcel 메서드 호출
                WriteMappingDataToExcel();
                
                Debug.WriteLine("✅ WriteCompleteMapping 완료");
            }
            catch (System.Exception ex)
            {
                Debug.WriteLine($"❌ WriteCompleteMapping 중 오류:");
                Debug.WriteLine($"   메시지: {ex.Message}");
                Debug.WriteLine($"   스택 트레이스: {ex.StackTrace}");
                throw;
            }
        }

        /// <summary>
        /// PDF 분석 결과 JSON으로 매핑 딕셔너리의 PdfValue를 업데이트합니다.
        /// </summary>
        /// <param name="jsonFilePath">PDF 분석 결과 JSON 파일 경로</param>
        public void UpdateWithPdfData(string jsonFilePath)
        {
            try
            {
                Debug.WriteLine($"[DEBUG] PDF 데이터로 매핑 딕셔너리 업데이트 시작: {jsonFilePath}");
                
                if (!File.Exists(jsonFilePath))
                {
                    Debug.WriteLine($"❌ JSON 파일이 존재하지 않습니다: {jsonFilePath}");
                    return;
                }

                // JSON 파일 읽기 및 정리
                string jsonContent = File.ReadAllText(jsonFilePath, System.Text.Encoding.UTF8);
                Debug.WriteLine($"[DEBUG] JSON 파일 크기: {jsonContent.Length} bytes");
                
                // JSON 내용 정리 (주석 제거 등)
                jsonContent = CleanJsonContent(jsonContent);
                
                JObject jsonData;
                try
                {
                    jsonData = JObject.Parse(jsonContent);
                }
                catch (Newtonsoft.Json.JsonReaderException jsonEx)
                {
                    Debug.WriteLine($"❌ JSON 파싱 오류: {jsonEx.Message}");
                    Debug.WriteLine($"❌ JSON 내용 미리보기 (첫 500자):");
                    Debug.WriteLine(jsonContent.Length > 500 ? jsonContent.Substring(0, 500) + "..." : jsonContent);
                    throw new System.Exception($"PDF 분석 JSON 파일 파싱 실패: {jsonEx.Message}\n파일: {jsonFilePath}");
                }
                
                var results = jsonData["results"] as JArray;
                if (results == null)
                {
                    Debug.WriteLine("❌ JSON에서 'results' 배열을 찾을 수 없습니다.");
                    Debug.WriteLine($"❌ JSON 루트 키들: {string.Join(", ", jsonData.Properties().Select(p => p.Name))}");
                    return;
                }

                int updatedCount = 0;
                int totalEntries = 0;

                foreach (JObject result in results)
                {
                    var fileInfo = result["file_info"];
                    var pdfAnalysis = result["pdf_analysis"];
                    
                    if (fileInfo == null || pdfAnalysis == null) continue;

                    string fileName = fileInfo["name"]?.ToString();
                    if (string.IsNullOrEmpty(fileName)) continue;

                    // 파일 확장자 제거
                    string fileNameWithoutExt = Path.GetFileNameWithoutExtension(fileName);
                    Debug.WriteLine($"[DEBUG] Processing PDF file: {fileNameWithoutExt}");

                    // 해당 파일의 매핑 데이터 확인
                    if (!FileToMapkeyToLabelTagValuePdf.ContainsKey(fileNameWithoutExt))
                    {
                        Debug.WriteLine($"⚠️ 매핑 데이터에 파일이 없습니다: {fileNameWithoutExt}");
                        continue;
                    }

                    // PDF 분석 결과의 각 필드 처리
                    foreach (var property in pdfAnalysis.Cast<JProperty>())
                    {
                        string aiLabel = property.Name; // 예: "설계공구_Station_col1"
                        var valueObj = property.Value as JObject;
                        
                        if (valueObj == null) continue;

                        string pdfValue = valueObj["value"]?.ToString();
                        if (string.IsNullOrEmpty(pdfValue)) continue;

                        totalEntries++;

                        // 매핑 딕셔너리에서 해당 항목 찾기
                        var fileData = FileToMapkeyToLabelTagValuePdf[fileNameWithoutExt];
                        
                        // AILabel로 매칭 찾기
                        var matchingEntry = fileData.FirstOrDefault(kvp => 
                            string.Equals(kvp.Value.Item1.Trim(), aiLabel.Trim(), StringComparison.OrdinalIgnoreCase));
                        
                        if (!string.IsNullOrEmpty(matchingEntry.Key))
                        {
                            // 기존 값 유지하면서 PdfValue만 업데이트
                            var existingValue = matchingEntry.Value;
                            fileData[matchingEntry.Key] = (existingValue.Item1, existingValue.Item2, existingValue.Item3, pdfValue);
                            updatedCount++;
                            
                            Debug.WriteLine($"✅ Updated: {fileNameWithoutExt} -> {aiLabel} = {pdfValue}");
                        }
                        else
                        {
                            Debug.WriteLine($"⚠️ No match found: {fileNameWithoutExt} -> {aiLabel}");
                        }
                    }
                }

                Debug.WriteLine($"[DEBUG] PDF 데이터 업데이트 완료: {updatedCount}/{totalEntries} 업데이트됨");
                
            }
            catch (System.Exception ex)
            {
                Debug.WriteLine($"❌ PDF 데이터 업데이트 중 오류:");
                Debug.WriteLine($"   메시지: {ex.Message}");
                Debug.WriteLine($"   스택 트레이스: {ex.StackTrace}");
                throw;
            }
        }

        /// <summary>
        /// JSON 내용을 정리하여 파싱 가능한 상태로 만듭니다.
        /// 주석 제거 및 기타 무효한 문자 처리
        /// </summary>
        /// <param name="jsonContent">원본 JSON 내용</param>
        /// <returns>정리된 JSON 내용</returns>
        private string CleanJsonContent(string jsonContent)
        {
            if (string.IsNullOrEmpty(jsonContent))
                return jsonContent;

            try
            {
                // 줄별로 처리하여 주석 제거
                var lines = jsonContent.Split('\n');
                var cleanedLines = new List<string>();

                bool inMultiLineComment = false;

                foreach (string line in lines)
                {
                    string processedLine = line;

                    // 멀티라인 주석 처리 (/* */)
                    if (inMultiLineComment)
                    {
                        int endIndex = processedLine.IndexOf("*/");
                        if (endIndex >= 0)
                        {
                            processedLine = processedLine.Substring(endIndex + 2);
                            inMultiLineComment = false;
                        }
                        else
                        {
                            continue; // 전체 라인이 주석
                        }
                    }

                    // 멀티라인 주석 시작 확인
                    int multiLineStart = processedLine.IndexOf("/*");
                    if (multiLineStart >= 0)
                    {
                        int multiLineEnd = processedLine.IndexOf("*/", multiLineStart + 2);
                        if (multiLineEnd >= 0)
                        {
                            // 같은 라인에서 시작하고 끝나는 주석
                            processedLine = processedLine.Substring(0, multiLineStart) + 
                                          processedLine.Substring(multiLineEnd + 2);
                        }
                        else
                        {
                            // 멀티라인 주석 시작
                            processedLine = processedLine.Substring(0, multiLineStart);
                            inMultiLineComment = true;
                        }
                    }

                    // 싱글라인 주석 제거 (//) - 문자열 내부의 //는 제외
                    bool inString = false;
                    bool escaped = false;
                    int commentIndex = -1;

                    for (int i = 0; i < processedLine.Length - 1; i++)
                    {
                        char current = processedLine[i];
                        char next = processedLine[i + 1];

                        if (escaped)
                        {
                            escaped = false;
                            continue;
                        }

                        if (current == '\\')
                        {
                            escaped = true;
                            continue;
                        }

                        if (current == '"')
                        {
                            inString = !inString;
                            continue;
                        }

                        if (!inString && current == '/' && next == '/')
                        {
                            commentIndex = i;
                            break;
                        }
                    }

                    if (commentIndex >= 0)
                    {
                        processedLine = processedLine.Substring(0, commentIndex);
                    }

                    // 빈 라인이 아니면 추가
                    if (!string.IsNullOrWhiteSpace(processedLine))
                    {
                        cleanedLines.Add(processedLine);
                    }
                }

                string result = string.Join("\n", cleanedLines);
                Debug.WriteLine($"[DEBUG] JSON 정리 완료: {jsonContent.Length} -> {result.Length} bytes");
                return result;
            }
            catch (System.Exception ex)
            {
                Debug.WriteLine($"❌ JSON 정리 중 오류: {ex.Message}");
                // 정리 실패시 원본 반환
                return jsonContent;
            }
        }

        public void Dispose()
        {
            try
            {
                Debug.WriteLine("[DEBUG] ExportExcel Dispose 시작");
                
                if (excelApplication != null)
                {
                    Debug.WriteLine("[DEBUG] Excel 객체 정리 중...");
                    CloseExcelObjects();
                }

                if (appServices != null)
                {
                    Debug.WriteLine("[DEBUG] Teigha Services 해제 중...");
                    try
                    {
                        TeighaServicesManager.Instance.ReleaseServices();
                        Debug.WriteLine($"[DEBUG] Teigha Services 해제 완료. Remaining ref count: {TeighaServicesManager.Instance.ReferenceCount}");
                    }
                    catch (System.Exception ex)
                    {
                        Debug.WriteLine($"[DEBUG] Teigha Services 해제 중 오류 (무시됨): {ex.Message}");
                    }
                    finally
                    {
                        appServices = null;
                    }
                }
                
                Debug.WriteLine("[DEBUG] ExportExcel Dispose 완료");
            }
            catch (System.Exception ex)
            {
                Debug.WriteLine($"[DEBUG] ExportExcel Dispose 중 전역 오류: {ex.Message}");
                // Disposal 오류는 로그만 남기고 계속 진행
            }
        }
    }
}