XRLib/Assets/Scripts/Simulator/UI/PropertyWindow/RobotArmProperty.cs

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

public class RobotArmProperty : MonoBehaviour
{
    [SerializeField]
    private PropertyWindow propertyWindow;

    private void Awake()
    {
        propertyWindow.PropertyValueChanged += OnPropertyValueChanged;
    }

    public void SetPropertyWindow(ComponentType type,ComponentDataBase data)
    {
        if (PlayerPropertyDataBase.isPlaying)
        {
            return;
        }
        InitRobotArmProperty(data as RobotArmDataClass);
    }

    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 InitRobotArmProperty(RobotArmDataClass robotArm)
    {
        var entries = new List<IPropertyEntry>
        {
            new StringProperty("name", "이름", robotArm.name)
            {
                IsReadOnly=true
            },
            new StringProperty("label", "라벨", robotArm.label)
            {
                IsReadOnly=false
            }.Bind(
                setter: v => {robotArm.label = v;SaveChange(robotArm,v,"label"); }
            ),
            CreatePositionGroup(robotArm),
        };

        entries.AddRange(PolicyPropertyBuilder.CreatePolicyEntries(
            "RobotArmSpeedPolicy", "로봇팔 속도 정책", "display_mode_RobotArmSpeedPolicy",
            () => robotArm.robot_arm_speed_policy, v => robotArm.robot_arm_speed_policy = v,
            "robot_arm_speed_policy", robotArm, SaveChange));

        entries.AddRange(PolicyPropertyBuilder.CreatePolicyEntries(
            "FailureRatePolicy", "고장률 정책", "display_mode_FailureRatePolicy",
            () => robotArm.failure_rate_policy, v => robotArm.failure_rate_policy = v,
            "failure_rate_policy", robotArm, SaveChange));

        entries.AddRange(PolicyPropertyBuilder.CreatePolicyEntries(
            "RepairTimePolicy", "수리 시간 정책", "display_mode_RepairTimePolicy",
            () => robotArm.repair_time_policy, v => robotArm.repair_time_policy = v,
            "repair_time_policy", robotArm, SaveChange));

        entries.Add(CreateInputsGroup(robotArm));
        entries.Add(CreateOutputsGroup(robotArm));
        entries.Add(CreateRequireResourceGroup(robotArm));

        propertyWindow.LoadMixedProperties(entries);

        PolicyPropertyBuilder.HandleDisplayModeChanged(propertyWindow, "RobotArmSpeedPolicy", robotArm.robot_arm_speed_policy.policy.ToString());
        PolicyPropertyBuilder.HandleDisplayModeChanged(propertyWindow, "FailureRatePolicy", robotArm.failure_rate_policy.policy.ToString());
        PolicyPropertyBuilder.HandleDisplayModeChanged(propertyWindow, "RepairTimePolicy", robotArm.repair_time_policy.policy.ToString());

        CreateCostGroup(robotArm);
    }

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

        PolicyPropertyBuilder.TryHandleDisplayModeChanged(e, propertyWindow, "display_mode_RobotArmSpeedPolicy", "RobotArmSpeedPolicy");
        PolicyPropertyBuilder.TryHandleDisplayModeChanged(e, propertyWindow, "display_mode_FailureRatePolicy", "FailureRatePolicy");
        PolicyPropertyBuilder.TryHandleDisplayModeChanged(e, propertyWindow, "display_mode_RepairTimePolicy", "RepairTimePolicy");
    }

    private PropertyGroup CreatePositionGroup(RobotArmDataClass robotArm)
    {
        return PropertyHelper.CreatePositionGroup("robotArm_position", robotArm, propertyWindow, SaveChange);
    }

    PropertyGroup CreateInputsGroup(RobotArmDataClass robotArm)
    {
        var group = new PropertyGroup("InputConnect", "입력 연결", isExpanded: true);
        foreach(var input in robotArm.inputs)
        {
            var property = new IntProperty($"{input.target}prefab", input.target, input.required_items).Bind
            (
                setter: v => { input.required_items = v; SaveChange(input, v, "required_items"); }
            );
            group.AddItem(property);
        }
        return group;
    }

    PropertyGroup CreateOutputsGroup(RobotArmDataClass robotArm)
    {
        var group = new PropertyGroup("OutputConnect", "출력 연결", isExpanded: true);
        foreach (var output in robotArm.outputs)
        {
            var property = new IntProperty($"{output.target}prefab", output.target, output.required_items).Bind
            (
                setter: v => { output.required_items = v; SaveChange(output, v, "required_items"); }
            );
            group.AddItem(property);
        }
        return group;
    }

    private PropertyGroup CreateRequireResourceGroup(RobotArmDataClass robotArm)
    {
        var group = new PropertyGroup("RequireResource", "자원 할당", isExpanded: true);

        var requiredIndex = BuildRequiredIndex(robotArm);

        int count = 0;
        foreach (var resource in ComponentsManager.logicDetailData.infrastructure.resources)
        {
            if (!string.Equals(resource.type, "worker"))
                continue;

            var key = resource.name;
            bool isRequired = key != null && requiredIndex.ContainsKey(key);

            var property = new BoolProperty($"required_resource[{count++}]", resource.label, isRequired);

            property.Bind(setter: v =>
            {
                SetRequiredResource(robotArm, key, v);
            });

            group.AddItem(property);
        }

        return group;
    }

    private void SetRequiredResource(RobotArmDataClass robotArm, string resourceName, bool required)
    {
        if (string.IsNullOrEmpty(resourceName)) return;

        robotArm.required_resources ??= new List<Required_Resources>();

        int idx = robotArm.required_resources.FindIndex(x => x != null && x.name == resourceName);

        if (required)
        {
            if (idx < 0)
            {
                robotArm.required_resources.Add(new Required_Resources
                {
                    name = resourceName,
                    count = 1,
                    selection_policy = "random"
                });
            }
        }
        else
        {
            if (idx >= 0)
                robotArm.required_resources.RemoveAt(idx);
        }
    }

    private Dictionary<string, Required_Resources> BuildRequiredIndex(RobotArmDataClass robotArm)
    {
        var dict = new Dictionary<string, Required_Resources>(StringComparer.Ordinal);

        if (robotArm.required_resources == null) return dict;

        foreach (var rr in robotArm.required_resources)
        {
            if (rr?.name == null) continue;
            dict[rr.name] = rr;
        }
        return dict;
    }

    PropertyGroup CreateCostGroup(RobotArmDataClass robotArm)
    {
        var group = new PropertyGroup("CostSetting", "비용 설정", isExpanded: true);
        group.AddItems(new IPropertyItem[]
        {
            new IntProperty("Operating_Cost_Per_Hour", "시간당 가동 비용", robotArm.operating_cost_per_hour)
            {
            }.Bind(
                setter: v => {robotArm.operating_cost_per_hour = v;SaveChange(robotArm,v,"operating_cost_per_hour"); }
            ),
            new IntProperty("Idle_Cost_Per_Hour", "시간당 대기 비용", robotArm.idle_cost_per_hour)
            {
            }.Bind(
                setter: v => {robotArm.idle_cost_per_hour = v;SaveChange(robotArm,v,"idle_cost_per_hour"); }
            ),
            new IntProperty("Failure_Cost", "고장 1회 손실 비용", robotArm.failure_cost)
            {
            }.Bind(
                setter: v => {robotArm.failure_cost = v;SaveChange(robotArm,v,"failure_cost"); }
            ),
            new IntProperty("repair_cost_per_hour", "시간당 수리 비용", robotArm.repair_cost_per_hour)
            {
            }.Bind(
                setter: v => {robotArm.repair_cost_per_hour = v;SaveChange(robotArm,v,"repair_cost_per_hour"); }
            ),
});
        return group;
    }

    private void OnDestroy()
    {
        if (propertyWindow != null)
            propertyWindow.PropertyValueChanged -= OnPropertyValueChanged;
    }
}