using System;
using System.Collections.Generic;
using System.Globalization;
using System.Text;

using JetBrains.ReSharper.Psi;
using JetBrains.ReSharper.Psi.Util;

using MbUnit.ReSharperRunner.Helper;

namespace MbUnit.ReSharperRunner.Explorer
{
    internal class FileHelper
    {
        #region ITypeMember

        internal static string GetMethodName(IMethod method)
        {
            var builder = new StringBuilder();
            builder.Append(method.ShortName);
            builder.Append("(");
            var parameters = method.Parameters;
            for (int i = 0; i < parameters.Count; i++)
            {
                IParameter parameter = parameters[i];
                if (i > 0)
                {
                    builder.Append(",");
                }
                builder.Append(parameter.Type.ToString());
                builder.Append(" ");
                builder.Append(parameter.ShortName);
            }
            builder.Append(")");
            return builder.ToString();
        }

        #endregion

        internal static bool IsTestMethod(IMethod method)
        {
            if ((method.GetAccessRights() != AccessRights.PUBLIC
                 || method.IsStatic
                 || method.IsAbstract
                 || !PredefinedType.IsVoid(method.ReturnType)))
            {
                return false;
            }
            return HasAttributeFromType(method, AttributesNames.TestBaseAttributeName);
        }

        internal static bool IsTestFixture(ITypeElement typeElement)
        {
            if ((typeElement is IClass || typeElement is IStruct))
            {
                return HasAttributeFromType(typeElement, AttributesNames.TestFixtureBaseAttributeName);
            }
            return false;
        }

        internal static string GetTestFixtureName(ITypeElement typeElement)
        {
            IList<IAttributeInstance> attributes =
                GetAttributesFromType(typeElement, AttributesNames.TestFixtureBaseAttributeName);
            foreach (IAttributeInstance instance in attributes)
            {
                return StringHelper.GetShortTypeName(instance.CLRName);
            }
            return string.Empty;
        }

        internal static string GetTestName(ITypeMember typeElement)
        {
            IList<IAttributeInstance> attributes =
                GetAttributesFromType(typeElement, AttributesNames.TestBaseAttributeName);
            foreach (IAttributeInstance instance in attributes)
            {
                if (instance.Constructor.Parameters.Count == 0)
                {
                    return StringHelper.GetShortTypeName(instance.CLRName);
                }
            }
            return string.Empty;
        }

        private static bool HasAttributeFromType(IAttributesOwner owner, string baseAttributeName)
        {
            IList<IAttributeInstance> attributeInstances = GetAttributesFromType(owner, baseAttributeName);
            return attributeInstances.Count > 0;
        }

        private static IList<IAttributeInstance> GetAttributesFromType(IAttributesOwner owner, string baseType)
        {
            var foundAttributes = new List<IAttributeInstance>();
            IList<IAttributeInstance> attributes = owner.GetAttributeInstances(false);
            foreach (IAttributeInstance attributeInstance in attributes)
            {
                if (IsAttributeBasedOn(attributeInstance, baseType))
                {
                    foundAttributes.Add(attributeInstance);
                }
            }
            return foundAttributes;
        }

        private static bool IsAttributeBasedOn(IAttributeInstance attributeInstance, string type)
        {
            if (attributeInstance.AttributeType.GetCLRName().CompareTo(type) == 0)
            {
                return true;
            }
            var types = attributeInstance.AttributeType.GetSuperTypes();
            foreach (IDeclaredType declaredType in types)
            {
                if (declaredType.GetCLRName().CompareTo(type) == 0)
                {
                    return true;
                }
            }
            return false;
        }

        public string[] GetChildNames(IMethod method)
        {
            var methodNames = new List<string>();
            IList<IAttributeInstance> attributes = GetAttributesFromType(method, AttributesNames.RowAttributeName);
            foreach (IAttributeInstance instance in attributes)
            {
                if (instance.Constructor.Parameters.Count > 0)
                {
                    methodNames.Add(GetChildMethodName(method, instance));
                }
            }
            return methodNames.ToArray();
        }

        private string GetChildMethodName(IParametersOwner method, IAttributeInstance attributeInstance)
        {
            IList<IParameter> methodsParameters = method.Parameters;
            var stringBuilder = new StringBuilder();
            stringBuilder.Append(method.ShortName);
            stringBuilder.Append("(");
            for (var i = 0; i < attributeInstance.PositionParameterCount; i++)
            {
                if (i > 0)
                {
                    stringBuilder.Append(",");
                }

                IParameter parameter = null;
                if (i < methodsParameters.Count)
                    parameter = methodsParameters[i];
                var value = attributeInstance.PositionParameter(i);

                if (value.IsConstant)
                {
                    var cValue = value.ConstantValue;
                    var added = false;
                    if (parameter != null)
                    {
                        IEnum anEnum = MiscUtil.GetEnumType(parameter.Type);
                        if (anEnum != null)
                        {
                            foreach (var field in anEnum.EnumMembers)
                            {
                                if (!field.ConstantValue.IsBadValue() && field.ConstantValue.Value.Equals(cValue.Value))
                                {
                                    stringBuilder.AppendFormat(CultureInfo.InvariantCulture, "{0}", field.ShortName);
                                    added = true;
                                    continue;
                                }
                            }
                        }
                        if (!added)
                            stringBuilder.AppendFormat(CultureInfo.InvariantCulture, "{0}", cValue.Value);
                    }
                }
            }
            stringBuilder.Append(")");
            return stringBuilder.ToString();
        }

        public bool HasChildTest(IMethod member)
        {
            return GetChildNames(member).Length > 0;
        }

        public void CollectTestFixtureCategories(ITypeMember typeMember, ref List<string> categories)
        {
            CollectCategoriesForType(typeMember, categories, AttributesNames.FixtureCategoryAttributeName);
            CollectCategoriesForType(typeMember, categories, AttributesNames.TestCategoryAttributeName);
        }

        public void CollectTestMethodCategories(IMethod typeMember, ref List<string> categories)
        {
            CollectCategoriesForType(typeMember, categories, AttributesNames.TestCategoryAttributeName);
        }

        private void CollectCategoriesForType(IAttributesOwner typeMember, ICollection<string> categories, string typeName)
        {
            foreach (IAttributeInstance attributeInstance in GetAttributesFromType(typeMember, typeName))
            {
                bool validParameter = true;
                for (int i = 0; validParameter; i++)
                {
                    AttributeValue value = attributeInstance.PositionParameter(i);
                    validParameter = value.IsType;
                    if (value.IsType)
                    {
                        if (value.ConstantValue.IsString())
                        {
                            if (!categories.Contains(value.ConstantValue.ToString()))
                                categories.Add(value.ConstantValue.ToString());
                        }
                    }
                }
            }
        }
    }
}