// 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.Generic;
using System.Diagnostics;
using System.Reflection;

namespace System.CodeDom.Compiler
{
    public sealed class CompilerInfo
    {
        internal readonly IDictionary<string, string> _providerOptions = new Dictionary<string, string>();
        internal string _codeDomProviderTypeName; // This can never by null
        internal CompilerParameters _compilerParams; // This can never by null
        internal string[] _compilerLanguages; // This can never by null
        internal string[] _compilerExtensions; // This can never by null
        private Type _type;

        private CompilerInfo() { } // Not createable

        public string[] GetLanguages() => (string[])_compilerLanguages.Clone();

        public string[] GetExtensions() => (string[])_compilerExtensions.Clone();

        public Type CodeDomProviderType
        {
            get
            {
                if (_type == null)
                {
                    lock (this)
                    {
                        _type ??= Type.GetType(_codeDomProviderTypeName);
                    }
                }

                return _type;
            }
        }

        public bool IsCodeDomProviderTypeValid => Type.GetType(_codeDomProviderTypeName) != null;

        public CodeDomProvider CreateProvider()
        {
            // if the provider defines an IDictionary<string, string> ctor and
            // provider options have been provided then call that and give it the
            // provider options dictionary.  Otherwise call the normal one.

            Debug.Assert(_providerOptions != null, "Created CompilerInfo w/ null _providerOptions");

            if (_providerOptions.Count > 0)
            {
                ConstructorInfo ci = CodeDomProviderType.GetConstructor(new Type[] { typeof(IDictionary<string, string>) });
                if (ci != null)
                {
                    return (CodeDomProvider)ci.Invoke(new object[] { _providerOptions });
                }
            }

            return (CodeDomProvider)Activator.CreateInstance(CodeDomProviderType);
        }

        public CodeDomProvider CreateProvider(IDictionary<string, string> providerOptions)
        {
            ArgumentNullException.ThrowIfNull(providerOptions);

            ConstructorInfo constructor = CodeDomProviderType.GetConstructor(new Type[] { typeof(IDictionary<string, string>) });
            if (constructor != null)
            {
                return (CodeDomProvider)constructor.Invoke(new object[] { providerOptions });
            }
            else
            {
                throw new InvalidOperationException(SR.Format(SR.Provider_does_not_support_options, CodeDomProviderType));
            }
        }

        public CompilerParameters CreateDefaultCompilerParameters() => CloneCompilerParameters();

        internal CompilerInfo(CompilerParameters compilerParams, string codeDomProviderTypeName)
        {
            _codeDomProviderTypeName = codeDomProviderTypeName;
            _compilerParams = compilerParams ?? new CompilerParameters();
        }

        public override int GetHashCode() => _codeDomProviderTypeName.GetHashCode();

        public override bool Equals(object o)
        {
            return
                o is CompilerInfo other &&
                CodeDomProviderType == other.CodeDomProviderType &&
                CompilerParams.WarningLevel == other.CompilerParams.WarningLevel &&
                CompilerParams.IncludeDebugInformation == other.CompilerParams.IncludeDebugInformation &&
                CompilerParams.CompilerOptions == other.CompilerParams.CompilerOptions;
        }

        private CompilerParameters CloneCompilerParameters()
        {
            CompilerParameters copy = new CompilerParameters();
            copy.IncludeDebugInformation = _compilerParams.IncludeDebugInformation;
            copy.TreatWarningsAsErrors = _compilerParams.TreatWarningsAsErrors;
            copy.WarningLevel = _compilerParams.WarningLevel;
            copy.CompilerOptions = _compilerParams.CompilerOptions;
            return copy;
        }

        internal CompilerParameters CompilerParams => _compilerParams;
    }
}