using System;
using System.Collections.Generic;
using UVC.UI.Window.PropertyWindow;

public static class PolicyPropertyBuilder
{
    public static List<IPropertyEntry> CreatePolicyEntries(
        string groupPrefix,
        string displayLabel,
        string displayModeId,
        Func<Policy_Base> policyGetter,
        Action<Policy_Base> policySetter,
        string savePath,
        object dataObject,
        Action<object, object, string> saveChange)
    {
        var entries = new List<IPropertyEntry>();

        entries.Add(new EnumProperty(displayModeId, displayLabel, policyGetter().policy).Bind(
            setter: v =>
            {
                var newPolicy = PolicyFactory.Create(v.ToString());
                policySetter(newPolicy);
                saveChange(dataObject, PolicyFactory.Create(v.ToString()), savePath);
            }));

        entries.Add(CreateConstantGroup(groupPrefix, policyGetter, savePath, dataObject, saveChange));
        entries.Add(CreateNormalGroup(groupPrefix, policyGetter, savePath, dataObject, saveChange));
        entries.Add(CreateUniformGroup(groupPrefix, policyGetter, savePath, dataObject, saveChange));
        entries.Add(CreateExponentialGroup(groupPrefix, policyGetter, savePath, dataObject, saveChange));
        entries.Add(CreateTriangularGroup(groupPrefix, policyGetter, savePath, dataObject, saveChange));

        return entries;
    }

    public static void HandleDisplayModeChanged(PropertyWindow pw, string groupPrefix, string mode)
    {
        string[] types = { "Constant", "Normal", "Uniform", "Exponential", "Triangular" };
        foreach (var t in types)
            pw.SetGroupVisibility($"{groupPrefix}_{t}", string.Equals(mode, t));
    }

    public static bool TryHandleDisplayModeChanged(
        PropertyValueChangedEventArgs e, PropertyWindow pw, string displayModeId, string groupPrefix)
    {
        if (e.PropertyId != displayModeId) return false;
        HandleDisplayModeChanged(pw, groupPrefix, e.NewValue.ToString());
        return true;
    }

    static PropertyGroup CreateConstantGroup(string prefix, Func<Policy_Base> getter,
        string savePath, object data, Action<object, object, string> save)
    {
        var g = new PropertyGroup($"{prefix}_Constant", "", isExpanded: true);
        g.AddItems(new IPropertyItem[]
        {
            new FloatProperty($"{prefix}_Constant_Value", "상수 값",
                (getter() as Policy_Constant)?.value ?? 0f)
            .Bind(setter: v => { (getter() as Policy_Constant).value = v; save(data, v, $"{savePath}.value"); })
        });
        return g;
    }

    static PropertyGroup CreateNormalGroup(string prefix, Func<Policy_Base> getter,
        string savePath, object data, Action<object, object, string> save)
    {
        var g = new PropertyGroup($"{prefix}_Normal", "", isExpanded: true);
        g.AddItems(new IPropertyItem[]
        {
            new FloatProperty($"{prefix}_Normal_Mean", "정규 분포 표준치",
                (getter() as Policy_Normal)?.mean ?? 0f)
            .Bind(setter: v => { (getter() as Policy_Normal).mean = v; save(data, v, $"{savePath}.mean"); }),
            new FloatProperty($"{prefix}_Normal_Gap", "정규 분포 표준 편차",
                (getter() as Policy_Normal)?.stddev ?? 0f)
            .Bind(setter: v => { (getter() as Policy_Normal).stddev = v; save(data, v, $"{savePath}.stddev"); })
        });
        return g;
    }

    static PropertyGroup CreateUniformGroup(string prefix, Func<Policy_Base> getter,
        string savePath, object data, Action<object, object, string> save)
    {
        var g = new PropertyGroup($"{prefix}_Uniform", "", isExpanded: true);
        g.AddItems(new IPropertyItem[]
        {
            new FloatProperty($"{prefix}_Uniform_Min", "균등 분포 최소값",
                (getter() as Policy_Uniform)?.min_val ?? 0f)
            .Bind(setter: v => { (getter() as Policy_Uniform).min_val = v; save(data, v, $"{savePath}.min_val"); }),
            new FloatProperty($"{prefix}_Uniform_Max", "균등 분포 최대값",
                (getter() as Policy_Uniform)?.max_val ?? 0f)
            .Bind(setter: v => { (getter() as Policy_Uniform).max_val = v; save(data, v, $"{savePath}.max_val"); })
        });
        return g;
    }

    static PropertyGroup CreateExponentialGroup(string prefix, Func<Policy_Base> getter,
        string savePath, object data, Action<object, object, string> save)
    {
        var g = new PropertyGroup($"{prefix}_Exponential", "", isExpanded: true);
        g.AddItems(new IPropertyItem[]
        {
            new FloatProperty($"{prefix}_Exponential_Mean", "지수 분포 평균치",
                (getter() as Policy_Exponential)?.mean ?? 0f)
            .Bind(setter: v => { (getter() as Policy_Exponential).mean = v; save(data, v, $"{savePath}.mean"); })
        });
        return g;
    }

    static PropertyGroup CreateTriangularGroup(string prefix, Func<Policy_Base> getter,
        string savePath, object data, Action<object, object, string> save)
    {
        var g = new PropertyGroup($"{prefix}_Triangular", "", isExpanded: true);
        g.AddItems(new IPropertyItem[]
        {
            new FloatProperty($"{prefix}_Triangular_Min", "삼각 분포 최소값",
                (getter() as Policy_Triangular)?.min_val ?? 0f)
            .Bind(setter: v => { (getter() as Policy_Triangular).min_val = v; save(data, v, $"{savePath}.min_val"); }),
            new FloatProperty($"{prefix}_Triangular_Mean", "삼각 분포 최빈값",
                (getter() as Policy_Triangular)?.mode ?? 0f)
            .Bind(setter: v => { (getter() as Policy_Triangular).mode = v; save(data, v, $"{savePath}.mode"); }),
            new FloatProperty($"{prefix}_Triangular_Max", "삼각 분포 최대값",
                (getter() as Policy_Triangular)?.max_val ?? 0f)
            .Bind(setter: v => { (getter() as Policy_Triangular).max_val = v; save(data, v, $"{savePath}.max_val"); })
        });
        return g;
    }
}