using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace System.Reflection
{
   

    [AttributeUsage(AttributeTargets.Assembly)]
    public class ProcessorAssemblyArchitecture : Attribute
    {
        public ProcessorAssemblyArchitecture() { Architecture = Undefined; }
        public ProcessorAssemblyArchitecture(string arch) 
        {
            Type t = typeof(ProcessorAssemblyArchitecture);
            FieldInfo[] fields = t.GetFields(BindingFlags.Public | BindingFlags.Static);

            bool found = false;
            foreach (FieldInfo field in fields)
            {
                string o = field.GetValue(null).ToString();
                if (arch == o)
                {
                    found = true;
                    break;
                }
            }
            if (!found) { Architecture = Undefined; }
            else { Architecture = arch; }
        }
        string _Architecture;
        public string Architecture { get { return _Architecture; } private set { _Architecture = value; } }
        #region processor architecture
        /// <summary>
        /// Represents an undefined processor arcitecture
        /// </summary>
        public const string Undefined = "Undefined";
        /// <summary>
        /// Represents a 32-bit processor arcitecture
        /// </summary>
        public const string x86 = "x86";
        /// <summary>
        /// Represents a 64-bit processor arcitecture
        /// </summary>
        public const string x64 = "x64";
        /// <summary>
        /// Represents a 64-bit processor arcitecture (this is equivalent to x64, this is just Amd's nameing convention)
        /// </summary>
        public const string Amd64 = x64;
        /// <summary>
        /// Represents am Itanium 64-bit processor arcitecture
        /// </summary>
        public const string Ia64 = "Ia64";
        /// <summary>
        /// Represents a 32-bit and 64-bit processor arcitecture (it will run in 32-bit mode for 32-bit systems and 64-bit for non-32bit systems)
        /// </summary>
        public const string AnyCpu = "AnyCpu";
        /// <summary>
        /// Represents a 32-bit and 64-bit processor arcitecture (refered to as AnyCpu)
        /// </summary>
        public const string Msil = AnyCpu;
        #endregion

        public static string GetProcessorArchitecture(Assembly t)
        {           
            string assembly_arch = Undefined;

            // get architecture
            ProcessorArchitecture o = t.GetName().ProcessorArchitecture;
            if (o == ProcessorArchitecture.None)
                assembly_arch = Undefined;

            switch (o)
            {                
                case ProcessorArchitecture.Amd64: assembly_arch = Amd64; break;
                case ProcessorArchitecture.IA64: assembly_arch = Ia64; break;
                case ProcessorArchitecture.MSIL: assembly_arch = AnyCpu; break;
                case ProcessorArchitecture.X86: assembly_arch = x86; break;
                case ProcessorArchitecture.None:  break;
                default: assembly_arch = Undefined; break;
            }           
                           
            return assembly_arch;
        }

    }
}