/*
    Copyright (C) 2011 de4dot@gmail.com

    This file is part of de4dot.

    de4dot is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    de4dot is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with de4dot.  If not, see <http://www.gnu.org/licenses/>.
*/

using System;
using System.Collections.Generic;
using System.Text.RegularExpressions;
using Mono.Cecil;
using Mono.Cecil.Cil;
using de4dot.code.renamer.asmmodules;
using de4dot.blocks;

namespace de4dot.code.renamer {
	class TypeInfo : MemberInfo {
		public string oldNamespace;
		public string newNamespace;
		public VariableNameState variableNameState = new VariableNameState();
		public TypeDef type;
		MemberInfos memberInfos;

		public INameChecker NameChecker {
			get { return type.Module.ObfuscatedFile.NameChecker; }
		}

		public TypeInfo(TypeDef typeDef, MemberInfos memberInfos)
			: base(typeDef) {
			this.type = typeDef;
			this.memberInfos = memberInfos;
			oldNamespace = typeDef.TypeDefinition.Namespace;
		}

		bool isWinFormsClass() {
			return memberInfos.isWinFormsClass(type);
		}

		public PropertyInfo prop(PropertyDef prop) {
			return memberInfos.prop(prop);
		}

		public EventInfo evt(EventDef evt) {
			return memberInfos.evt(evt);
		}

		public FieldInfo field(FieldDef field) {
			return memberInfos.field(field);
		}

		public MethodInfo method(MethodDef method) {
			return memberInfos.method(method);
		}

		public GenericParamInfo gparam(GenericParamDef gparam) {
			return memberInfos.gparam(gparam);
		}

		public ParamInfo param(ParamDef param) {
			return memberInfos.param(param);
		}

		TypeInfo getBase() {
			if (type.baseType == null)
				return null;

			TypeInfo baseInfo;
			memberInfos.tryGetType(type.baseType.typeDef, out baseInfo);
			return baseInfo;
		}

		public void prepareRenameTypes(TypeRenamerState state) {
			var checker = NameChecker;

			if (newNamespace == null && oldNamespace != "") {
				if (!checker.isValidNamespaceName(oldNamespace)) {
					newNamespace = state.createNamespace(oldNamespace);
				}
			}

			string origClassName = null;
			if (isWinFormsClass())
				origClassName = findWindowsFormsClassName(type);
			if (oldFullName != "<Module>" && !checker.isValidTypeName(oldName)) {
				if (origClassName != null && checker.isValidTypeName(origClassName))
					rename(state.getTypeName(oldName, origClassName));
				else {
					ITypeNameCreator nameCreator = type.isGlobalType() ?
											state.globalTypeNameCreator :
											state.internalTypeNameCreator;
					string newBaseType = null;
					TypeInfo baseInfo = getBase();
					if (baseInfo != null && baseInfo.renamed)
						newBaseType = baseInfo.newName;
					rename(nameCreator.create(type.TypeDefinition, newBaseType));
				}
			}

			prepareRenameGenericParams(type.GenericParams, checker);
		}

		public void mergeState() {
			foreach (var ifaceInfo in type.interfaces)
				mergeState(ifaceInfo.typeDef);
			if (type.baseType != null)
				mergeState(type.baseType.typeDef);
		}

		void mergeState(TypeDef other) {
			if (other == null)
				return;
			TypeInfo otherInfo;
			if (!memberInfos.tryGetType(other, out otherInfo))
				return;
			variableNameState.merge(otherInfo.variableNameState);
		}

		public void prepareRenameMembers() {
			mergeState();

			foreach (var fieldDef in type.AllFields)
				variableNameState.addFieldName(field(fieldDef).oldName);
			foreach (var eventDef in type.AllEvents)
				variableNameState.addEventName(evt(eventDef).oldName);
			foreach (var propDef in type.AllProperties)
				variableNameState.addPropertyName(prop(propDef).oldName);
			foreach (var methodDef in type.AllMethods)
				variableNameState.addMethodName(method(methodDef).oldName);

			if (isWinFormsClass())
				initializeWindowsFormsFieldsAndProps();

			prepareRenameFields();
		}

		public void prepareRenamePropsAndEvents() {
			mergeState();
			prepareRenameProperties();
			prepareRenameEvents();
		}

		void prepareRenameFields() {
			var checker = NameChecker;

			if (type.TypeDefinition.IsEnum) {
				var instanceFields = getInstanceFields();
				if (instanceFields.Count == 1)
					field(instanceFields[0]).rename("value__");

				int i = 0;
				string nameFormat = hasFlagsAttribute() ? "flag_{0}" : "const_{0}";
				foreach (var fieldDef in type.AllFieldsSorted) {
					var fieldInfo = field(fieldDef);
					if (fieldInfo.renamed)
						continue;
					if (!fieldDef.FieldDefinition.IsStatic || !fieldDef.FieldDefinition.IsLiteral)
						continue;
					if (!checker.isValidFieldName(fieldInfo.oldName))
						fieldInfo.rename(string.Format(nameFormat, i));
					i++;
				}
			}
			foreach (var fieldDef in type.AllFieldsSorted) {
				var fieldInfo = field(fieldDef);
				if (fieldInfo.renamed)
					continue;
				if (!checker.isValidFieldName(fieldInfo.oldName))
					fieldInfo.rename(fieldInfo.suggestedName ?? variableNameState.getNewFieldName(fieldDef.FieldDefinition));
			}
		}

		List<FieldDef> getInstanceFields() {
			var fields = new List<FieldDef>();
			foreach (var fieldDef in type.AllFields) {
				if (!fieldDef.FieldDefinition.IsStatic)
					fields.Add(fieldDef);
			}
			return fields;
		}

		bool hasFlagsAttribute() {
			foreach (var attr in type.TypeDefinition.CustomAttributes) {
				if (attr.AttributeType.FullName == "System.FlagsAttribute")
					return true;
			}
			return false;
		}

		void prepareRenameProperties() {
			foreach (var propDef in type.AllPropertiesSorted) {
				if (propDef.isVirtual())
					continue;
				prepareRenameProperty(propDef);
			}
		}

		void prepareRenameProperty(PropertyDef propDef) {
			if (propDef.isVirtual())
				throw new ApplicationException("Can't rename virtual props here");
			var propInfo = prop(propDef);
			if (propInfo.renamed)
				return;

			string propName = propInfo.oldName;
			if (!NameChecker.isValidPropertyName(propName))
				propName = propInfo.suggestedName;
			if (!NameChecker.isValidPropertyName(propName)) {
				if (propDef.isItemProperty())
					propName = "Item";
				else
					propName = variableNameState.getNewPropertyName(propDef.PropertyDefinition);
			}
			variableNameState.addPropertyName(propName);
			propInfo.rename(propName);

			renameSpecialMethod(propDef.GetMethod, "get_" + propName);
			renameSpecialMethod(propDef.SetMethod, "set_" + propName);
		}

		void prepareRenameEvents() {
			foreach (var eventDef in type.AllEventsSorted) {
				if (eventDef.isVirtual())
					continue;
				prepareRenameEvent(eventDef);
			}
		}

		void prepareRenameEvent(EventDef eventDef) {
			if (eventDef.isVirtual())
				throw new ApplicationException("Can't rename virtual events here");
			var eventInfo = evt(eventDef);
			if (eventInfo.renamed)
				return;

			string eventName = eventInfo.oldName;
			if (!NameChecker.isValidEventName(eventName))
				eventName = eventInfo.suggestedName;
			if (!NameChecker.isValidEventName(eventName))
				eventName = variableNameState.getNewEventName(eventDef.EventDefinition);
			variableNameState.addEventName(eventName);
			eventInfo.rename(eventName);

			renameSpecialMethod(eventDef.AddMethod, "add_" + eventName);
			renameSpecialMethod(eventDef.RemoveMethod, "remove_" + eventName);
			renameSpecialMethod(eventDef.RaiseMethod, "raise_" + eventName);
		}

		void renameSpecialMethod(MethodDef methodDef, string newName) {
			if (methodDef == null)
				return;
			if (methodDef.isVirtual())
				return;
			renameMethod(methodDef, newName);
		}

		public void prepareRenameMethods() {
			mergeState();
			foreach (var methodDef in type.AllMethodsSorted) {
				if (methodDef.isVirtual())
					continue;
				renameMethod(methodDef);
			}
		}

		public void prepareRenameMethods2() {
			var checker = NameChecker;
			foreach (var methodDef in type.AllMethodsSorted) {
				prepareRenameMethodArgs(methodDef);
				prepareRenameGenericParams(methodDef.GenericParams, checker, methodDef.Owner == null ? null : methodDef.Owner.GenericParams);
			}
		}

		void prepareRenameMethodArgs(MethodDef methodDef) {
			if (methodDef.ParamDefs.Count > 0) {
				if (isEventHandler(methodDef)) {
					param(methodDef.ParamDefs[0]).newName = "sender";
					param(methodDef.ParamDefs[1]).newName = "e";
				}
				else {
					var newVariableNameState = variableNameState.clone();
					var checker = NameChecker;
					foreach (var paramDef in methodDef.ParamDefs) {
						var info = param(paramDef);
						if (info.gotNewName())
							continue;
						if (!checker.isValidMethodArgName(info.oldName))
							info.newName = newVariableNameState.getNewParamName(info.oldName, paramDef.ParameterDefinition);
					}
				}
			}

			if ((methodDef.Property != null && methodDef == methodDef.Property.SetMethod) ||
				(methodDef.Event != null && (methodDef == methodDef.Event.AddMethod || methodDef == methodDef.Event.RemoveMethod))) {
				if (methodDef.ParamDefs.Count > 0) {
					var paramDef = methodDef.ParamDefs[methodDef.ParamDefs.Count - 1];
					param(paramDef).newName = "value";
				}
			}
		}

		bool canRenameMethod(MethodDef methodDef) {
			var methodInfo = method(methodDef);
			if (methodDef.isStatic()) {
				if (methodInfo.oldName == ".cctor")
					return false;
			}
			else if (methodDef.isVirtual()) {
				if (DotNetUtils.derivesFromDelegate(type.TypeDefinition)) {
					switch (methodInfo.oldName) {
					case "BeginInvoke":
					case "EndInvoke":
					case "Invoke":
						return false;
					}
				}
			}
			else {
				if (methodInfo.oldName == ".ctor")
					return false;
			}
			return true;
		}

		public void renameMethod(MethodDef methodDef, string methodName) {
			if (!canRenameMethod(methodDef))
				return;
			var methodInfo = method(methodDef);
			variableNameState.addMethodName(methodName);
			methodInfo.rename(methodName);
		}

		void renameMethod(MethodDef methodDef) {
			if (methodDef.isVirtual())
				throw new ApplicationException("Can't rename virtual methods here");
			if (!canRenameMethod(methodDef))
				return;

			var info = method(methodDef);
			if (info.renamed)
				return;
			info.renamed = true;
			var checker = NameChecker;

			// PInvoke methods' EntryPoint is always valid. It has to, so always rename.
			if (!NameChecker.isValidMethodName(info.oldName) || methodDef.MethodDefinition.PInvokeInfo != null) {
				INameCreator nameCreator = null;
				string newName = info.suggestedName;
				if (methodDef.MethodDefinition.PInvokeInfo != null)
					newName = getPinvokeName(methodDef);
				else if (methodDef.isStatic())
					nameCreator = variableNameState.staticMethodNameCreator;
				else
					nameCreator = variableNameState.instanceMethodNameCreator;
				if (newName != null)
					nameCreator = new NameCreator2(newName);
				renameMethod(methodDef, variableNameState.getNewMethodName(info.oldName, nameCreator));
			}
		}

		string getPinvokeName(MethodDef methodDef) {
			var entryPoint = methodDef.MethodDefinition.PInvokeInfo.EntryPoint;
			if (Regex.IsMatch(entryPoint, @"^#\d+$"))
				entryPoint = DotNetUtils.getDllName(methodDef.MethodDefinition.PInvokeInfo.Module.Name) + "_" + entryPoint.Substring(1);
			return entryPoint;
		}

		static bool isEventHandler(MethodDef methodDef) {
			if (methodDef.MethodDefinition.Parameters.Count != 2)
				return false;
			if (methodDef.MethodDefinition.MethodReturnType.ReturnType.FullName != "System.Void")
				return false;
			if (methodDef.MethodDefinition.Parameters[0].ParameterType.FullName != "System.Object")
				return false;
			if (!methodDef.MethodDefinition.Parameters[1].ParameterType.FullName.Contains("EventArgs"))
				return false;
			return true;
		}

		void prepareRenameGenericParams(IEnumerable<GenericParamDef> genericParams, INameChecker checker, IEnumerable<GenericParamDef> otherGenericParams = null) {
			var usedNames = new Dictionary<string, bool>(StringComparer.Ordinal);
			var nameCreator = new GenericParamNameCreator();

			if (otherGenericParams != null) {
				foreach (var param in otherGenericParams) {
					var gpInfo = memberInfos.gparam(param);
					usedNames[gpInfo.newName] = true;
				}
			}

			foreach (var param in genericParams) {
				var gpInfo = memberInfos.gparam(param);
				if (!checker.isValidGenericParamName(gpInfo.oldName) || usedNames.ContainsKey(gpInfo.oldName)) {
					string newName;
					do {
						newName = nameCreator.create();
					} while (usedNames.ContainsKey(newName));
					usedNames[newName] = true;
					gpInfo.rename(newName);
				}
			}
		}

		void initializeWindowsFormsFieldsAndProps() {
			var checker = NameChecker;

			var ourFields = new Dictionary<FieldReferenceAndDeclaringTypeKey, FieldDef>();
			foreach (var fieldDef in type.AllFields)
				ourFields[new FieldReferenceAndDeclaringTypeKey(fieldDef.FieldDefinition)] = fieldDef;
			var ourMethods = new Dictionary<MethodReferenceAndDeclaringTypeKey, MethodDef>();
			foreach (var methodDef in type.AllMethods)
				ourMethods[new MethodReferenceAndDeclaringTypeKey(methodDef.MethodDefinition)] = methodDef;

			foreach (var methodDef in type.AllMethods) {
				if (methodDef.MethodDefinition.Body == null)
					continue;
				if (methodDef.MethodDefinition.IsStatic || methodDef.MethodDefinition.IsVirtual)
					continue;
				var instructions = methodDef.MethodDefinition.Body.Instructions;
				for (int i = 2; i < instructions.Count; i++) {
					var call = instructions[i];
					if (call.OpCode.Code != Code.Call && call.OpCode.Code != Code.Callvirt)
						continue;
					if (!isWindowsFormsSetNameMethod(call.Operand as MethodReference))
						continue;

					var ldstr = instructions[i - 1];
					if (ldstr.OpCode.Code != Code.Ldstr)
						continue;
					var fieldName = ldstr.Operand as string;
					if (fieldName == null || !checker.isValidFieldName(fieldName))
						continue;

					var instr = instructions[i - 2];
					FieldReference fieldRef = null;
					if (instr.OpCode.Code == Code.Call || instr.OpCode.Code == Code.Callvirt) {
						var calledMethod = instr.Operand as MethodReference;
						if (calledMethod == null)
							continue;
						MethodDef calledMethodDef;
						if (!ourMethods.TryGetValue(new MethodReferenceAndDeclaringTypeKey(calledMethod), out calledMethodDef))
							continue;
						fieldRef = getFieldReference(calledMethodDef.MethodDefinition);
						if (fieldRef == null)
							continue;

						var propDef = calledMethodDef.Property;
						if (propDef == null)
							continue;

						memberInfos.prop(propDef).suggestedName = fieldName;
						fieldName = "_" + fieldName;
					}
					else if (instr.OpCode.Code == Code.Ldfld) {
						fieldRef = instr.Operand as FieldReference;
					}

					if (fieldRef == null)
						continue;
					FieldDef fieldDef;
					if (!ourFields.TryGetValue(new FieldReferenceAndDeclaringTypeKey(fieldRef), out fieldDef))
						continue;
					var fieldInfo = memberInfos.field(fieldDef);

					if (fieldInfo.renamed)
						continue;

					fieldInfo.suggestedName = variableNameState.getNewFieldName(fieldInfo.oldName, new NameCreator2(fieldName));
				}
			}
		}

		static FieldReference getFieldReference(MethodDefinition method) {
			if (method == null || method.Body == null)
				return null;
			var instructions = method.Body.Instructions;
			int index = 0;
			var ldarg0 = DotNetUtils.getInstruction(instructions, ref index);
			if (ldarg0 == null || DotNetUtils.getArgIndex(method, ldarg0) != 0)
				return null;
			var ldfld = DotNetUtils.getInstruction(instructions, ref index);
			if (ldfld == null || ldfld.OpCode.Code != Code.Ldfld)
				return null;
			var ret = DotNetUtils.getInstruction(instructions, ref index);
			if (ret == null || ret.OpCode.Code != Code.Ret)
				return null;
			return ldfld.Operand as FieldReference;
		}

		public void initializeEventHandlerNames() {
			var ourFields = new Dictionary<FieldReferenceAndDeclaringTypeKey, FieldDef>();
			foreach (var fieldDef in type.AllFields)
				ourFields[new FieldReferenceAndDeclaringTypeKey(fieldDef.FieldDefinition)] = fieldDef;
			var ourMethods = new Dictionary<MethodReferenceAndDeclaringTypeKey, MethodDef>();
			foreach (var methodDef in type.AllMethods)
				ourMethods[new MethodReferenceAndDeclaringTypeKey(methodDef.MethodDefinition)] = methodDef;

			initVbEventHandlers(ourFields, ourMethods);
			initFieldEventHandlers(ourFields, ourMethods);
			initTypeEventHandlers(ourFields, ourMethods);
		}

		// VB initializes the handlers in the property setter, where it first removes the handler
		// from the previous control, and then adds the handler to the new control.
		void initVbEventHandlers(Dictionary<FieldReferenceAndDeclaringTypeKey, FieldDef> ourFields, Dictionary<MethodReferenceAndDeclaringTypeKey, MethodDef> ourMethods) {
			var checker = NameChecker;

			foreach (var propDef in type.AllProperties) {
				var setter = propDef.PropertyDefinition.SetMethod;
				if (setter == null)
					continue;
				var setterDef = type.find(setter);
				if (setterDef == null)
					continue;

				string eventName;
				var handler = getVbHandler(setterDef.MethodDefinition, out eventName);
				if (handler == null)
					continue;
				MethodDef handlerDef;
				if (!ourMethods.TryGetValue(new MethodReferenceAndDeclaringTypeKey(handler), out handlerDef))
					continue;

				if (!checker.isValidEventName(eventName))
					continue;

				memberInfos.method(handlerDef).suggestedName = string.Format("{0}_{1}", memberInfos.prop(propDef).newName, eventName);
			}
		}

		static MethodReference getVbHandler(MethodDefinition method, out string eventName) {
			eventName = null;
			if (method.Body == null)
				return null;
			if (method.MethodReturnType.ReturnType.FullName != "System.Void")
				return null;
			if (method.Parameters.Count != 1)
				return null;
			if (method.Body.Variables.Count != 1)
				return null;
			if (!isEventHandlerType(method.Body.Variables[0].VariableType))
				return null;

			var instructions = method.Body.Instructions;
			int index = 0;

			int newobjIndex = findInstruction(instructions, index, Code.Newobj);
			if (newobjIndex == -1 || findInstruction(instructions, newobjIndex + 1, Code.Newobj) != -1)
				return null;
			if (!isEventHandlerCtor(instructions[newobjIndex].Operand as MethodReference))
				return null;
			if (newobjIndex < 1)
				return null;
			var ldvirtftn = instructions[newobjIndex - 1];
			if (ldvirtftn.OpCode.Code != Code.Ldvirtftn && ldvirtftn.OpCode.Code != Code.Ldftn)
				return null;
			var handlerMethod = ldvirtftn.Operand as MethodReference;
			if (handlerMethod == null)
				return null;
			if (!MemberReferenceHelper.compareTypes(method.DeclaringType, handlerMethod.DeclaringType))
				return null;
			index = newobjIndex;

			FieldReference addField, removeField;
			MethodReference addMethod, removeMethod;
			if (!findEventCall(instructions, ref index, out removeField, out removeMethod))
				return null;
			if (!findEventCall(instructions, ref index, out addField, out addMethod))
				return null;

			if (findInstruction(instructions, index, Code.Callvirt) != -1)
				return null;
			if (!MemberReferenceHelper.compareFieldReference(addField, removeField))
				return null;
			if (!MemberReferenceHelper.compareTypes(method.DeclaringType, addField.DeclaringType))
				return null;
			if (!MemberReferenceHelper.compareTypes(addMethod.DeclaringType, removeMethod.DeclaringType))
				return null;
			if (!Utils.StartsWith(addMethod.Name, "add_", StringComparison.Ordinal))
				return null;
			if (!Utils.StartsWith(removeMethod.Name, "remove_", StringComparison.Ordinal))
				return null;
			eventName = addMethod.Name.Substring(4);
			if (eventName != removeMethod.Name.Substring(7))
				return null;
			if (eventName == "")
				return null;

			return handlerMethod;
		}

		static bool findEventCall(IList<Instruction> instructions, ref int index, out FieldReference field, out MethodReference calledMethod) {
			field = null;
			calledMethod = null;

			int callvirt = findInstruction(instructions, index, Code.Callvirt);
			if (callvirt < 2)
				return false;
			index = callvirt + 1;

			var ldloc = instructions[callvirt - 1];
			if (ldloc.OpCode.Code != Code.Ldloc_0)
				return false;

			var ldfld = instructions[callvirt - 2];
			if (ldfld.OpCode.Code != Code.Ldfld)
				return false;

			field = ldfld.Operand as FieldReference;
			calledMethod = instructions[callvirt].Operand as MethodReference;
			return field != null && calledMethod != null;
		}

		static int findInstruction(IList<Instruction> instructions, int index, Code code) {
			for (int i = index; i < instructions.Count; i++) {
				if (instructions[i].OpCode.Code == code)
					return i;
			}
			return -1;
		}

		void initFieldEventHandlers(Dictionary<FieldReferenceAndDeclaringTypeKey, FieldDef> ourFields, Dictionary<MethodReferenceAndDeclaringTypeKey, MethodDef> ourMethods) {
			var checker = NameChecker;

			foreach (var methodDef in type.AllMethods) {
				if (methodDef.MethodDefinition.Body == null)
					continue;
				if (methodDef.MethodDefinition.IsStatic)
					continue;
				var instructions = methodDef.MethodDefinition.Body.Instructions;
				for (int i = 0; i < instructions.Count - 6; i++) {
					// We're looking for this code pattern:
					//	ldarg.0
					//	ldfld field
					//	ldarg.0
					//	ldftn method / ldarg.0 + ldvirtftn
					//	newobj event_handler_ctor
					//	callvirt add_SomeEvent

					if (DotNetUtils.getArgIndex(methodDef.MethodDefinition, instructions[i]) != 0)
						continue;
					int index = i + 1;

					var ldfld = instructions[index++];
					if (ldfld.OpCode.Code != Code.Ldfld)
						continue;
					var fieldRef = ldfld.Operand as FieldReference;
					if (fieldRef == null)
						continue;
					FieldDef fieldDef;
					if (!ourFields.TryGetValue(new FieldReferenceAndDeclaringTypeKey(fieldRef), out fieldDef))
						continue;

					if (DotNetUtils.getArgIndex(methodDef.MethodDefinition, instructions[index++]) != 0)
						continue;

					MethodReference methodRef;
					var instr = instructions[index + 1];
					if (instr.OpCode.Code == Code.Ldvirtftn) {
						if (!isThisOrDup(methodDef.MethodDefinition, instructions[index++]))
							continue;
						var ldvirtftn = instructions[index++];
						methodRef = ldvirtftn.Operand as MethodReference;
					}
					else {
						var ldftn = instructions[index++];
						if (ldftn.OpCode.Code != Code.Ldftn)
							continue;
						methodRef = ldftn.Operand as MethodReference;
					}
					if (methodRef == null)
						continue;
					MethodDef handlerMethod;
					if (!ourMethods.TryGetValue(new MethodReferenceAndDeclaringTypeKey(methodRef), out handlerMethod))
						continue;

					var newobj = instructions[index++];
					if (newobj.OpCode.Code != Code.Newobj)
						continue;
					if (!isEventHandlerCtor(newobj.Operand as MethodReference))
						continue;

					var call = instructions[index++];
					if (call.OpCode.Code != Code.Call && call.OpCode.Code != Code.Callvirt)
						continue;
					var addHandler = call.Operand as MethodReference;
					if (addHandler == null)
						continue;
					if (!Utils.StartsWith(addHandler.Name, "add_", StringComparison.Ordinal))
						continue;

					var eventName = addHandler.Name.Substring(4);
					if (!checker.isValidEventName(eventName))
						continue;

					memberInfos.method(handlerMethod).suggestedName = string.Format("{0}_{1}", memberInfos.field(fieldDef).newName, eventName);
				}
			}
		}

		void initTypeEventHandlers(Dictionary<FieldReferenceAndDeclaringTypeKey, FieldDef> ourFields, Dictionary<MethodReferenceAndDeclaringTypeKey, MethodDef> ourMethods) {
			var checker = NameChecker;

			foreach (var methodDef in type.AllMethods) {
				if (methodDef.MethodDefinition.Body == null)
					continue;
				if (methodDef.MethodDefinition.IsStatic)
					continue;
				var method = methodDef.MethodDefinition;
				var instructions = method.Body.Instructions;
				for (int i = 0; i < instructions.Count - 5; i++) {
					// ldarg.0
					// ldarg.0 / dup
					// ldarg.0 / dup
					// ldvirtftn handler
					// newobj event handler ctor
					// call add_Xyz

					if (DotNetUtils.getArgIndex(method, instructions[i]) != 0)
						continue;
					int index = i + 1;

					if (!isThisOrDup(method, instructions[index++]))
						continue;
					MethodReference handler;
					if (instructions[index].OpCode.Code == Code.Ldftn) {
						handler = instructions[index++].Operand as MethodReference;
					}
					else {
						if (!isThisOrDup(method, instructions[index++]))
							continue;
						var instr = instructions[index++];
						if (instr.OpCode.Code != Code.Ldvirtftn)
							continue;
						handler = instr.Operand as MethodReference;
					}
					if (handler == null)
						continue;
					MethodDef handlerDef;
					if (!ourMethods.TryGetValue(new MethodReferenceAndDeclaringTypeKey(handler), out handlerDef))
						continue;

					var newobj = instructions[index++];
					if (newobj.OpCode.Code != Code.Newobj)
						continue;
					if (!isEventHandlerCtor(newobj.Operand as MethodReference))
						continue;

					var call = instructions[index++];
					if (call.OpCode.Code != Code.Call && call.OpCode.Code != Code.Callvirt)
						continue;
					var addMethod = call.Operand as MethodReference;
					if (addMethod == null)
						continue;
					if (!Utils.StartsWith(addMethod.Name, "add_", StringComparison.Ordinal))
						continue;

					var eventName = addMethod.Name.Substring(4);
					if (!checker.isValidEventName(eventName))
						continue;

					memberInfos.method(handlerDef).suggestedName = string.Format("{0}_{1}", newName, eventName);
				}
			}
		}

		static bool isThisOrDup(MethodReference method, Instruction instr) {
			return DotNetUtils.getArgIndex(method, instr) == 0 || instr.OpCode.Code == Code.Dup;
		}

		static bool isEventHandlerCtor(MethodReference method) {
			if (method == null)
				return false;
			if (method.Name != ".ctor")
				return false;
			if (!DotNetUtils.isMethod(method, "System.Void", "(System.Object,System.IntPtr)"))
				return false;
			if (!isEventHandlerType(method.DeclaringType))
				return false;
			return true;
		}

		static bool isEventHandlerType(TypeReference type) {
			return type.FullName.EndsWith("EventHandler", StringComparison.Ordinal);
		}

		static MethodReference getOverrideMethod(MethodDefinition meth) {
			if (meth == null || !meth.HasOverrides)
				return null;
			return meth.Overrides[0];
		}

		string findWindowsFormsClassName(TypeDef type) {
			foreach (var methodDef in type.AllMethods) {
				if (methodDef.MethodDefinition.Body == null)
					continue;
				if (methodDef.MethodDefinition.IsStatic || methodDef.MethodDefinition.IsVirtual)
					continue;
				var instructions = methodDef.MethodDefinition.Body.Instructions;
				for (int i = 2; i < instructions.Count; i++) {
					var call = instructions[i];
					if (call.OpCode.Code != Code.Call && call.OpCode.Code != Code.Callvirt)
						continue;
					if (!isWindowsFormsSetNameMethod(call.Operand as MethodReference))
						continue;

					var ldstr = instructions[i - 1];
					if (ldstr.OpCode.Code != Code.Ldstr)
						continue;
					var className = ldstr.Operand as string;
					if (className == null)
						continue;

					if (DotNetUtils.getArgIndex(methodDef.MethodDefinition, instructions[i - 2]) != 0)
						continue;

					findInitializeComponentMethod(type, methodDef);
					return className;
				}
			}
			return null;
		}

		void findInitializeComponentMethod(TypeDef type, MethodDef possibleInitMethod) {
			foreach (var methodDef in type.AllMethods) {
				if (methodDef.MethodDefinition.Name != ".ctor")
					continue;
				if (methodDef.MethodDefinition.Body == null)
					continue;
				foreach (var instr in methodDef.MethodDefinition.Body.Instructions) {
					if (instr.OpCode.Code != Code.Call && instr.OpCode.Code != Code.Callvirt)
						continue;
					if (!MemberReferenceHelper.compareMethodReferenceAndDeclaringType(possibleInitMethod.MethodDefinition, instr.Operand as MethodReference))
						continue;

					memberInfos.method(possibleInitMethod).suggestedName = "InitializeComponent";
					return;
				}
			}
		}

		static bool isWindowsFormsSetNameMethod(MethodReference method) {
			if (method == null)
				return false;
			if (method.Name != "set_Name")
				return false;
			if (method.MethodReturnType.ReturnType.FullName != "System.Void")
				return false;
			if (method.Parameters.Count != 1)
				return false;
			if (method.Parameters[0].ParameterType.FullName != "System.String")
				return false;
			return true;
		}
	}
}