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

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

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

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

        #endregion

        internal static bool IsTestMethod(IMethod method)
        {
            if ((method.GetAccessRights() != AccessRights.PUBLIC || method.IsStatic || method.IsAbstract ||
                 !method.ReturnType.Equals(method.GetManager().PredefinedType.Void)))
            {
                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)
            {
                if (instance.Constructor != null)
                {
                    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)
        {
            List<IAttributeInstance> 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;
            }
            IDeclaredType[] 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 static string GetChildMethodName(IMethod method, IAttributeInstance attributeInstance)
        {
            IList<IParameter> methodsParameters = method.Parameters;
            var stringBuilder = new StringBuilder();
            stringBuilder.Append(method.ShortName);
            stringBuilder.Append("(");
            int i = 0;
            ConstantValue2 value = attributeInstance.PositionParameter(i);
            while (!value.IsBadValue())
            {
                if (i > 0)
                {
                    stringBuilder.Append(",");
                }
                IParameter parameter = null;
                if (i < methodsParameters.Count)
                {
                    parameter = methodsParameters[i];
                }
                if (value.Type == null || value.Value == null)
                {
                    stringBuilder.Append("");
                }
                else
                {
                    var added = false;
                    if (parameter != null)
                    {
                        IEnum anEnum = MiscUtil.GetEnumType(parameter.Type);
                        if (anEnum != null)
                        {
                            foreach (IField field in anEnum.EnumMembers)
                            {
                                if (!field.Value.IsBadValue())
                                {
                                    if (field.Value.Value.Equals(value.Value))
                                    {
                                        stringBuilder.AppendFormat(CultureInfo.InvariantCulture, "{0}", field.ShortName);
                                        added = true;
                                        continue;
                                    }
                                }
                            }
                        }
                        if (!added)
                            stringBuilder.AppendFormat(CultureInfo.InvariantCulture, "{0}", value.Value);
                    }
                }
                i++;
                value = attributeInstance.PositionParameter(i);
            }
            stringBuilder.Append(")");
            return stringBuilder.ToString();
        }

        public bool HasChildTest(IMethod method)
        {
            return GetChildNames(method).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, List<string> categories, string typeName)
        {
            foreach (IAttributeInstance attributeInstance in GetAttributesFromType(typeMember, typeName))
            {
                bool validParameter = true;
                for (int i = 0; validParameter; i++)
                {
                    ConstantValue2 value = attributeInstance.PositionParameter(i);
                    validParameter = value.Type != null;
                    if (validParameter)
                    {
                        if (value.IsString())
                        {
                            if (!categories.Contains((string)value.Value))
                            {
                                categories.Add((string)value.Value);
                            }
                        }
                    }
                }
            }
        }
    }
}