XRLib/Assets/Scripts/Simulator/PropertyWindow/ASRSProperty.cs

using Simulator.Data;
using System;
using System.Collections.Generic;
using UnityEngine;
using UVC.UI.Window.PropertyWindow;

public class ASRSProperty : MonoBehaviour
{
    [SerializeField]
    private PropertyWindow propertyWindow;
    private void Awake()
    {
        propertyWindow.PropertyValueChanged += OnPropertyValueChanged;
    }

    public void SetProertyWindow(ComponentType type, ComponentDataBase data)
    {
        Debug.Log(data);
        InitAsrsProperty(data as ASRSDataClass);
    }

    void SaveChange(object source, object value, string name)
    {
        var path = PathIndexer.GetNodePath(source);
        Patch updateData = new Patch();
        updateData.value = value;
        UpdateValueStack.AddPatch($"{path}.{name}", value);
    }

    public void InitAsrsProperty(ASRSDataClass asrs)
    {
        List<IPropertyEntry> entries = new List<IPropertyEntry>
        {
            new StringProperty("name", "이름", asrs.name)
            {
                IsReadOnly=true
            },
            new StringProperty("label", "라벨", asrs.label)
            {
                IsReadOnly=false
            }.Bind(
                setter: v => {asrs.label = v;SaveChange(asrs,v,"label"); }
            ),
            new Vector2Property("Position","X,Y 좌표(m)", new Vector2(asrs.physical.position.x,asrs.physical.position.z))
            {
                IsReadOnly=false
            }.Bind(
                setter: v => {asrs.physical.position.x = v.x;asrs.physical.position.z = v.y; SaveChange(asrs,v,"physical.position"); }
            ),
            new ButtonProperty("InitializeButton","초기 재고 설정",""){
            }.BindClick(()=>FindAnyObjectByType<InitialInventoryWindow>(FindObjectsInactive.Include).Open(asrs)),
            new BoolProperty("limited","용량 무제한", asrs.is_unlimited)
            {
                IsReadOnly=false
            }.Bind(
                setter: v => {asrs.is_unlimited=v; SaveChange(asrs,v,"is_unlimited"); }
            ),
            CreateRackLayoutGroup(asrs),
            new IntProperty("entityperblock","칸당 개체 개수", asrs.entity_count_per_block)
            {
                IsReadOnly=false
            }.Bind(
                setter: v => {asrs.entity_count_per_block=v; SaveChange(asrs,v,"entity_count_per_block"); }
            ),
            new EnumProperty("display_mode_ReceicingTimePolicy", "입고 시간 정책",asrs.receiving_time_policy.policy).Bind(
                setter: v=>{asrs.receiving_time_policy=PolicyFactory.Create(v.ToString());SaveChange(asrs,v.ToString(),"spawn_time_policy.type");}
                ),
            CreateReceivingTimePolicy_Constant(asrs),
            CreateReceivingTimePolicy_Normal(asrs),
            CreateReceivingTimePolicy_Uniform(asrs),
            CreateReceivingTimePolicy_Exponential(asrs),
            CreateReceivingTimePolicy_Triangular(asrs),

            new EnumProperty("display_mode_ShippingTimePolicy", "출고 시간 정책",asrs.shipping_time_policy.policy).Bind(
                setter: v=>{asrs.shipping_time_policy=PolicyFactory.Create(v.ToString());SaveChange(asrs,v.ToString(),"shipping_time_policy.type");}
                ),
            CreateShippingTimePolicy_Constant(asrs),
            CreateShippingTimePolicy_Normal(asrs),
            CreateShippingTimePolicy_Uniform(asrs),
            CreateShippingTimePolicy_Exponential(asrs),
            CreateShippingTimePolicy_Triangular(asrs),

            new EnumProperty("display_mode_StorageCostPolicy", "보관 비용 정책",asrs.storage_cost_policy.policy).Bind(
                setter: v=>{asrs.storage_cost_policy=PolicyFactory.Create(v.ToString());SaveChange(asrs,v.ToString(),"storage_cost_policy.type");}
                ),
            CreateStorageCostPolicy_Constant(asrs),
            CreateStorageCostPolicy_Normal(asrs),
            CreateStorageCostPolicy_Uniform(asrs),
            CreateStorageCostPolicy_Exponential(asrs),
            CreateStorageCostPolicy_Triangular(asrs),

            new EnumProperty("display_mode_HorizonSpeedPolicy", "크레인 수평 이동 속도",asrs.horizon_speed_policy.policy).Bind(
                setter: v=>{asrs.horizon_speed_policy=PolicyFactory.Create(v.ToString());SaveChange(asrs,v.ToString(),"horizon_speed_policy.type");}
                ),
            CreateHorizonSpeedPolicy_Constant(asrs),
            CreateHorizonSpeedPolicy_Normal(asrs),
            CreateHorizonSpeedPolicy_Uniform(asrs),
            CreateHorizonSpeedPolicy_Exponential(asrs),
            CreateHorizonSpeedPolicy_Triangular(asrs),

            new EnumProperty("display_mode_VerticalSpeedPolicy", "크레인 수직 이동 속도",asrs.vertical_speed_policy.policy).Bind(
                setter: v=>{asrs.vertical_speed_policy=PolicyFactory.Create(v.ToString());SaveChange(asrs,v.ToString(),"vertical_speed_policy.type");}
                ),
            CreateVerticalSpeedPolicy_Constant(asrs),
            CreateVerticalSpeedPolicy_Normal(asrs),
            CreateVerticalSpeedPolicy_Uniform(asrs),
            CreateVerticalSpeedPolicy_Exponential(asrs),
            CreateVerticalSpeedPolicy_Triangular(asrs),

            new EnumProperty("display_mode_ForkCycleTimePolicy", "크레인 포크 이동 시간",asrs.fork_cycle_time_policy.policy).Bind(
                setter: v=>{asrs.fork_cycle_time_policy=PolicyFactory.Create(v.ToString());SaveChange(asrs,v.ToString(),"fork_cycle_time_policy.type");}
                ),
            CreateForkCycleTimePolicy_Constant(asrs),
            CreateForkCycleTimePolicy_Normal(asrs),
            CreateForkCycleTimePolicy_Uniform(asrs),
            CreateForkCycleTimePolicy_Exponential(asrs),
            CreateForkCycleTimePolicy_Triangular(asrs),

            new BoolProperty("fms_input_enabled","입력에 FMS 사용", asrs.fms_input_enabled)
            {
                IsReadOnly=false
            }.Bind(
                setter: v => {asrs.fms_input_enabled=v; SaveChange(asrs,v,"fms_input_enabled"); }
            ),
            new BoolProperty("fms_output_enabled","출력에 FMS 사용", asrs.fms_output_enabled)
            {
                IsReadOnly=false
            }.Bind(
                setter: v => {asrs.fms_output_enabled=v; SaveChange(asrs,v,"fms_output_enabled"); }
            ),
        };
        propertyWindow.LoadMixedProperties(entries);

        HandleDisplayModeChanged_ReceivingTimePolicy(asrs.receiving_time_policy.policy.ToString());
        HandleDisplayModeChanged_ShippingTimePolicy(asrs.shipping_time_policy.policy.ToString());
        HandleDisplayModeChanged_StorageCostPolicy(asrs.storage_cost_policy.policy.ToString());
        HandleDisplayModeChanged_HorizonSpeedPolicy(asrs.horizon_speed_policy.policy.ToString());
        HandleDisplayModeChanged_VerticalSpeedPolicy(asrs.vertical_speed_policy.policy.ToString());
        HandleDisplayModeChanged_ForkCycleTimePolicy(asrs.fork_cycle_time_policy.policy.ToString());
    }

    private void OnPropertyValueChanged(object sender, PropertyValueChangedEventArgs e)
    {
        Debug.Log($"[PropertyChanged] Id:{e.PropertyId}, Type:{e.PropertyType}, Value:{e.NewValue}");

        // 동적 그룹 표시/비표시 테스트
        if (e.PropertyId == "display_mode_ReceicingTimePolicy")
        {
            string selectedMode = e.NewValue.ToString();
            HandleDisplayModeChanged_ReceivingTimePolicy(selectedMode);
        }
        if (e.PropertyId == "display_mode_ShippingTimePolicy")
        {
            string selectedMode = e.NewValue.ToString();
            HandleDisplayModeChanged_ShippingTimePolicy(selectedMode);
        }
        if (e.PropertyId == "display_mode_StorageCostPolicy")
        {
            string selectedMode = e.NewValue.ToString();
            HandleDisplayModeChanged_StorageCostPolicy(selectedMode);
        }
        if (e.PropertyId == "display_mode_HorizonSpeedPolicy")
        {
            string selectedMode = e.NewValue.ToString();
            HandleDisplayModeChanged_HorizonSpeedPolicy(selectedMode);
        }
        if (e.PropertyId == "display_mode_VerticalSpeedPolicy")
        {
            string selectedMode = e.NewValue.ToString();
            HandleDisplayModeChanged_VerticalSpeedPolicy(selectedMode);
        }
        if (e.PropertyId == "limited")
        {
            bool flag = Convert.ToBoolean(e.NewValue);
            propertyWindow.SetPropertyEnabled("x", !flag);
            propertyWindow.SetPropertyEnabled("z", !flag);
        }
    }

    private PropertyGroup CreateRackLayoutGroup(ASRSDataClass asrs)
    {
        var group = new PropertyGroup("asrslayout", "자동 창고 구조", isExpanded: true);
        group.AddItems(new IPropertyItem[]
        {
            new IntProperty("x", "행 개수(x)", asrs.asrs_layout.x)
            {
            }.Bind(
                setter: v => {asrs.asrs_layout.x = v;SaveChange(asrs,v,"asrs_layout.x"); }
            ),
            new IntProperty("y", "열 개수(y)", asrs.asrs_layout.y)
            {
                IsReadOnly=true
            }.Bind(
                setter: v => {asrs.asrs_layout.y = v;SaveChange(asrs,v,"asrs_layout.y"); }
            ),
            new IntProperty("z", "층 수(z)", asrs.asrs_layout.z)
            {
            }.Bind(
                setter: v => {asrs.asrs_layout.z = v;SaveChange(asrs,v,"asrs_layout.z"); }
            ),
        });
        return group;
    }

    #region 입고 시간 정책
    private PropertyGroup CreateReceivingTimePolicy_Constant(ASRSDataClass asrs)
    {
        var group = new PropertyGroup("ReceivingTimePolicy_Constant", "", isExpanded: true);
        group.AddItems(new IPropertyItem[]
        {
            new FloatProperty("ReceivingTimePolicy_Constant_Value", "상수 값", (asrs.receiving_time_policy as Policy_Constant)?.value??0f)
            {
            }.Bind(
                setter: v => {(asrs.receiving_time_policy as Policy_Constant).value = v;SaveChange(asrs,v,"receiving_time_policy.value"); }
            ),
        });
        return group;
    }

    private PropertyGroup CreateReceivingTimePolicy_Normal(ASRSDataClass asrs)
    {
        var group = new PropertyGroup("ReceivingTimePolicy_Normal", "", isExpanded: true);
        group.AddItems(new IPropertyItem[]
        {
            new FloatProperty("ReceivingTimePolicy_Normal_Mean", "정규 분포 표준치", (asrs.receiving_time_policy as Policy_Normal) ?.mean ?? 0f)
            {
            }.Bind(
                setter: v => {(asrs.receiving_time_policy as Policy_Normal).mean = v;SaveChange(asrs,v,"receiving_time_policy.mean"); }
            ),
            new FloatProperty("ReceivingTimePolicy_Normal_Gap", "정규 분포 표준 편차", (asrs.receiving_time_policy as Policy_Normal) ?.stddev ?? 0f)
            {
            }.Bind(
                setter: v => {(asrs.receiving_time_policy as Policy_Normal).stddev = v;SaveChange(asrs,v,"receiving_time_policy.stddev"); }
            ),
        });
        return group;
    }

    private PropertyGroup CreateReceivingTimePolicy_Uniform(ASRSDataClass asrs)
    {
        var group = new PropertyGroup("ReceivingTimePolicy_Uniform", "", isExpanded: true);
        group.AddItems(new IPropertyItem[]
        {
            new FloatProperty("ReceivingTimePolicy_Uniform_Min", "균등 분포 최소값", (asrs.receiving_time_policy as Policy_Uniform) ?.min_val ?? 0f)
            {
            }.Bind(
                setter: v => {(asrs.receiving_time_policy as Policy_Uniform).min_val = v;SaveChange(asrs,v,"receiving_time_policy.min_val"); }
            ),
            new FloatProperty("ReceivingTimePolicy_Uniform_Max", "균등 분포 최대값",  (asrs.receiving_time_policy as Policy_Uniform) ?.max_val ?? 0f)
            {
            }.Bind(
                setter: v => {(asrs.receiving_time_policy as Policy_Uniform).max_val = v;SaveChange(asrs,v,"receiving_time_policy.max_val"); }
            ),
        });
        return group;
    }

    private PropertyGroup CreateReceivingTimePolicy_Exponential(ASRSDataClass asrs)
    {
        var group = new PropertyGroup("ReceivingTimePolicy_Exponential", "", isExpanded: true);
        group.AddItems(new IPropertyItem[]
        {
            new FloatProperty("ReceivingTimePolicy_Exponential_Mean", "지수 분포 평균치",  (asrs.receiving_time_policy as Policy_Exponential) ?.mean ?? 0f)
            {
            }.Bind(
                setter: v => {(asrs.receiving_time_policy as Policy_Exponential).mean = v;SaveChange(asrs,v,"receiving_time_policy.mean"); }
            ),
        });
        return group;
    }

    private PropertyGroup CreateReceivingTimePolicy_Triangular(ASRSDataClass asrs)
    {
        var group = new PropertyGroup("ReceivingTimePolicy_Triangular", "", isExpanded: true);
        group.AddItems(new IPropertyItem[]
        {
            new FloatProperty("ReceivingTimePolicy_Triangular_Min", "지수 분포 최소값",  (asrs.receiving_time_policy as Policy_Triangular) ?.min_val ?? 0f)
            {
            }.Bind(
                setter: v => {(asrs.receiving_time_policy as Policy_Triangular).min_val = v;SaveChange(asrs,v,"receiving_time_policy.min_val"); }
            ),
            new FloatProperty("ReceivingTimePolicy_Triangular_Mean", "지수 분포 최빈값", (asrs.receiving_time_policy as Policy_Triangular) ?.mode ?? 0f)
            {
            }.Bind(
                setter: v => {(asrs.receiving_time_policy as Policy_Triangular).mode = v;SaveChange(asrs,v,"receiving_time_policy.mode"); }
            ),
            new FloatProperty("ReceivingTimePolicy_Triangular_Max", "지수 분포 최대값", (asrs.receiving_time_policy as Policy_Triangular) ?.max_val ?? 0f)
            {
            }.Bind(
                setter: v => {(asrs.receiving_time_policy as Policy_Triangular).max_val = v;SaveChange(asrs,v,"receiving_time_policy.max_val"); }
            ),
        });
        return group;
    }
    private void HandleDisplayModeChanged_ReceivingTimePolicy(string mode)
    {
        // 모든 조건부 그룹 숨김
        propertyWindow.SetGroupVisibility("ReceivingTimePolicy_Constant", false);
        propertyWindow.SetGroupVisibility("ReceivingTimePolicy_Normal", false);
        propertyWindow.SetGroupVisibility("ReceivingTimePolicy_Uniform", false);
        propertyWindow.SetGroupVisibility("ReceivingTimePolicy_Exponential", false);
        propertyWindow.SetGroupVisibility("ReceivingTimePolicy_Triangular", false);

        // 선택된 모드에 따라 해당 그룹만 표시
        switch (mode)
        {
            case "Constant":
                propertyWindow.SetGroupVisibility("ReceivingTimePolicy_Constant", true);
                break;
            case "Normal":
                propertyWindow.SetGroupVisibility("ReceivingTimePolicy_Normal", true);
                break;
            case "Uniform":
                propertyWindow.SetGroupVisibility("ReceivingTimePolicy_Uniform", true);
                break;
            case "Exponential":
                propertyWindow.SetGroupVisibility("ReceivingTimePolicy_Exponential", true);
                break;
            case "Triangular":
                propertyWindow.SetGroupVisibility("ReceivingTimePolicy_Triangular", true);
                break;
        }
    }
    #endregion

    #region 출고 시간 정책
    private PropertyGroup CreateShippingTimePolicy_Constant(ASRSDataClass asrs)
    {
        var group = new PropertyGroup("ShippingTimePolicy_Constant", "", isExpanded: true);
        group.AddItems(new IPropertyItem[]
        {
            new FloatProperty("ShippingTimePolicy_Constant_Value", "상수 값", (asrs.shipping_time_policy as Policy_Constant)?.value??0f)
            {
            }.Bind(
                setter: v => {(asrs.shipping_time_policy as Policy_Constant).value = v;SaveChange(asrs,v,"shipping_time_policy.value"); }
            ),
        });
        return group;
    }

    private PropertyGroup CreateShippingTimePolicy_Normal(ASRSDataClass asrs)
    {
        var group = new PropertyGroup("ShippingTimePolicy_Normal", "", isExpanded: true);
        group.AddItems(new IPropertyItem[]
        {
            new FloatProperty("ShippingTimePolicy_Normal_Mean", "정규 분포 표준치", (asrs.shipping_time_policy as Policy_Normal) ?.mean ?? 0f)
            {
            }.Bind(
                setter: v => {(asrs.shipping_time_policy as Policy_Normal).mean = v;SaveChange(asrs,v,"spawn_count_policy.mean"); }
            ),
            new FloatProperty("ShippingTimePolicy_Normal_Gap", "정규 분포 표준 편차", (asrs.shipping_time_policy as Policy_Normal) ?.stddev ?? 0f)
            {
            }.Bind(
                setter: v => {(asrs.shipping_time_policy as Policy_Normal).stddev = v;SaveChange(asrs,v,"spawn_count_policy.stddev"); }
            ),
        });
        return group;
    }

    private PropertyGroup CreateShippingTimePolicy_Uniform(ASRSDataClass asrs)
    {
        var group = new PropertyGroup("ShippingTimePolicy_Uniform", "", isExpanded: true);
        group.AddItems(new IPropertyItem[]
        {
            new FloatProperty("ShippingTimePolicy_Uniform_Min", "균등 분포 최소값", (asrs.shipping_time_policy as Policy_Uniform) ?.min_val ?? 0f)
            {
            }.Bind(
                setter: v => {(asrs.shipping_time_policy as Policy_Uniform).min_val = v;SaveChange(asrs,v,"spawn_count_policy.min_val"); }
            ),
            new FloatProperty("ShippingTimePolicy_Uniform_Max", "균등 분포 최대값",  (asrs.shipping_time_policy as Policy_Uniform) ?.max_val ?? 0f)
            {
            }.Bind(
                setter: v => {(asrs.shipping_time_policy as Policy_Uniform).max_val = v;SaveChange(asrs,v,"spawn_count_policy.max_val"); }
            ),
        });
        return group;
    }

    private PropertyGroup CreateShippingTimePolicy_Exponential(ASRSDataClass asrs)
    {
        var group = new PropertyGroup("ShippingTimePolicy_Exponential", "", isExpanded: true);
        group.AddItems(new IPropertyItem[]
        {
            new FloatProperty("ShippingTimePolicy_Exponential_Mean", "지수 분포 평균치",  (asrs.shipping_time_policy as Policy_Exponential) ?.mean ?? 0f)
            {
            }.Bind(
                setter: v => {(asrs.shipping_time_policy as Policy_Exponential).mean = v;SaveChange(asrs,v,"shipping_time_policy.mean"); }
            ),
        });
        return group;
    }

    private PropertyGroup CreateShippingTimePolicy_Triangular(ASRSDataClass asrs)
    {
        var group = new PropertyGroup("ShippingTimePolicy_Triangular", "", isExpanded: true);
        group.AddItems(new IPropertyItem[]
        {
            new FloatProperty("ShippingTimePolicy_Triangular_Min", "지수 분포 최소값",  (asrs.shipping_time_policy as Policy_Triangular) ?.min_val ?? 0f)
            {
            }.Bind(
                setter: v => {(asrs.shipping_time_policy as Policy_Triangular).min_val = v;SaveChange(asrs,v,"spawn_count_policy.min_val"); }
            ),
            new FloatProperty("ShippingTimePolicy_Triangular_Mean", "지수 분포 최빈값", (asrs.shipping_time_policy as Policy_Triangular) ?.mode ?? 0f)
            {
            }.Bind(
                setter: v => {(asrs.shipping_time_policy as Policy_Triangular).mode = v;SaveChange(asrs,v,"spawn_count_policy.mode"); }
            ),
            new FloatProperty("ShippingTimePolicy_Triangular_Max", "지수 분포 최대값", (asrs.shipping_time_policy as Policy_Triangular) ?.max_val ?? 0f)
            {
            }.Bind(
                setter: v => {(asrs.shipping_time_policy as Policy_Triangular).max_val = v;SaveChange(asrs,v,"spawn_count_policy.max_val"); }
            ),
        });
        return group;
    }
    private void HandleDisplayModeChanged_ShippingTimePolicy(string mode)
    {
        // 모든 조건부 그룹 숨김
        propertyWindow.SetGroupVisibility("ShippingTimePolicy_Constant", false);
        propertyWindow.SetGroupVisibility("ShippingTimePolicy_Normal", false);
        propertyWindow.SetGroupVisibility("ShippingTimePolicy_Uniform", false);
        propertyWindow.SetGroupVisibility("ShippingTimePolicy_Exponential", false);
        propertyWindow.SetGroupVisibility("ShippingTimePolicy_Triangular", false);

        // 선택된 모드에 따라 해당 그룹만 표시
        switch (mode)
        {
            case "Constant":
                propertyWindow.SetGroupVisibility("ShippingTimePolicy_Constant", true);
                break;
            case "Normal":
                propertyWindow.SetGroupVisibility("ShippingTimePolicy_Normal", true);
                break;
            case "Uniform":
                propertyWindow.SetGroupVisibility("ShippingTimePolicy_Uniform", true);
                break;
            case "Exponential":
                propertyWindow.SetGroupVisibility("ShippingTimePolicy_Exponential", true);
                break;
            case "Triangular":
                propertyWindow.SetGroupVisibility("ShippingTimePolicy_Triangular", true);
                break;
        }
    }
    #endregion

    #region 보관 비용 정책
    private PropertyGroup CreateStorageCostPolicy_Constant(ASRSDataClass asrs)
    {
        var group = new PropertyGroup("StorageCostPolicy_Constant", "", isExpanded: true);
        group.AddItems(new IPropertyItem[]
        {
            new FloatProperty("StorageCostPolicy_Constant_Value", "상수 값", (asrs.storage_cost_policy as Policy_Constant) ?.value ?? 0f)
            {
            }.Bind(
                setter: v => {(asrs.storage_cost_policy as Policy_Constant).value = v;SaveChange(asrs,v,"storage_cost_policy.value"); }
            ),
        });
        return group;
    }

    private PropertyGroup CreateStorageCostPolicy_Normal(ASRSDataClass asrs)
    {
        var group = new PropertyGroup("StorageCostPolicy_Normal", "", isExpanded: true);
        group.AddItems(new IPropertyItem[]
        {
            new FloatProperty("StorageCostPolicy_Normal_Mean", "정규 분포 표준치", (asrs.storage_cost_policy as Policy_Normal) ?.mean ?? 0f)
            {
            }.Bind(
                setter: v => {(asrs.storage_cost_policy as Policy_Normal).mean = v;SaveChange(asrs,v,"storage_cost_policy.mean"); }
            ),
            new FloatProperty("StorageCostPolicy_Normal_Gap", "정규 분포 표준 편차", (asrs.storage_cost_policy as Policy_Normal) ?.stddev ?? 0f)
            {
            }.Bind(
                setter: v => {(asrs.storage_cost_policy as Policy_Normal).stddev = v;SaveChange(asrs,v,"storage_cost_policy.stddev"); }
            ),
        });
        return group;
    }

    private PropertyGroup CreateStorageCostPolicy_Uniform(ASRSDataClass asrs)
    {
        var group = new PropertyGroup("StorageCostPolicy_Uniform", "", isExpanded: true);
        group.AddItems(new IPropertyItem[]
        {
            new FloatProperty("StorageCostPolicy_Uniform_Min", "균등 분포 최소값", (asrs.storage_cost_policy as Policy_Uniform) ?.min_val ?? 0f)
            {
            }.Bind(
                setter: v => {(asrs.storage_cost_policy as Policy_Uniform).min_val = v;SaveChange(asrs,v,"storage_cost_policy.min_val"); }
            ),
            new FloatProperty("StorageCostPolicy_Uniform_Max", "균등 분포 최대값", (asrs.storage_cost_policy as Policy_Uniform) ?.max_val ?? 0f)
            {
            }.Bind(
                setter: v => {(asrs.storage_cost_policy as Policy_Uniform).max_val = v;SaveChange(asrs,v,"storage_cost_policy.max_val"); }
            ),
        });
        return group;
    }

    private PropertyGroup CreateStorageCostPolicy_Exponential(ASRSDataClass asrs)
    {
        var group = new PropertyGroup("StorageCostPolicy_Exponential", "", isExpanded: true);
        group.AddItems(new IPropertyItem[]
        {
            new FloatProperty("StorageCostPolicy_Exponential_Mean", "지수 분포 평균치", (asrs.storage_cost_policy as Policy_Exponential) ?.mean ?? 0f)
            {
            }.Bind(
                setter: v => {(asrs.storage_cost_policy as Policy_Exponential).mean = v;SaveChange(asrs,v,"storage_cost_policy.mean"); }
            ),
        });
        return group;
    }

    private PropertyGroup CreateStorageCostPolicy_Triangular(ASRSDataClass asrs)
    {
        var group = new PropertyGroup("StorageCostPolicy_Triangular", "", isExpanded: true);
        group.AddItems(new IPropertyItem[]
        {
            new FloatProperty("StorageCostPolicy_Triangular_Min", "지수 분포 최소값", (asrs.storage_cost_policy as Policy_Triangular) ?.min_val ?? 0f)
            {
            }.Bind(
                setter: v => {(asrs.storage_cost_policy as Policy_Triangular).min_val = v;SaveChange(asrs,v,"storage_cost_policy.min_val"); }
            ),
            new FloatProperty("StorageCostPolicy_Triangular_Mean", "지수 분포 최빈값", (asrs.storage_cost_policy as Policy_Triangular) ?.mode ?? 0f)
            {
            }.Bind(
                setter: v => {(asrs.storage_cost_policy as Policy_Triangular).mode = v;SaveChange(asrs,v,"storage_cost_policy.mode"); }
            ),
            new FloatProperty("StorageCostPolicy_Triangular_Max", "지수 분포 최대값", (asrs.storage_cost_policy as Policy_Triangular) ?.max_val ?? 0f)
            {
            }.Bind(
                setter: v => {(asrs.storage_cost_policy as Policy_Triangular).max_val = v;SaveChange(asrs,v,"storage_cost_policy.max_val"); }
            ),
        });
        return group;
    }

    private void HandleDisplayModeChanged_StorageCostPolicy(string mode)
    {
        // 모든 조건부 그룹 숨김
        propertyWindow.SetGroupVisibility("StorageCostPolicy_Constant", false);
        propertyWindow.SetGroupVisibility("StorageCostPolicy_Normal", false);
        propertyWindow.SetGroupVisibility("StorageCostPolicy_Uniform", false);
        propertyWindow.SetGroupVisibility("StorageCostPolicy_Exponential", false);
        propertyWindow.SetGroupVisibility("StorageCostPolicy_Triangular", false);
        // 선택된 모드에 따라 해당 그룹만 표시
        switch (mode)
        {
            case "Constant":
                propertyWindow.SetGroupVisibility("StorageCostPolicy_Constant", true);
                break;
            case "Normal":
                propertyWindow.SetGroupVisibility("StorageCostPolicy_Normal", true);
                break;
            case "Uniform":
                propertyWindow.SetGroupVisibility("StorageCostPolicy_Uniform", true);
                break;
            case "Exponential":
                propertyWindow.SetGroupVisibility("StorageCostPolicy_Exponential", true);
                break;
            case "Triangular":
                propertyWindow.SetGroupVisibility("StorageCostPolicy_Triangular", true);
                break;
        }
    }
    #endregion

    #region 크레인 수평 이동 속도
    private PropertyGroup CreateHorizonSpeedPolicy_Constant(ASRSDataClass asrs)
    {
        var group = new PropertyGroup("HorizonSpeedPolicy_Constant", "", isExpanded: true);
        group.AddItems(new IPropertyItem[]
        {
            new FloatProperty("HorizonSpeedPolicy_Constant_Value", "상수 값", (asrs.horizon_speed_policy as Policy_Constant) ?.value ?? 0f)
            {
            }.Bind(
                setter: v => {(asrs.horizon_speed_policy as Policy_Constant).value = v;SaveChange(asrs,v,"horizon_speed_policy.value"); }
            ),
        });
        return group;
    }

    private PropertyGroup CreateHorizonSpeedPolicy_Normal(ASRSDataClass asrs)
    {
        var group = new PropertyGroup("HorizonSpeedPolicy_Normal", "", isExpanded: true);
        group.AddItems(new IPropertyItem[]
        {
            new FloatProperty("HorizonSpeedPolicy_Normal_Mean", "정규 분포 표준치", (asrs.horizon_speed_policy as Policy_Normal) ?.mean ?? 0f)
            {
            }.Bind(
                setter: v => {(asrs.horizon_speed_policy as Policy_Normal).mean = v;SaveChange(asrs,v,"horizon_speed_policy.mean"); }
            ),
            new FloatProperty("HorizonSpeedPolicy_Normal_Gap", "정규 분포 표준 편차", (asrs.horizon_speed_policy as Policy_Normal) ?.stddev ?? 0f)
            {
            }.Bind(
                setter: v => {(asrs.horizon_speed_policy as Policy_Normal).stddev = v;SaveChange(asrs,v,"horizon_speed_policy.stddev"); }
            ),
        });
        return group;
    }

    private PropertyGroup CreateHorizonSpeedPolicy_Uniform(ASRSDataClass asrs)
    {
        var group = new PropertyGroup("HorizonSpeedPolicy_Uniform", "", isExpanded: true);
        group.AddItems(new IPropertyItem[]
        {
            new FloatProperty("HorizonSpeedPolicy_Uniform_Min", "균등 분포 최소값", (asrs.horizon_speed_policy as Policy_Uniform) ?.min_val ?? 0f)
            {
            }.Bind(
                setter: v => {(asrs.horizon_speed_policy as Policy_Uniform).min_val = v;SaveChange(asrs,v,"horizon_speed_policy.min_val"); }
            ),
            new FloatProperty("HorizonSpeedPolicy_Uniform_Max", "균등 분포 최대값", (asrs.horizon_speed_policy as Policy_Uniform) ?.max_val ?? 0f)
            {
            }.Bind(
                setter: v => {(asrs.horizon_speed_policy as Policy_Uniform).max_val = v;SaveChange(asrs,v,"horizon_speed_policy.max_val"); }
            ),
        });
        return group;
    }

    private PropertyGroup CreateHorizonSpeedPolicy_Exponential(ASRSDataClass asrs)
    {
        var group = new PropertyGroup("HorizonSpeedPolicy_Exponential", "", isExpanded: true);
        group.AddItems(new IPropertyItem[]
        {
            new FloatProperty("HorizonSpeedPolicy_Exponential_Mean", "지수 분포 평균치", (asrs.horizon_speed_policy as Policy_Exponential) ?.mean ?? 0f)
            {
            }.Bind(
                setter: v => {(asrs.horizon_speed_policy as Policy_Exponential).mean = v;SaveChange(asrs,v,"horizon_speed_policy.mean"); }
            ),
        });
        return group;
    }

    private PropertyGroup CreateHorizonSpeedPolicy_Triangular(ASRSDataClass asrs)
    {
        var group = new PropertyGroup("HorizonSpeedPolicy_Triangular", "", isExpanded: true);
        group.AddItems(new IPropertyItem[]
        {
            new FloatProperty("HorizonSpeedPolicy_Triangular_Min", "지수 분포 최소값", (asrs.horizon_speed_policy as Policy_Triangular) ?.min_val ?? 0f)
            {
            }.Bind(
                setter: v => {(asrs.horizon_speed_policy as Policy_Triangular).min_val = v;SaveChange(asrs,v,"horizon_speed_policy.min_val"); }
            ),
            new FloatProperty("HorizonSpeedPolicy_Triangular_Mean", "지수 분포 최빈값", (asrs.horizon_speed_policy as Policy_Triangular) ?.mode ?? 0f)
            {
            }.Bind(
                setter: v => {(asrs.horizon_speed_policy as Policy_Triangular).mode = v;SaveChange(asrs,v,"horizon_speed_policy.mode"); }
            ),
            new FloatProperty("HorizonSpeedPolicy_Triangular_Max", "지수 분포 최대값", (asrs.horizon_speed_policy as Policy_Triangular) ?.max_val ?? 0f)
            {
            }.Bind(
                setter: v => {(asrs.horizon_speed_policy as Policy_Triangular).max_val = v;SaveChange(asrs,v,"horizon_speed_policy.max_val"); }
            ),
        });
        return group;
    }

    private void HandleDisplayModeChanged_HorizonSpeedPolicy(string mode)
    {
        // 모든 조건부 그룹 숨김
        propertyWindow.SetGroupVisibility("HorizonSpeedPolicy_Constant", false);
        propertyWindow.SetGroupVisibility("HorizonSpeedPolicy_Normal", false);
        propertyWindow.SetGroupVisibility("HorizonSpeedPolicy_Uniform", false);
        propertyWindow.SetGroupVisibility("HorizonSpeedPolicy_Exponential", false);
        propertyWindow.SetGroupVisibility("HorizonSpeedPolicy_Triangular", false);
        // 선택된 모드에 따라 해당 그룹만 표시
        switch (mode)
        {
            case "Constant":
                propertyWindow.SetGroupVisibility("HorizonSpeedPolicy_Constant", true);
                break;
            case "Normal":
                propertyWindow.SetGroupVisibility("HorizonSpeedPolicy_Normal", true);
                break;
            case "Uniform":
                propertyWindow.SetGroupVisibility("HorizonSpeedPolicy_Uniform", true);
                break;
            case "Exponential":
                propertyWindow.SetGroupVisibility("HorizonSpeedPolicy_Exponential", true);
                break;
            case "Triangular":
                propertyWindow.SetGroupVisibility("HorizonSpeedPolicy_Triangular", true);
                break;
        }
    }
    #endregion

    #region 크레인 수직 이동 속도
    private PropertyGroup CreateVerticalSpeedPolicy_Constant(ASRSDataClass asrs)
    {
        var group = new PropertyGroup("VerticalSpeedPolicy_Constant", "", isExpanded: true);
        group.AddItems(new IPropertyItem[]
        {
            new FloatProperty("VerticalSpeedPolicy_Constant_Value", "상수 값", (asrs.vertical_speed_policy as Policy_Constant) ?.value ?? 0f)
            {
            }.Bind(
                setter: v => {(asrs.vertical_speed_policy as Policy_Constant).value = v;SaveChange(asrs,v,"vertical_speed_policy.value"); }
            ),
        });
        return group;
    }

    private PropertyGroup CreateVerticalSpeedPolicy_Normal(ASRSDataClass asrs)
    {
        var group = new PropertyGroup("VerticalSpeedPolicy_Normal", "", isExpanded: true);
        group.AddItems(new IPropertyItem[]
        {
            new FloatProperty("VerticalSpeedPolicy_Normal_Mean", "정규 분포 표준치", (asrs.vertical_speed_policy as Policy_Normal) ?.mean ?? 0f)
            {
            }.Bind(
                setter: v => {(asrs.vertical_speed_policy as Policy_Normal).mean = v;SaveChange(asrs,v,"vertical_speed_policy.mean"); }
            ),
            new FloatProperty("VerticalSpeedPolicy_Normal_Gap", "정규 분포 표준 편차", (asrs.vertical_speed_policy as Policy_Normal) ?.stddev ?? 0f)
            {
            }.Bind(
                setter: v => {(asrs.vertical_speed_policy as Policy_Normal).stddev = v;SaveChange(asrs,v,"vertical_speed_policy.stddev"); }
            ),
        });
        return group;
    }

    private PropertyGroup CreateVerticalSpeedPolicy_Uniform(ASRSDataClass asrs)
    {
        var group = new PropertyGroup("VerticalSpeedPolicy_Uniform", "", isExpanded: true);
        group.AddItems(new IPropertyItem[]
        {
            new FloatProperty("VerticalSpeedPolicy_Uniform_Min", "균등 분포 최소값", (asrs.vertical_speed_policy as Policy_Uniform) ?.min_val ?? 0f)
            {
            }.Bind(
                setter: v => {(asrs.vertical_speed_policy as Policy_Uniform).min_val = v;SaveChange(asrs,v,"vertical_speed_policy.min_val"); }
            ),
            new FloatProperty("VerticalSpeedPolicy_Uniform_Max", "균등 분포 최대값", (asrs.vertical_speed_policy as Policy_Uniform) ?.max_val ?? 0f)
            {
            }.Bind(
                setter: v => {(asrs.vertical_speed_policy as Policy_Uniform).max_val = v;SaveChange(asrs,v,"vertical_speed_policy.max_val"); }
            ),
        });
        return group;
    }

    private PropertyGroup CreateVerticalSpeedPolicy_Exponential(ASRSDataClass asrs)
    {
        var group = new PropertyGroup("VerticalSpeedPolicy_Exponential", "", isExpanded: true);
        group.AddItems(new IPropertyItem[]
        {
            new FloatProperty("VerticalSpeedPolicy_Exponential_Mean", "지수 분포 평균치", (asrs.vertical_speed_policy as Policy_Exponential) ?.mean ?? 0f)
            {
            }.Bind(
                setter: v => {(asrs.vertical_speed_policy as Policy_Exponential).mean = v;SaveChange(asrs,v,"vertical_speed_policy.mean"); }
            ),
        });
        return group;
    }

    private PropertyGroup CreateVerticalSpeedPolicy_Triangular(ASRSDataClass asrs)
    {
        var group = new PropertyGroup("VerticalSpeedPolicy_Triangular", "", isExpanded: true);
        group.AddItems(new IPropertyItem[]
        {
            new FloatProperty("VerticalSpeedPolicy_Triangular_Min", "지수 분포 최소값", (asrs.vertical_speed_policy as Policy_Triangular) ?.min_val ?? 0f)
            {
            }.Bind(
                setter: v => {(asrs.vertical_speed_policy as Policy_Triangular).min_val = v;SaveChange(asrs,v,"vertical_speed_policy.min_val"); }
            ),
            new FloatProperty("VerticalSpeedPolicy_Triangular_Mean", "지수 분포 최빈값", (asrs.vertical_speed_policy as Policy_Triangular) ?.mode ?? 0f)
            {
            }.Bind(
                setter: v => {(asrs.vertical_speed_policy as Policy_Triangular).mode = v;SaveChange(asrs,v,"vertical_speed_policy.mode"); }
            ),
            new FloatProperty("VerticalSpeedPolicy_Triangular_Max", "지수 분포 최대값", (asrs.vertical_speed_policy as Policy_Triangular) ?.max_val ?? 0f)
            {
            }.Bind(
                setter: v => {(asrs.vertical_speed_policy as Policy_Triangular).max_val = v;SaveChange(asrs,v,"vertical_speed_policy.max_val"); }
            ),
        });
        return group;
    }

    private void HandleDisplayModeChanged_VerticalSpeedPolicy(string mode)
    {
        // 모든 조건부 그룹 숨김
        propertyWindow.SetGroupVisibility("VerticalSpeedPolicy_Constant", false);
        propertyWindow.SetGroupVisibility("VerticalSpeedPolicy_Normal", false);
        propertyWindow.SetGroupVisibility("VerticalSpeedPolicy_Uniform", false);
        propertyWindow.SetGroupVisibility("VerticalSpeedPolicy_Exponential", false);
        propertyWindow.SetGroupVisibility("VerticalSpeedPolicy_Triangular", false);
        // 선택된 모드에 따라 해당 그룹만 표시
        switch (mode)
        {
            case "Constant":
                propertyWindow.SetGroupVisibility("VerticalSpeedPolicy_Constant", true);
                break;
            case "Normal":
                propertyWindow.SetGroupVisibility("VerticalSpeedPolicy_Normal", true);
                break;
            case "Uniform":
                propertyWindow.SetGroupVisibility("VerticalSpeedPolicy_Uniform", true);
                break;
            case "Exponential":
                propertyWindow.SetGroupVisibility("VerticalSpeedPolicy_Exponential", true);
                break;
            case "Triangular":
                propertyWindow.SetGroupVisibility("VerticalSpeedPolicy_Triangular", true);
                break;
        }
    }
    #endregion

    #region 크레인 포크 이동 시간
    private PropertyGroup CreateForkCycleTimePolicy_Constant(ASRSDataClass asrs)
    {
        var group = new PropertyGroup("ForkCycleTimePolicy_Constant", "", isExpanded: true);
        group.AddItems(new IPropertyItem[]
        {
            new FloatProperty("ForkCycleTimePolicy_Constant_Value", "상수 값", (asrs.fork_cycle_time_policy as Policy_Constant) ?.value ?? 0f)
            {
            }.Bind(
                setter: v => {(asrs.fork_cycle_time_policy as Policy_Constant).value = v;SaveChange(asrs,v,"fork_cycle_time_policy.value"); }
            ),
        });
        return group;
    }

    private PropertyGroup CreateForkCycleTimePolicy_Normal(ASRSDataClass asrs)
    {
        var group = new PropertyGroup("ForkCycleTimePolicy_Normal", "", isExpanded: true);
        group.AddItems(new IPropertyItem[]
        {
            new FloatProperty("ForkCycleTimePolicy_Normal_Mean", "정규 분포 표준치", (asrs.fork_cycle_time_policy as Policy_Normal) ?.mean ?? 0f)
            {
            }.Bind(
                setter: v => {(asrs.fork_cycle_time_policy as Policy_Normal).mean = v;SaveChange(asrs,v,"fork_cycle_time_policy.mean"); }
            ),
            new FloatProperty("ForkCycleTimePolicy_Normal_Gap", "정규 분포 표준 편차", (asrs.fork_cycle_time_policy as Policy_Normal) ?.stddev ?? 0f)
            {
            }.Bind(
                setter: v => {(asrs.fork_cycle_time_policy as Policy_Normal).stddev = v;SaveChange(asrs,v,"fork_cycle_time_policy.stddev"); }
            ),
        });
        return group;
    }

    private PropertyGroup CreateForkCycleTimePolicy_Uniform(ASRSDataClass asrs)
    {
        var group = new PropertyGroup("ForkCycleTimePolicy_Uniform", "", isExpanded: true);
        group.AddItems(new IPropertyItem[]
        {
            new FloatProperty("ForkCycleTimePolicy_Uniform_Min", "균등 분포 최소값", (asrs.fork_cycle_time_policy as Policy_Uniform) ?.min_val ?? 0f)
            {
            }.Bind(
                setter: v => {(asrs.fork_cycle_time_policy as Policy_Uniform).min_val = v;SaveChange(asrs,v,"fork_cycle_time_policy.min_val"); }
            ),
            new FloatProperty("ForkCycleTimePolicy_Uniform_Max", "균등 분포 최대값", (asrs.fork_cycle_time_policy as Policy_Uniform) ?.max_val ?? 0f)
            {
            }.Bind(
                setter: v => {(asrs.fork_cycle_time_policy as Policy_Uniform).max_val = v;SaveChange(asrs,v,"fork_cycle_time_policy.max_val"); }
            ),
        });
        return group;
    }

    private PropertyGroup CreateForkCycleTimePolicy_Exponential(ASRSDataClass asrs)
    {
        var group = new PropertyGroup("ForkCycleTimePolicy_Exponential", "", isExpanded: true);
        group.AddItems(new IPropertyItem[]
        {
            new FloatProperty("ForkCycleTimePolicy_Exponential_Mean", "지수 분포 평균치", (asrs.fork_cycle_time_policy as Policy_Exponential) ?.mean ?? 0f)
            {
            }.Bind(
                setter: v => {(asrs.fork_cycle_time_policy as Policy_Exponential).mean = v;SaveChange(asrs,v,"fork_cycle_time_policy.mean"); }
            ),
        });
        return group;
    }

    private PropertyGroup CreateForkCycleTimePolicy_Triangular(ASRSDataClass asrs)
    {
        var group = new PropertyGroup("ForkCycleTimePolicy_Triangular", "", isExpanded: true);
        group.AddItems(new IPropertyItem[]
        {
            new FloatProperty("ForkCycleTimePolicy_Triangular_Min", "지수 분포 최소값", (asrs.fork_cycle_time_policy as Policy_Triangular) ?.min_val ?? 0f)
            {
            }.Bind(
                setter: v => {(asrs.fork_cycle_time_policy as Policy_Triangular).min_val = v;SaveChange(asrs,v,"fork_cycle_time_policy.min_val"); }
            ),
            new FloatProperty("ForkCycleTimePolicy_Triangular_Mean", "지수 분포 최빈값", (asrs.fork_cycle_time_policy as Policy_Triangular) ?.mode ?? 0f)
            {
            }.Bind(
                setter: v => {(asrs.fork_cycle_time_policy as Policy_Triangular).mode = v;SaveChange(asrs,v,"fork_cycle_time_policy.mode"); }
            ),
            new FloatProperty("ForkCycleTimePolicy_Triangular_Max", "지수 분포 최대값", (asrs.fork_cycle_time_policy as Policy_Triangular) ?.max_val ?? 0f)
            {
            }.Bind(
                setter: v => {(asrs.vertical_speed_policy as Policy_Triangular).max_val = v;SaveChange(asrs,v,"vertical_speed_policy.max_val"); }
            ),
        });
        return group;
    }

    private void HandleDisplayModeChanged_ForkCycleTimePolicy(string mode)
    {
        // 모든 조건부 그룹 숨김
        propertyWindow.SetGroupVisibility("ForkCycleTimePolicy_Constant", false);
        propertyWindow.SetGroupVisibility("ForkCycleTimePolicy_Normal", false);
        propertyWindow.SetGroupVisibility("ForkCycleTimePolicy_Uniform", false);
        propertyWindow.SetGroupVisibility("ForkCycleTimePolicy_Exponential", false);
        propertyWindow.SetGroupVisibility("ForkCycleTimePolicy_Triangular", false);
        // 선택된 모드에 따라 해당 그룹만 표시
        switch (mode)
        {
            case "Constant":
                propertyWindow.SetGroupVisibility("ForkCycleTimePolicy_Constant", true);
                break;
            case "Normal":
                propertyWindow.SetGroupVisibility("ForkCycleTimePolicy_Normal", true);
                break;
            case "Uniform":
                propertyWindow.SetGroupVisibility("ForkCycleTimePolicy_Uniform", true);
                break;
            case "Exponential":
                propertyWindow.SetGroupVisibility("ForkCycleTimePolicy_Exponential", true);
                break;
            case "Triangular":
                propertyWindow.SetGroupVisibility("ForkCycleTimePolicy_Triangular", true);
                break;
        }
    }
    #endregion
}