// Copyright (c) .NET Foundation and contributors. All rights reserved.
// Licensed under the MIT license. See LICENSE file in the project root for full license information.

using System;
using System.Diagnostics;
using Mono.Cecil;

namespace Mono.Linker.Steps
{
    // This discovers types attributed with certain serialization attributes, to match the old behavior
    // of xamarin-android. It is not meant to be complete. Unlike xamarin-andorid:
    // - this will only discover attributed types that are marked
    // - this will discover types in non-"link" assemblies as well
    public class DiscoverSerializationHandler : IMarkHandler
    {
        LinkContext? _context;
        LinkContext Context
        {
            get
            {
                Debug.Assert(_context != null);
                return _context;
            }
        }

        public void Initialize(LinkContext context, MarkContext markContext)
        {
            _context = context;
            markContext.RegisterMarkTypeAction(ProcessType);
            markContext.RegisterMarkMethodAction(CheckForSerializerActivation);
        }

        void CheckForSerializerActivation(MethodDefinition method)
        {
            var type = method.DeclaringType;

            if (!Context.SerializationMarker.IsActive(SerializerKind.DataContractSerializer) &&
                method.IsConstructor && !method.IsStatic &&
                ((type.Namespace == "System.Runtime.Serialization" && type.Name == "DataContractSerializer") ||
                (type.Namespace == "System.Runtime.Serialization.Json" && type.Name == "DataContractJsonSerializer")))
            {

                Context.SerializationMarker.Activate(SerializerKind.DataContractSerializer);
            }

            if (!Context.SerializationMarker.IsActive(SerializerKind.XmlSerializer) &&
                method.IsConstructor && !method.IsStatic &&
                type.Namespace == "System.Xml.Serialization" &&
                type.Name == "XmlSerializer")
            {

                Context.SerializationMarker.Activate(SerializerKind.XmlSerializer);
            }
        }

        void ProcessType(TypeDefinition type)
        {
            ProcessAttributeProvider(type);

            if (type.HasFields)
            {
                foreach (var field in type.Fields)
                    ProcessAttributeProvider(field);
            }

            if (type.HasProperties)
            {
                foreach (var property in type.Properties)
                    ProcessAttributeProvider(property);
            }

            if (type.HasMethods)
            {
                foreach (var method in type.Methods)
                    ProcessAttributeProvider(method);
            }

            if (type.HasEvents)
            {
                foreach (var @event in type.Events)
                {
                    ProcessAttributeProvider(@event);
                }
            }
        }

        void ProcessAttributeProvider(ICustomAttributeProvider provider)
        {
            if (!provider.HasCustomAttributes)
                return;

            var serializedFor = SerializerKind.None;

            foreach (var attribute in provider.CustomAttributes)
            {
                if (IsPreservedSerializationAttribute(provider, attribute, out SerializerKind serializerKind))
                    serializedFor |= serializerKind;
            }

            if (serializedFor == SerializerKind.None)
                return;

            if (serializedFor.HasFlag(SerializerKind.DataContractSerializer))
                Context.SerializationMarker.TrackForSerialization(provider, SerializerKind.DataContractSerializer);
            if (serializedFor.HasFlag(SerializerKind.XmlSerializer))
                Context.SerializationMarker.TrackForSerialization(provider, SerializerKind.XmlSerializer);
        }

        static bool IsPreservedSerializationAttribute(ICustomAttributeProvider provider, CustomAttribute attribute, out SerializerKind serializerKind)
        {
            TypeReference attributeType = attribute.Constructor.DeclaringType;
            serializerKind = SerializerKind.None;

            switch (attributeType.Namespace)
            {

                // http://bugzilla.xamarin.com/show_bug.cgi?id=1415
                // http://msdn.microsoft.com/en-us/library/system.runtime.serialization.datamemberattribute.aspx
                case "System.Runtime.Serialization":
                    var serialized = false;
                    if (provider is PropertyDefinition or FieldDefinition or EventDefinition)
                        serialized = attributeType.Name == "DataMemberAttribute";
                    else if (provider is TypeDefinition)
                        serialized = attributeType.Name == "DataContractAttribute";

                    if (serialized)
                    {
                        serializerKind = SerializerKind.DataContractSerializer;
                        return true;
                    }
                    break;

                // http://msdn.microsoft.com/en-us/library/83y7df3e.aspx
                case "System.Xml.Serialization":
                    var attributeName = attributeType.Name;
                    if (attributeName.StartsWith("Xml", StringComparison.Ordinal)
                        && attributeName.EndsWith("Attribute", StringComparison.Ordinal)
                        && attributeName != "XmlIgnoreAttribute")
                    {
                        serializerKind = SerializerKind.XmlSerializer;
                        return true;
                    }
                    break;

            }
            ;

            return false;
        }
    }
}