// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
 
using System.Collections;
using System.ComponentModel;
using System.ComponentModel.Design.Serialization;
using System.Globalization;
using static System.TrimmingConstants;
 
namespace System.Windows.Forms.PropertyGridInternal;
 
internal partial class MergePropertyDescriptor : PropertyDescriptor
{
    private readonly PropertyDescriptor[] _descriptors;
 
    private bool? _localizable;
    private bool? _readOnly;
    private bool? _canReset;
 
    private MultiMergeCollection? _collection;
 
    public MergePropertyDescriptor(PropertyDescriptor[] descriptors)
        : base(descriptors[0].Name, attrs: null)
    {
        _descriptors = descriptors;
    }
 
    public override Type ComponentType => _descriptors[0].ComponentType;
 
    public override TypeConverter Converter
    {
        [RequiresUnreferencedCode(PropertyDescriptorPropertyTypeMessage)]
        get => _descriptors[0].Converter;
    }
 
    public override string DisplayName => _descriptors[0].DisplayName;
 
    public override bool IsLocalizable
    {
        get
        {
            if (!_localizable.HasValue)
            {
                _localizable = true;
                foreach (PropertyDescriptor pd in _descriptors)
                {
                    if (!pd.IsLocalizable)
                    {
                        _localizable = false;
                        break;
                    }
                }
            }
 
            return _localizable.Value;
        }
    }
 
    public override bool IsReadOnly
    {
        get
        {
            if (!_readOnly.HasValue)
            {
                _readOnly = false;
                foreach (PropertyDescriptor pd in _descriptors)
                {
                    if (pd.IsReadOnly)
                    {
                        _readOnly = true;
                        break;
                    }
                }
            }
 
            return _readOnly.Value;
        }
    }
 
    public override Type PropertyType => _descriptors[0].PropertyType;
 
    public PropertyDescriptor this[int index] => _descriptors[index];
 
    public override bool CanResetValue(object component)
    {
        Debug.Assert(component is Array, "MergePropertyDescriptor::CanResetValue called with non-array value");
        if (!_canReset.HasValue)
        {
            _canReset = true;
            var a = (Array)component;
            for (int i = 0; i < _descriptors.Length; i++)
            {
                if (!_descriptors[i].CanResetValue(GetPropertyOwnerForComponent(a, i)!))
                {
                    _canReset = false;
                    break;
                }
            }
        }
 
        return _canReset.Value;
    }
 
    /// <summary>
    ///  This method attempts to copy the given value so unique values are always passed to each object.
    ///  If the value cannot be copied the original value will be returned.
    /// </summary>
    private static object? CopyValue(object? value)
    {
        // Null is always OK.
        if (value is null)
        {
            return value;
        }
 
        Type type = value.GetType();
 
        // Value types are always copies.
        if (type.IsValueType)
        {
            return value;
        }
 
        object? clonedValue = null;
 
        // ICloneable is the next easiest thing.
        if (value is ICloneable clone)
        {
            clonedValue = clone.Clone();
 
            if (clonedValue is not null)
            {
                return clonedValue;
            }
        }
 
        // Next, access the type converter.
        TypeConverter converter = TypeDescriptor.GetConverter(value);
        if (converter.CanConvertTo(typeof(InstanceDescriptor)))
        {
            // Instance descriptors provide full fidelity unless they are marked as incomplete.
            var instanceDescriptor = (InstanceDescriptor?)converter.ConvertTo(
                null,
                CultureInfo.InvariantCulture,
                value,
                typeof(InstanceDescriptor));
 
            if (instanceDescriptor is not null && instanceDescriptor.IsComplete)
            {
                clonedValue = instanceDescriptor.Invoke();
                if (clonedValue is not null)
                {
                    return clonedValue;
                }
            }
        }
 
        // If that didn't work, try conversion to/from string.
        if (converter.CanConvertTo(typeof(string)) && converter.CanConvertFrom(typeof(string)))
        {
            string stringRepresentation = converter.ConvertToInvariantString(value)!;
            clonedValue = converter.ConvertFromInvariantString(stringRepresentation);
            if (clonedValue is not null)
            {
                return clonedValue;
            }
        }
 
        if (clonedValue is not null)
        {
            return clonedValue;
        }
 
        // We failed. This object's reference will be set on each property.
        return value;
    }
 
    protected override AttributeCollection CreateAttributeCollection() => new MergedAttributeCollection(this);
 
    private object? GetPropertyOwnerForComponent(Array a, int i)
    {
        object? propertyOwner = a.GetValue(i);
        if (propertyOwner is ICustomTypeDescriptor descriptor)
        {
            propertyOwner = descriptor.GetPropertyOwner(_descriptors[i]);
        }
 
        return propertyOwner;
    }
 
    [RequiresUnreferencedCode($"{EditorRequiresUnreferencedCode} {PropertyDescriptorPropertyTypeMessage}")]
    public override object? GetEditor(Type editorBaseType) => _descriptors[0].GetEditor(editorBaseType);
 
    public override object? GetValue(object? component)
    {
        Debug.Assert(component is Array, "MergePropertyDescriptor::GetValue called with non-array value");
        return GetValue((Array)component, out _);
    }
 
    public object? GetValue(Array components, out bool allEqual)
    {
        allEqual = true;
        object? @object = _descriptors[0].GetValue(GetPropertyOwnerForComponent(components, 0));
 
        if (@object is ICollection collection)
        {
            if (_collection is null)
            {
                _collection = new MultiMergeCollection(collection);
            }
            else if (_collection.Locked)
            {
                return _collection;
            }
            else
            {
                _collection.SetItems(collection);
            }
        }
 
        for (int i = 1; i < _descriptors.Length; i++)
        {
            object? currentObject = _descriptors[i].GetValue(GetPropertyOwnerForComponent(components, i));
 
            if (_collection is not null)
            {
                if (!_collection.ReinitializeIfNotEqual((ICollection)currentObject!))
                {
                    allEqual = false;
                    return null;
                }
            }
            else if ((@object is null && currentObject is null) || (@object is not null && @object.Equals(currentObject)))
            {
                continue;
            }
            else
            {
                allEqual = false;
                return null;
            }
        }
 
        if (allEqual && _collection is not null && _collection.Count == 0)
        {
            return null;
        }
 
        return _collection ?? @object;
    }
 
    internal object?[] GetValues(Array components)
    {
        object?[] values = new object?[components.Length];
 
        for (int i = 0; i < components.Length; i++)
        {
            values[i] = _descriptors[i].GetValue(GetPropertyOwnerForComponent(components, i));
        }
 
        return values;
    }
 
    public override void ResetValue(object component)
    {
        Debug.Assert(component is Array, "MergePropertyDescriptor::ResetValue called with non-array value");
        var array = (Array)component;
        for (int i = 0; i < _descriptors.Length; i++)
        {
            _descriptors[i].ResetValue(GetPropertyOwnerForComponent(array, i)!);
        }
    }
 
    private void SetCollectionValues(Array a, IList listValue)
    {
        try
        {
            _collection?.Locked = true;
 
            // Now we have to copy the value into each property.
            object[] values = new object[listValue.Count];
 
            listValue.CopyTo(values, 0);
 
            for (int i = 0; i < _descriptors.Length; i++)
            {
                if (_descriptors[i].GetValue(GetPropertyOwnerForComponent(a, i)) is not IList properties)
                {
                    continue;
                }
 
                properties.Clear();
                foreach (object value in values)
                {
                    properties.Add(value);
                }
            }
        }
        finally
        {
            _collection?.Locked = false;
        }
    }
 
    public override void SetValue(object? component, object? value)
    {
        Debug.Assert(component is Array, "MergePropertyDescriptor::SetValue called with non-array value");
        var array = (Array)component;
        if (value is IList list && typeof(IList).IsAssignableFrom(PropertyType))
        {
            SetCollectionValues(array, list);
        }
        else
        {
            for (int i = 0; i < _descriptors.Length; i++)
            {
                object? clonedValue = CopyValue(value);
                _descriptors[i].SetValue(GetPropertyOwnerForComponent(array, i), clonedValue);
            }
        }
    }
 
    public override bool ShouldSerializeValue(object component)
    {
        Debug.Assert(component is Array, "MergePropertyDescriptor::ShouldSerializeValue called with non-array value");
        var array = (Array)component;
        for (int i = 0; i < _descriptors.Length; i++)
        {
            if (!_descriptors[i].ShouldSerializeValue(GetPropertyOwnerForComponent(array, i)!))
            {
                return false;
            }
        }
 
        return true;
    }
}