using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;

// 어셈블리 정보
[assembly: AssemblyTitle("MyNavisworksPlugin")]
[assembly: AssemblyDescription("Custom Navisworks Plugin")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("My Company")]
[assembly: AssemblyProduct("MyNavisworksPlugin")]
[assembly: AssemblyCopyright("Copyright © 2026")]
[assembly: AssemblyTrademark("")]
[assembly: AssemblyCulture("")]

// COM 가시성
[assembly: ComVisible(false)]

// 버전 정보
[assembly: AssemblyVersion("1.0.0.0")]
[assembly: AssemblyFileVersion("1.0.0.0")]

using System;
using Autodesk.Navisworks.Api.Plugins;

namespace MyNavisworksPlugin
{
    /// <summary>
    /// 기본 AddIn 플러그인 클래스
    /// Navisworks 메뉴에 간단한 명령을 추가합니다.
    /// </summary>
    [Plugin(
        "MyBasicPlugin",                          // Plugin ID (고유해야 함)
        "MyCompany",                              // Developer ID
        DisplayName = "My Basic Plugin",          // 메뉴에 표시될 이름
        ToolTip = "This is my basic plugin"       // 툴팁 텍스트
    )]
    public class MyBasicPlugin : AddInPlugin
    {
        /// <summary>
        /// 플러그인이 실행될 때 호출되는 메서드
        /// 사용자가 메뉴에서 플러그인을 클릭하면 실행됩니다.
        /// </summary>
        /// <param name="parameters">실행 매개변수</param>
        /// <returns>실행 성공 여부 (0: 성공)</returns>
        public override int Execute(params string[] parameters)
        {
            try
            {
                // 현재 활성 문서 가져오기
                var doc = Autodesk.Navisworks.Api.Application.ActiveDocument;

                // 문서가 열려있는지 확인
                if (doc == null)
                {
                    System.Windows.MessageBox.Show(
                        "No document is currently open.",
                        "Error",
                        System.Windows.MessageBoxButton.OK,
                        System.Windows.MessageBoxImage.Error
                    );
                    return 1; // 실패
                }

                // 플러그인 로직 구현
                System.Windows.MessageBox.Show(
                    "Plugin executed successfully!",
                    "Success",
                    System.Windows.MessageBoxButton.OK,
                    System.Windows.MessageBoxImage.Information
                );

                return 0; // 성공
            }
            catch (Exception ex)
            {
                // 에러 처리
                System.Windows.MessageBox.Show(
                    $"Error: {ex.Message}",
                    "Error",
                    System.Windows.MessageBoxButton.OK,
                    System.Windows.MessageBoxImage.Error
                );
                return 1; // 실패
            }
        }
    }
}

using System;
using System.Windows.Controls;
using Autodesk.Navisworks.Api.Plugins;

namespace MyNavisworksPlugin
{
    /// <summary>
    /// 도킹 패널 플러그인
    /// Navisworks 인터페이스에 도킹 가능한 커스텀 패널을 추가합니다.
    /// </summary>
    [Plugin(
        "MyDockPanePlugin",                       // Plugin ID
        "MyCompany",                              // Developer ID
        DisplayName = "My Dock Pane",             // 패널 제목
        ToolTip = "Custom dockable panel"         // 툴팁
    )]
    [DockPanePlugin(
        800,                                      // 기본 너비 (픽셀)
        600                                       // 기본 높이 (픽셀)
    )]
    public class MyDockPanePlugin : DockPanePlugin
    {
        /// <summary>
        /// 도킹 패널의 WPF 컨트롤을 생성하고 반환합니다.
        /// 이 메서드는 패널이 처음 표시될 때 한 번 호출됩니다.
        /// </summary>
        /// <returns>WPF UserControl 또는 다른 WPF 컨트롤</returns>
        public override System.Windows.Controls.Control CreateControlPane()
        {
            // WPF UserControl 또는 간단한 컨트롤 반환
            var stackPanel = new StackPanel();

            // 라벨 추가
            var label = new Label
            {
                Content = "This is a custom dock pane",
                FontSize = 14,
                Margin = new System.Windows.Thickness(10)
            };
            stackPanel.Children.Add(label);

            // 버튼 추가
            var button = new Button
            {
                Content = "Click Me",
                Margin = new System.Windows.Thickness(10),
                Padding = new System.Windows.Thickness(10, 5, 10, 5)
            };
            button.Click += Button_Click;
            stackPanel.Children.Add(button);

            return stackPanel;
        }

        /// <summary>
        /// 버튼 클릭 이벤트 핸들러
        /// </summary>
        private void Button_Click(object sender, System.Windows.RoutedEventArgs e)
        {
            // 버튼 클릭 시 실행할 로직
            System.Windows.MessageBox.Show(
                "Button clicked from dock pane!",
                "Info",
                System.Windows.MessageBoxButton.OK,
                System.Windows.MessageBoxImage.Information
            );
        }

        /// <summary>
        /// 도킹 패널이 삭제될 때 호출됩니다.
        /// 리소스 정리에 사용합니다.
        /// </summary>
        public override void DestroyControlPane(Control pane)
        {
            // 이벤트 핸들러 해제 등 정리 작업
            if (pane is StackPanel stackPanel)
            {
                foreach (var child in stackPanel.Children)
                {
                    if (child is Button btn)
                    {
                        btn.Click -= Button_Click;
                    }
                }
            }

            base.DestroyControlPane(pane);
        }
    }
}

using System;
using System.Windows.Forms;
using Autodesk.Navisworks.Api.Plugins;

namespace MyNavisworksPlugin
{
    /// <summary>
    /// 커스텀 리본 탭과 명령을 추가하는 플러그인
    /// 여러 개의 명령을 하나의 플러그인에서 관리할 수 있습니다.
    /// </summary>
    [Plugin(
        "MyCommandHandler",                       // Plugin ID
        "MyCompany",                              // Developer ID
        DisplayName = "My Command Handler",       // 표시 이름
        ToolTip = "Custom ribbon commands"        // 툴팁
    )]
    [RibbonLayout("RibbonLayout.xaml")]           // XAML 파일 경로
    [RibbonTab("MyCustomTab")]                    // XAML에서 정의한 탭 ID
    [Command("Command1", DisplayName = "Command 1", ToolTip = "First command")]
    [Command("Command2", DisplayName = "Command 2", ToolTip = "Second command")]
    public class MyCommandHandler : CommandHandlerPlugin
    {
        /// <summary>
        /// 리본 버튼이 클릭되었을 때 호출됩니다.
        /// </summary>
        /// <param name="commandId">클릭된 버튼의 Command ID</param>
        /// <param name="parameters">명령 매개변수</param>
        /// <returns>실행 성공 여부 (0: 성공)</returns>
        public override int ExecuteCommand(string commandId, params string[] parameters)
        {
            try
            {
                // 현재 활성 문서 가져오기
                var doc = Autodesk.Navisworks.Api.Application.ActiveDocument;

                // commandId에 따라 다른 동작 수행
                switch (commandId)
                {
                    case "Command1":
                        ExecuteCommand1(doc);
                        break;

                    case "Command2":
                        ExecuteCommand2(doc);
                        break;

                    default:
                        MessageBox.Show(
                            $"Unknown command: {commandId}",
                            "Error",
                            MessageBoxButtons.OK,
                            MessageBoxIcon.Error
                        );
                        return 1; // 실패
                }

                return 0; // 성공
            }
            catch (Exception ex)
            {
                MessageBox.Show(
                    $"Error in {commandId}: {ex.Message}",
                    "Error",
                    MessageBoxButtons.OK,
                    MessageBoxIcon.Error
                );
                return 1; // 실패
            }
        }

        /// <summary>
        /// Command1 실행 로직
        /// </summary>
        private void ExecuteCommand1(Autodesk.Navisworks.Api.Document doc)
        {
            // Command1 로직 구현
            MessageBox.Show(
                "Command 1 executed!",
                "Info",
                MessageBoxButtons.OK,
                MessageBoxIcon.Information
            );
        }

        /// <summary>
        /// Command2 실행 로직
        /// </summary>
        private void ExecuteCommand2(Autodesk.Navisworks.Api.Document doc)
        {
            // Command2 로직 구현
            MessageBox.Show(
                "Command 2 executed!",
                "Info",
                MessageBoxButtons.OK,
                MessageBoxIcon.Information
            );
        }
    }
}

using Autodesk.Navisworks.Api;                    // 핵심 API
using Autodesk.Navisworks.Api.Plugins;            // 플러그인 관련
using Autodesk.Navisworks.Api.DocumentParts;      // 문서 부분 (Selection, CurrentSelection 등)
using Autodesk.Navisworks.Api.Interop.ComApi;     // COM API (고급 기능)

// 활성 문서 가져오기
var doc = Autodesk.Navisworks.Api.Application.ActiveDocument;

// 문서가 열려있는지 확인
if (doc == null)
{
    // 문서가 없음
    return;
}

// 파일 경로
var filePath = doc.FileName;
Console.WriteLine($"DOCUMENT_PATH:{filePath}");

// 문서의 모델 루트
var models = doc.Models;
Console.WriteLine($"MODEL_COUNT:{models.Count}");

// 모든 ModelItem을 재귀적으로 탐색하는 헬퍼 메서드
private void TraverseModelItems(ModelItem item, Action<ModelItem> action)
{
    // 현재 아이템에 대해 액션 수행
    action(item);

    // 자식 아이템들을 재귀적으로 탐색
    foreach (var child in item.Children)
    {
        TraverseModelItems(child, action);
    }
}

// 사용 예시
var rootItems = doc.Models.RootItems;
foreach (var rootItem in rootItems)
{
    TraverseModelItems(rootItem, (item) =>
    {
        // 각 ModelItem에 대한 처리
        var displayName = item.DisplayName;
        Console.WriteLine($"ITEM:{displayName}");
    });
}

// 검색 조건 생성: 이름에 "Wall"이 포함된 모든 아이템 찾기
var searchCondition = SearchCondition.HasPropertyByDisplayName(
    "Item",         // PropertyCategory 이름
    "Name"          // Property 이름
).Contains("Wall"); // 조건

// 검색 실행
var search = new Search();
search.Selection.SelectAll();  // 모든 아이템을 대상으로 검색
search.SearchConditions.Add(searchCondition);

// 검색 결과
var results = search.FindAll(doc, false); // false = 첫 번째 발견 시 중단하지 않음
Console.WriteLine($"SEARCH_RESULTS:{results.Count}");

// 결과 처리
foreach (var item in results)
{
    Console.WriteLine($"FOUND:{item.DisplayName}");
}

// ModelItem의 모든 속성 읽기
private void ReadProperties(ModelItem item)
{
    // 모든 PropertyCategory 순회
    foreach (var category in item.PropertyCategories)
    {
        var categoryName = category.DisplayName;
        Console.WriteLine($"CATEGORY:{categoryName}");

        // 카테고리 내의 모든 속성 순회
        foreach (var property in category.Properties)
        {
            var propertyName = property.DisplayName;
            var propertyValue = property.Value.ToDisplayString();

            Console.WriteLine($"PROPERTY:{propertyName}={propertyValue}");
        }
    }
}

// 특정 속성 찾기
private string GetPropertyValue(
    ModelItem item,
    string categoryName,
    string propertyName)
{
    // 카테고리 찾기
    var category = item.PropertyCategories.FindCategoryByDisplayName(categoryName);
    if (category == null)
    {
        Console.WriteLine($"CATEGORY_NOT_FOUND category:{categoryName}");
        return null;
    }

    // 속성 찾기
    var property = category.Properties.FindPropertyByDisplayName(propertyName);
    if (property == null)
    {
        Console.WriteLine($"PROPERTY_NOT_FOUND property:{propertyName}");
        return null;
    }

    // 값 반환
    return property.Value.ToDisplayString();
}

// 현재 선택된 아이템 가져오기
var selection = doc.CurrentSelection.SelectedItems;
Console.WriteLine($"SELECTED_COUNT:{selection.Count}");

// 선택된 아이템 순회
foreach (var item in selection)
{
    Console.WriteLine($"SELECTED_ITEM:{item.DisplayName}");
}

// 프로그래밍 방식으로 선택 설정
var itemsToSelect = new ModelItemCollection();
// ... itemsToSelect에 아이템 추가 ...
doc.CurrentSelection.CopyFrom(itemsToSelect);

// 현재 뷰포인트 가져오기
var currentViewpoint = doc.CurrentViewpoint.CreateCopy();

// 카메라 위치 가져오기
var position = currentViewpoint.Position;
Console.WriteLine($"CAMERA_POSITION:X={position.X}, Y={position.Y}, Z={position.Z}");

// 카메라 회전 가져오기 (Quaternion)
var rotation = currentViewpoint.Rotation;

// 회전을 Axis-Angle 형식으로 변환
var axisAngle = rotation.ToAxisAndAngle();
var axis = axisAngle.Axis;
var angle = axisAngle.Angle; // 라디안

Console.WriteLine($"CAMERA_ROTATION:Axis=({axis.X},{axis.Y},{axis.Z}), Angle={angle}");

// 새로운 뷰포인트 생성 및 적용
var newViewpoint = new Viewpoint();
newViewpoint.Position = new Point3D(10, 20, 30);
newViewpoint.FocalDistance = 100;
doc.CurrentViewpoint.CopyFrom(newViewpoint);

// ModelItem의 지오메트리 확인
if (item.HasGeometry)
{
    var geometry = item.Geometry;

    // 바운딩 박스 (BoundingBox)
    var boundingBox = geometry.BoundingBox();
    var min = boundingBox.Min;
    var max = boundingBox.Max;

    Console.WriteLine($"BOUNDING_BOX:Min=({min.X},{min.Y},{min.Z}), Max=({max.X},{max.Y},{max.Z})");

    // Transform 정보
    var activeTransform = geometry.ActiveTransform;
    Console.WriteLine($"ACTIVE_TRANSFORM:{activeTransform}");
}

[Plugin(
    "UniquePluginID",                     // 고유 ID (필수)
    "DeveloperID",                        // 개발자 ID (필수)
    DisplayName = "Display Name",         // GUI 표시 이름
    ToolTip = "Tooltip text"              // 툴팁
)]

[DockPanePlugin(
    800,                                  // 기본 너비
    600,                                  // 기본 높이
    MinimumWidth = 400,                   // 최소 너비 (선택적)
    MinimumHeight = 300                   // 최소 높이 (선택적)
)]

[RibbonLayout("RibbonLayout.xaml")]       // XAML 파일 경로
[RibbonTab("MyCustomTab")]                // XAML의 탭 ID
[Command("Command1",
    DisplayName = "Command 1",
    ToolTip = "Command 1 tooltip",
    Icon = "icon16.png",                  // 16x16 아이콘
    LargeIcon = "icon32.png")]            // 32x32 아이콘

// Utilities/GeometryHelper.cs
public class GeometryHelper
{
    /// <summary>
    /// 두 점 사이의 거리 계산
    /// </summary>
    public static double Distance(Point3D p1, Point3D p2)
    {
        var dx = p2.X - p1.X;
        var dy = p2.Y - p1.Y;
        var dz = p2.Z - p1.Z;
        return Math.Sqrt(dx * dx + dy * dy + dz * dz);
    }
}

// Tests/GeometryHelperTests.cs (별도 테스트 프로젝트)
[TestClass]
public class GeometryHelperTests
{
    [TestMethod]
    public void Distance_TwoPoints_ReturnsCorrectDistance()
    {
        var p1 = new Point3D(0, 0, 0);
        var p2 = new Point3D(3, 4, 0);

        var distance = GeometryHelper.Distance(p1, p2);

        Assert.AreEqual(5.0, distance, 0.001);
    }
}

using System;
using System.IO;

namespace MyNavisworksPlugin.Utilities
{
    /// <summary>
    /// 간단한 파일 로거
    /// </summary>
    public static class Logger
    {
        private static readonly string _logFilePath;

        static Logger()
        {
            // 로그 파일 경로 설정
            var appData = Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData);
            var logFolder = Path.Combine(appData, "MyNavisworksPlugin");

            // 폴더 생성 (없으면)
            if (!Directory.Exists(logFolder))
            {
                Directory.CreateDirectory(logFolder);
            }

            // 로그 파일명 (날짜 포함)
            var fileName = $"log_{DateTime.Now:yyyyMMdd}.txt";
            _logFilePath = Path.Combine(logFolder, fileName);
        }

        /// <summary>
        /// 디버그 로그 기록
        /// </summary>
        public static void Log(string message)
        {
            try
            {
                var timestamp = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fff");
                var logEntry = $"[{timestamp}] {message}";

                File.AppendAllText(_logFilePath, logEntry + Environment.NewLine);
            }
            catch (Exception ex)
            {
                // 로깅 실패 시 조용히 무시 (크래시 방지)
                System.Diagnostics.Debug.WriteLine($"LOGGING_FAILED:{ex.Message}");
            }
        }

        /// <summary>
        /// 에러 로그 기록
        /// </summary>
        public static void LogError(string message, Exception ex = null)
        {
            var errorMessage = $"ERROR:{message}";
            if (ex != null)
            {
                errorMessage += $" Exception:{ex.Message}, StackTrace:{ex.StackTrace}";
            }

            Log(errorMessage);
        }
    }
}

try
{
    Logger.Log($"PLUGIN_STARTED");

    // 플러그인 로직
    var doc = Autodesk.Navisworks.Api.Application.ActiveDocument;
    Logger.Log($"DOCUMENT_LOADED:Path={doc.FileName}");

    // ...
}
catch (Exception ex)
{
    Logger.LogError("PLUGIN_EXECUTION_FAILED", ex);
    throw; // 크래시로 명확한 디버깅
}

// 외부 애플리케이션에서 Navisworks 제어
var navisworks = new Autodesk.Navisworks.Api.Automation.NavisworksApplication();
navisworks.OpenFile(@"C:\Path\To\Model.nwd");

// 플러그인 실행
// ... 테스트 로직 ...

navisworks.Dispose();

using System;
using System.Collections.Generic;
using System.IO;
using System.Text;
using System.Windows.Forms;
using Autodesk.Navisworks.Api;
using Autodesk.Navisworks.Api.Plugins;
using Autodesk.Navisworks.Api.Interop.ComApi;

namespace NavisworksDataExtractor
{
    /// <summary>
    /// Navisworks 모델에서 모든 오브젝트의 상세 정보를 추출하는 플러그인
    /// </summary>
    [Plugin(
        "DataExtractorPlugin",
        "MyCompany",
        DisplayName = "Extract Object Data",
        ToolTip = "Extract position, rotation, mesh, and properties from all objects"
    )]
    public class DataExtractorPlugin : AddInPlugin
    {
        /// <summary>
        /// 플러그인 실행
        /// </summary>
        public override int Execute(params string[] parameters)
        {
            try
            {
                // 현재 활성 문서 가져오기
                var doc = Autodesk.Navisworks.Api.Application.ActiveDocument;

                // 문서 확인
                if (doc == null)
                {
                    MessageBox.Show(
                        "No document is currently open.",
                        "Error",
                        MessageBoxButtons.OK,
                        MessageBoxIcon.Error
                    );
                    return 1;
                }

                Logger.Log($"EXTRACTION_STARTED:File={doc.FileName}");

                // 데이터 추출
                var objectDataList = ExtractAllObjectData(doc);

                Logger.Log($"EXTRACTION_COMPLETED:Count={objectDataList.Count}");

                // 결과를 CSV로 저장
                SaveToCSV(objectDataList);

                MessageBox.Show(
                    $"Extracted data from {objectDataList.Count} objects.\nSaved to CSV file.",
                    "Success",
                    MessageBoxButtons.OK,
                    MessageBoxIcon.Information
                );

                return 0; // 성공
            }
            catch (Exception ex)
            {
                Logger.LogError("EXTRACTION_FAILED", ex);
                MessageBox.Show(
                    $"Error: {ex.Message}",
                    "Error",
                    MessageBoxButtons.OK,
                    MessageBoxIcon.Error
                );
                return 1; // 실패
            }
        }

        /// <summary>
        /// 모든 객체의 데이터를 추출합니다.
        /// </summary>
        private List<ObjectData> ExtractAllObjectData(Document doc)
        {
            var objectDataList = new List<ObjectData>();

            // COM API 초기화 (일부 고급 기능에 필요)
            InwOpState10 comState = ComApiBridge.State;

            // 모든 루트 아이템 순회
            var rootItems = doc.Models.RootItems;
            Logger.Log($"ROOT_ITEMS_COUNT:{rootItems.Count}");

            foreach (var rootItem in rootItems)
            {
                // 재귀적으로 모든 자식 아이템 추출
                TraverseAndExtract(rootItem, comState, objectDataList);
            }

            return objectDataList;
        }

        /// <summary>
        /// ModelItem을 재귀적으로 순회하며 데이터를 추출합니다.
        /// </summary>
        private void TraverseAndExtract(
            ModelItem item,
            InwOpState10 comState,
            List<ObjectData> dataList)
        {
            try
            {
                // ObjectData 생성 및 추출
                var objectData = new ObjectData();

                // 기본 정보
                objectData.DisplayName = item.DisplayName ?? "Unnamed";
                objectData.InstanceGuid = item.InstanceGuid.ToString();
                objectData.ClassDisplayName = item.ClassDisplayName ?? "Unknown";

                Logger.Log($"PROCESSING_ITEM:Name={objectData.DisplayName}");

                // 지오메트리가 있는 경우에만 추가 정보 추출
                if (item.HasGeometry)
                {
                    ExtractGeometryData(item, comState, objectData);
                }

                // 속성 추출
                ExtractProperties(item, objectData);

                // 리스트에 추가
                dataList.Add(objectData);
            }
            catch (Exception ex)
            {
                Logger.LogError($"ITEM_EXTRACTION_FAILED:Item={item.DisplayName}", ex);
                // 에러가 발생해도 계속 진행
            }

            // 자식 아이템들을 재귀적으로 처리
            foreach (var child in item.Children)
            {
                TraverseAndExtract(child, comState, dataList);
            }
        }

        /// <summary>
        /// 지오메트리 데이터를 추출합니다 (위치, 회전, 메시).
        /// </summary>
        private void ExtractGeometryData(
            ModelItem item,
            InwOpState10 comState,
            ObjectData objectData)
        {
            try
            {
                var geometry = item.Geometry;

                // 바운딩 박스 (World 좌표계)
                var boundingBox = geometry.BoundingBox();
                var center = new Point3D(
                    (boundingBox.Min.X + boundingBox.Max.X) / 2.0,
                    (boundingBox.Min.Y + boundingBox.Max.Y) / 2.0,
                    (boundingBox.Min.Z + boundingBox.Max.Z) / 2.0
                );

                objectData.WorldPositionX = center.X;
                objectData.WorldPositionY = center.Y;
                objectData.WorldPositionZ = center.Z;

                Logger.Log($"WORLD_POSITION:X={center.X}, Y={center.Y}, Z={center.Z}");

                // Transform 정보
                var activeTransform = geometry.ActiveTransform;

                // Transform을 Matrix로 변환하여 로컬 좌표 추출
                // Transform3D는 4x4 매트릭스를 나타냅니다.
                // Translation (로컬 위치)는 매트릭스의 마지막 행에 있습니다.
                var translation = activeTransform.Translation;
                objectData.LocalPositionX = translation.X;
                objectData.LocalPositionY = translation.Y;
                objectData.LocalPositionZ = translation.Z;

                Logger.Log($"LOCAL_POSITION:X={translation.X}, Y={translation.Y}, Z={translation.Z}");

                // 회전 정보 추출 (Rotation3D를 Euler Angles로 변환)
                // Navisworks는 Quaternion을 사용하므로 Euler Angles로 변환
                var rotation = activeTransform.Rotation;
                var eulerAngles = QuaternionToEulerAngles(rotation);

                objectData.RotationX = eulerAngles.X;
                objectData.RotationY = eulerAngles.Y;
                objectData.RotationZ = eulerAngles.Z;

                Logger.Log($"ROTATION:X={eulerAngles.X}, Y={eulerAngles.Y}, Z={eulerAngles.Z}");

                // 메시 정보 추출 (COM API 사용)
                ExtractMeshData(item, comState, objectData);
            }
            catch (Exception ex)
            {
                Logger.LogError($"GEOMETRY_EXTRACTION_FAILED:Item={objectData.DisplayName}", ex);
            }
        }

        /// <summary>
        /// COM API를 사용하여 메시 데이터를 추출합니다.
        /// </summary>
        private void ExtractMeshData(
            ModelItem item,
            InwOpState10 comState,
            ObjectData objectData)
        {
            try
            {
                // ModelItem을 COM 객체로 변환
                InwOaPath comPath = ComApiBridge.ToInwOaPath(item);

                // Fragment 가져오기 (지오메트리의 실제 데이터)
                var fragments = comState.ObjectFactory.CreateFragmentsColl();
                fragments.AddFragsForPath(comPath);

                // Fragment가 있는 경우
                if (fragments.Count > 0)
                {
                    var fragment = fragments.Item(1); // 첫 번째 Fragment

                    // Vertex 개수 및 Triangle 개수 추출
                    // 주의: GenerateSimplePrimitives()는 성능 이슈가 있을 수 있음
                    var primitives = fragment.GenerateSimplePrimitives(
                        nwEVertexProperty.eNORMAL,  // Normal 포함
                        null
                    );

                    // Primitives 정보 추출
                    var vertexCount = 0;
                    var triangleCount = 0;

                    foreach (InwSimplePrimitive primitive in primitives)
                    {
                        vertexCount += primitive.VerticesCount;
                        triangleCount += primitive.TrianglesCount;
                    }

                    objectData.VertexCount = vertexCount;
                    objectData.TriangleCount = triangleCount;

                    Logger.Log($"MESH_DATA:Vertices={vertexCount}, Triangles={triangleCount}");
                }
            }
            catch (Exception ex)
            {
                Logger.LogError($"MESH_EXTRACTION_FAILED:Item={objectData.DisplayName}", ex);
                // 메시 추출 실패 시에도 계속 진행
            }
        }

        /// <summary>
        /// Quaternion을 Euler Angles(도)로 변환합니다.
        /// </summary>
        private Point3D QuaternionToEulerAngles(Rotation3D rotation)
        {
            // Quaternion 성분 추출
            var axisAngle = rotation.ToAxisAndAngle();
            var axis = axisAngle.Axis;
            var angle = axisAngle.Angle; // 라디안

            // 간단한 변환 (정확한 변환은 더 복잡함)
            // 여기서는 근사치를 사용
            var x = axis.X * angle * (180.0 / Math.PI);
            var y = axis.Y * angle * (180.0 / Math.PI);
            var z = axis.Z * angle * (180.0 / Math.PI);

            return new Point3D(x, y, z);
        }

        /// <summary>
        /// ModelItem의 속성을 추출합니다.
        /// </summary>
        private void ExtractProperties(ModelItem item, ObjectData objectData)
        {
            try
            {
                var propertiesDict = new Dictionary<string, string>();

                // 모든 PropertyCategory 순회
                foreach (var category in item.PropertyCategories)
                {
                    var categoryName = category.DisplayName;

                    // 카테고리 내의 모든 속성 순회
                    foreach (var property in category.Properties)
                    {
                        var propertyName = property.DisplayName;
                        var propertyValue = property.Value.ToDisplayString();

                        // 키 생성: "Category::Property"
                        var key = $"{categoryName}::{propertyName}";
                        propertiesDict[key] = propertyValue;
                    }
                }

                // Dictionary를 JSON 형식 문자열로 변환 (간단하게)
                var sb = new StringBuilder();
                sb.Append("{");
                var first = true;
                foreach (var kvp in propertiesDict)
                {
                    if (!first) sb.Append(", ");
                    sb.Append($"\"{kvp.Key}\":\"{kvp.Value}\"");
                    first = false;
                }
                sb.Append("}");

                objectData.Properties = sb.ToString();

                Logger.Log($"PROPERTIES_EXTRACTED:Count={propertiesDict.Count}");
            }
            catch (Exception ex)
            {
                Logger.LogError($"PROPERTIES_EXTRACTION_FAILED:Item={objectData.DisplayName}", ex);
            }
        }

        /// <summary>
        /// 추출된 데이터를 CSV 파일로 저장합니다.
        /// </summary>
        private void SaveToCSV(List<ObjectData> dataList)
        {
            try
            {
                // 저장 경로 설정
                var appData = Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments);
                var fileName = $"NavisworksExtraction_{DateTime.Now:yyyyMMdd_HHmmss}.csv";
                var filePath = Path.Combine(appData, fileName);

                Logger.Log($"SAVING_CSV:Path={filePath}");

                using (var writer = new StreamWriter(filePath, false, Encoding.UTF8))
                {
                    // CSV 헤더
                    writer.WriteLine("DisplayName,InstanceGuid,ClassDisplayName," +
                        "WorldX,WorldY,WorldZ," +
                        "LocalX,LocalY,LocalZ," +
                        "RotationX,RotationY,RotationZ," +
                        "VertexCount,TriangleCount," +
                        "Properties");

                    // 데이터 행
                    foreach (var data in dataList)
                    {
                        writer.WriteLine(
                            $"\"{data.DisplayName}\"," +
                            $"\"{data.InstanceGuid}\"," +
                            $"\"{data.ClassDisplayName}\"," +
                            $"{data.WorldPositionX}," +
                            $"{data.WorldPositionY}," +
                            $"{data.WorldPositionZ}," +
                            $"{data.LocalPositionX}," +
                            $"{data.LocalPositionY}," +
                            $"{data.LocalPositionZ}," +
                            $"{data.RotationX}," +
                            $"{data.RotationY}," +
                            $"{data.RotationZ}," +
                            $"{data.VertexCount}," +
                            $"{data.TriangleCount}," +
                            $"\"{EscapeCSV(data.Properties)}\""
                        );
                    }
                }

                Logger.Log($"CSV_SAVED_SUCCESSFULLY:Path={filePath}");

                // 파일 열기
                System.Diagnostics.Process.Start(filePath);
            }
            catch (Exception ex)
            {
                Logger.LogError("CSV_SAVE_FAILED", ex);
                throw;
            }
        }

        /// <summary>
        /// CSV 문자열 이스케이프 처리
        /// </summary>
        private string EscapeCSV(string value)
        {
            if (string.IsNullOrEmpty(value))
                return string.Empty;

            // 따옴표를 이중 따옴표로 변환
            return value.Replace("\"", "\"\"");
        }
    }

    /// <summary>
    /// 추출된 객체 데이터를 담는 클래스
    /// </summary>
    public class ObjectData
    {
        // 기본 정보
        public string DisplayName { get; set; }
        public string InstanceGuid { get; set; }
        public string ClassDisplayName { get; set; }

        // World Position
        public double WorldPositionX { get; set; }
        public double WorldPositionY { get; set; }
        public double WorldPositionZ { get; set; }

        // Local Position
        public double LocalPositionX { get; set; }
        public double LocalPositionY { get; set; }
        public double LocalPositionZ { get; set; }

        // Rotation (Euler Angles in degrees)
        public double RotationX { get; set; }
        public double RotationY { get; set; }
        public double RotationZ { get; set; }

        // Mesh 정보
        public int VertexCount { get; set; }
        public int TriangleCount { get; set; }

        // 속성 (JSON 형식 문자열)
        public string Properties { get; set; }
    }

    /// <summary>
    /// 간단한 로거 클래스
    /// </summary>
    public static class Logger
    {
        private static readonly string _logFilePath;

        static Logger()
        {
            var appData = Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData);
            var logFolder = Path.Combine(appData, "NavisworksDataExtractor");

            if (!Directory.Exists(logFolder))
            {
                Directory.CreateDirectory(logFolder);
            }

            var fileName = $"log_{DateTime.Now:yyyyMMdd}.txt";
            _logFilePath = Path.Combine(logFolder, fileName);
        }

        public static void Log(string message)
        {
            try
            {
                var timestamp = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fff");
                var logEntry = $"[{timestamp}] {message}";

                File.AppendAllText(_logFilePath, logEntry + Environment.NewLine);
            }
            catch
            {
                // 로깅 실패 시 조용히 무시
            }
        }

        public static void LogError(string message, Exception ex = null)
        {
            var errorMessage = $"ERROR:{message}";
            if (ex != null)
            {
                errorMessage += $" Exception:{ex.Message}, StackTrace:{ex.StackTrace}";
            }

            Log(errorMessage);
        }
    }
}