// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
// See the LICENSE file in the project root for more information.
 
#nullable disable
 
using System;
using System.Runtime.InteropServices;
using System.Threading;
using Microsoft.CodeAnalysis;
using Microsoft.VisualStudio.LanguageServices.Implementation.CodeModel.Collections;
using Microsoft.VisualStudio.LanguageServices.Implementation.CodeModel.Interop;
using Microsoft.VisualStudio.LanguageServices.Implementation.Interop;
using Microsoft.VisualStudio.LanguageServices.Implementation.Utilities;
using Roslyn.Utilities;
 
namespace Microsoft.VisualStudio.LanguageServices.Implementation.CodeModel.InternalElements
{
    [ComVisible(true)]
    [ComDefaultInterface(typeof(EnvDTE80.CodeParameter2))]
    public sealed class CodeParameter : AbstractCodeElement, EnvDTE.CodeParameter, EnvDTE80.CodeParameter2, IParameterKind
    {
        internal static EnvDTE.CodeParameter Create(
            CodeModelState state,
            AbstractCodeMember parent,
            string name)
        {
            var element = new CodeParameter(state, parent, name);
            return (EnvDTE.CodeParameter)ComAggregate.CreateAggregatedObject(element);
        }
 
        private readonly ParentHandle<AbstractCodeMember> _parentHandle;
        private readonly string _name;
 
        private CodeParameter(
            CodeModelState state,
            AbstractCodeMember parent,
            string name)
            : base(state, parent.FileCodeModel)
        {
            _parentHandle = new ParentHandle<AbstractCodeMember>(parent);
            _name = name;
        }
 
        private IParameterSymbol ParameterSymbol
        {
            get { return (IParameterSymbol)LookupSymbol(); }
        }
 
        private void UpdateNodeAndReacquireParentNodeKey<T>(Action<SyntaxNode, T> parameterUpdater, T value)
        {
            void updater(SyntaxNode n, T v)
            {
                var parentNode = _parentHandle.Value.LookupNode();
                var parentNodePath = new SyntaxPath(parentNode);
 
                parameterUpdater(n, v);
 
                _parentHandle.Value.ReacquireNodeKey(parentNodePath, CancellationToken.None);
            }
 
            UpdateNode(updater, value);
        }
 
        protected override EnvDTE.CodeElements GetCollection()
            => GetCollection<CodeParameter>(Parent);
 
        protected override string GetName()
            => _name;
 
        protected override string GetFullName()
        {
            var node = LookupNode();
            if (node == null)
            {
                return string.Empty;
            }
 
            return CodeModelService.GetParameterFullName(node);
        }
 
        internal override bool TryLookupNode(out SyntaxNode node)
        {
            node = null;
 
            var parentNode = _parentHandle.Value.LookupNode();
            if (parentNode == null)
            {
                return false;
            }
 
            if (!CodeModelService.TryGetParameterNode(parentNode, _name, out var parameterNode))
            {
                return false;
            }
 
            node = parameterNode;
            return node != null;
        }
 
        public override EnvDTE.vsCMElement Kind
        {
            get { return EnvDTE.vsCMElement.vsCMElementParameter; }
        }
 
        public override object Parent
        {
            get { return _parentHandle.Value; }
        }
 
        EnvDTE.CodeElement EnvDTE.CodeParameter.Parent
        {
            get { return (EnvDTE.CodeElement)Parent; }
        }
 
        EnvDTE.CodeElement EnvDTE80.CodeParameter2.Parent
        {
            get { return (EnvDTE.CodeElement)Parent; }
        }
 
        public override EnvDTE.CodeElements Children
        {
            get { return this.Attributes; }
        }
 
        public EnvDTE.CodeElements Attributes
        {
            get { return AttributeCollection.Create(this.State, this); }
        }
 
        public string DocComment
        {
            get
            {
                return string.Empty;
            }
 
            set
            {
                throw Exceptions.ThrowENotImpl();
            }
        }
 
        public EnvDTE.CodeTypeRef Type
        {
            get
            {
                return CodeTypeRef.Create(this.State, this, GetProjectId(), ParameterSymbol.Type);
            }
 
            set
            {
                UpdateNodeAndReacquireParentNodeKey(FileCodeModel.UpdateType, value);
            }
        }
 
        public EnvDTE80.vsCMParameterKind ParameterKind
        {
            get
            {
                return CodeModelService.GetParameterKind(LookupNode());
            }
 
            set
            {
                UpdateNodeAndReacquireParentNodeKey(FileCodeModel.UpdateParameterKind, value);
            }
        }
 
        public string DefaultValue
        {
            get
            {
                return CodeModelService.GetInitExpression(LookupNode());
            }
 
            set
            {
                UpdateNode(FileCodeModel.UpdateInitExpression, value);
            }
        }
 
        public EnvDTE.CodeAttribute AddAttribute(string name, string value, object position)
        {
            return FileCodeModel.EnsureEditor(() =>
            {
                return FileCodeModel.AddAttribute(LookupNode(), name, value, position);
            });
        }
 
        void IParameterKind.SetParameterPassingMode(PARAMETER_PASSING_MODE passingMode)
            => this.ParameterKind = this.CodeModelService.UpdateParameterKind(ParameterKind, passingMode);
 
        void IParameterKind.SetParameterArrayDimensions(int dimensions)
        {
            var type = this.ParameterSymbol.Type;
            var compilation = this.FileCodeModel.GetCompilation();
 
            var elementType = type is IArrayTypeSymbol
                ? ((IArrayTypeSymbol)type).ElementType
                : type;
 
            // The original C# implementation had a weird behavior where it wold allow setting array dimensions
            // to 0 to create an array with a single rank.
            var rank = Math.Max(dimensions, 1);
            var newType = compilation.CreateArrayTypeSymbol(elementType, rank);
 
            this.Type = CodeTypeRef.Create(this.State, this, GetProjectId(), newType);
        }
 
        int IParameterKind.GetParameterArrayCount()
        {
            var arrayType = this.ParameterSymbol.Type as IArrayTypeSymbol;
            var count = 0;
 
            while (arrayType != null)
            {
                count++;
                arrayType = arrayType.ElementType as IArrayTypeSymbol;
            }
 
            return count;
        }
 
        int IParameterKind.GetParameterArrayDimensions(int index)
        {
            if (index < 0)
            {
                throw Exceptions.ThrowEInvalidArg();
            }
 
            var arrayType = this.ParameterSymbol.Type as IArrayTypeSymbol;
            var count = 0;
 
            while (count < index && arrayType != null)
            {
                count++;
                arrayType = arrayType.ElementType as IArrayTypeSymbol;
            }
 
            if (arrayType == null)
            {
                throw Exceptions.ThrowEInvalidArg();
            }
 
            return arrayType.Rank;
        }
 
        PARAMETER_PASSING_MODE IParameterKind.GetParameterPassingMode()
        {
            var parameterKind = this.ParameterKind;
 
            if ((parameterKind & EnvDTE80.vsCMParameterKind.vsCMParameterKindRef) != 0)
            {
                return PARAMETER_PASSING_MODE.cmParameterTypeInOut;
            }
            else if ((parameterKind & EnvDTE80.vsCMParameterKind.vsCMParameterKindOut) != 0)
            {
                return PARAMETER_PASSING_MODE.cmParameterTypeOut;
            }
            else
            {
                return PARAMETER_PASSING_MODE.cmParameterTypeIn;
            }
        }
    }
}