/* *******************************************************************
 * Copyright (c) 2002 Palo Alto Research Center, Incorporated (PARC).
 * All rights reserved.
 * This program and the accompanying materials are made available
 * under the terms of the Eclipse Public License v 2.0
 * which accompanies this distribution and is available at
 * https://www.eclipse.org/org/documents/epl-2.0/EPL-2.0.txt
 *
 * Contributors:
 *     PARC     initial implementation
 * ******************************************************************/

package org.aspectj.weaver;

import java.util.Collections;
import java.util.List;

import org.aspectj.bridge.IMessage;
import org.aspectj.bridge.ISourceLocation;
import org.aspectj.weaver.patterns.AndPointcut;
import org.aspectj.weaver.patterns.PerClause;
import org.aspectj.weaver.patterns.Pointcut;
import org.aspectj.weaver.patterns.TypePattern;

public abstract class Advice extends ShadowMunger {

	protected AjAttribute.AdviceAttribute attribute;
	protected transient AdviceKind kind; // alias for attribute.getKind()
	protected Member signature;
	private boolean isAnnotationStyle;

	// not necessarily declaring aspect, this is a semantics change from 1.0
	protected ResolvedType concreteAspect; // null until after concretize

	// Just for Cflow*entry kinds
	protected List<ShadowMunger> innerCflowEntries = Collections.emptyList();
	protected int nFreeVars;

	protected TypePattern exceptionType; // just for Softener kind

	// if we are parameterized, these type may be different to the advice
	// signature types
	protected UnresolvedType[] bindingParameterTypes;

	protected boolean hasMatchedAtLeastOnce = false;

	// based on annotations on this advice
	protected List<Lint.Kind> suppressedLintKinds = null;

	public ISourceLocation lastReportedMonitorExitJoinpointLocation = null;

	public static Advice makeCflowEntry(World world, Pointcut entry, boolean isBelow, Member stackField, int nFreeVars,
			List<ShadowMunger> innerCflowEntries, ResolvedType inAspect) {
		Advice ret = world.createAdviceMunger(isBelow ? AdviceKind.CflowBelowEntry : AdviceKind.CflowEntry, entry, stackField, 0,
				entry, inAspect);
		ret.innerCflowEntries = innerCflowEntries;
		ret.nFreeVars = nFreeVars;
		ret.setDeclaringType(inAspect); // correct?
		return ret;
	}

	public static Advice makePerCflowEntry(World world, Pointcut entry, boolean isBelow, Member stackField, ResolvedType inAspect,
			List<ShadowMunger> innerCflowEntries) {
		Advice ret = world.createAdviceMunger(isBelow ? AdviceKind.PerCflowBelowEntry : AdviceKind.PerCflowEntry, entry,
				stackField, 0, entry, inAspect);
		ret.innerCflowEntries = innerCflowEntries;
		ret.concreteAspect = inAspect;
		return ret;
	}

	public static Advice makePerObjectEntry(World world, Pointcut entry, boolean isThis, ResolvedType inAspect) {
		Advice ret = world.createAdviceMunger(isThis ? AdviceKind.PerThisEntry : AdviceKind.PerTargetEntry, entry, null, 0, entry,
				inAspect);

		ret.concreteAspect = inAspect;
		return ret;
	}

	// PTWIMPL per type within entry advice is what initializes the aspect
	// instance in the matched type
	public static Advice makePerTypeWithinEntry(World world, Pointcut p, ResolvedType inAspect) {
		Advice ret = world.createAdviceMunger(AdviceKind.PerTypeWithinEntry, p, null, 0, p, inAspect);
		ret.concreteAspect = inAspect;
		return ret;
	}

	public boolean isAroundAdvice() {
		return attribute.getKind() == AdviceKind.Around;
	}

	public static Advice makeSoftener(World world, Pointcut entry, TypePattern exceptionType, ResolvedType inAspect,
			IHasSourceLocation loc) {
		Advice ret = world.createAdviceMunger(AdviceKind.Softener, entry, null, 0, loc, inAspect);
		ret.exceptionType = exceptionType;
		return ret;
	}

	public Advice(AjAttribute.AdviceAttribute attribute, Pointcut pointcut, Member signature) {
		super(pointcut, attribute.getStart(), attribute.getEnd(), attribute.getSourceContext(), ShadowMungerAdvice);
		this.attribute = attribute;
		this.isAnnotationStyle = signature != null && !signature.getName().startsWith("ajc$");
		this.kind = attribute.getKind(); // alias
		this.signature = signature;
		if (signature != null) {
			bindingParameterTypes = signature.getParameterTypes();
		} else {
			bindingParameterTypes = UnresolvedType.NONE;
		}
	}

	@Override
	public boolean match(Shadow shadow, World world) {
		if (super.match(shadow, world)) {
			if (shadow.getKind() == Shadow.ExceptionHandler) {
				if (kind.isAfter() || kind == AdviceKind.Around) {
					world.showMessage(IMessage.WARNING, WeaverMessages.format(WeaverMessages.ONLY_BEFORE_ON_HANDLER),
							getSourceLocation(), shadow.getSourceLocation());
					return false;
				}
			}
			if (shadow.getKind() == Shadow.SynchronizationLock || shadow.getKind() == Shadow.SynchronizationUnlock) {
				if (kind == AdviceKind.Around
				// Don't work, see comments in SynchronizationTests
				// && attribute.getProceedCallSignatures()!=null
				// && attribute.getProceedCallSignatures().length!=0
				) {
					world.showMessage(IMessage.WARNING, WeaverMessages.format(WeaverMessages.NO_AROUND_ON_SYNCHRONIZATION),
							getSourceLocation(), shadow.getSourceLocation());
					return false;
				}
			}

			if (hasExtraParameter() && kind == AdviceKind.AfterReturning) {
				ResolvedType resolvedExtraParameterType = getExtraParameterType().resolve(world);
				ResolvedType shadowReturnType = shadow.getReturnType().resolve(world);
				boolean matches = (resolvedExtraParameterType.isConvertableFrom(shadowReturnType) && shadow.getKind()
						.hasReturnValue());
				if (matches && resolvedExtraParameterType.isParameterizedType()) {
					maybeIssueUncheckedMatchWarning(resolvedExtraParameterType, shadowReturnType, shadow, world);
				}
				return matches;
			} else if (hasExtraParameter() && kind == AdviceKind.AfterThrowing) { // pr119749
				ResolvedType exceptionType = getExtraParameterType().resolve(world);
				if (!exceptionType.isCheckedException() || exceptionType.getName().equals("java.lang.Exception")) { // pr292239
					return true;
				}
				UnresolvedType[] shadowThrows = shadow.getSignature().getExceptions(world);
				boolean matches = false;
				for (int i = 0; i < shadowThrows.length && !matches; i++) {
					ResolvedType type = shadowThrows[i].resolve(world);
					if (exceptionType.isAssignableFrom(type)) {
						matches = true;
					}
				}
				return matches;
			} else if (kind == AdviceKind.PerTargetEntry) {
				return shadow.hasTarget();
			} else if (kind == AdviceKind.PerThisEntry) {
				// Groovy Constructors have a strange switch statement in them - this switch statement can leave us in places where
				// the
				// instance is not initialized (a super ctor hasn't been called yet).
				// In these situations it isn't safe to do a perObjectBind, the instance is not initialized and cannot be passed
				// over.
				if (shadow.getEnclosingCodeSignature().getName().equals("<init>")) {
					if (world.resolve(shadow.getEnclosingType()).isGroovyObject()) {
						return false;
					}
				}
				return shadow.hasThis();
			} else if (kind == AdviceKind.Around) {
				if (shadow.getKind() == Shadow.PreInitialization) {
					world.showMessage(IMessage.WARNING, WeaverMessages.format(WeaverMessages.AROUND_ON_PREINIT),
							getSourceLocation(), shadow.getSourceLocation());
					return false;
				} else if (shadow.getKind() == Shadow.Initialization) {
					world.showMessage(IMessage.WARNING, WeaverMessages.format(WeaverMessages.AROUND_ON_INIT), getSourceLocation(),
							shadow.getSourceLocation());
					return false;
				} else if (shadow.getKind() == Shadow.StaticInitialization
						&& shadow.getEnclosingType().resolve(world).isInterface()) {
					world.showMessage(IMessage.ERROR, WeaverMessages.format(WeaverMessages.AROUND_ON_INTERFACE_STATICINIT, shadow
							.getEnclosingType().getName()), getSourceLocation(), shadow.getSourceLocation());
					return false;
				} else {
					// System.err.println(getSignature().getReturnType() +
					// " from " + shadow.getReturnType());
					if (getSignature().getReturnType().equals(UnresolvedType.VOID)) {
						if (!shadow.getReturnType().equals(UnresolvedType.VOID)) {
							String s = shadow.toString();
							String s2 = WeaverMessages.format(WeaverMessages.NON_VOID_RETURN, s);
							world.showMessage(IMessage.ERROR, s2, getSourceLocation(), shadow.getSourceLocation());
							return false;
						}
					} else if (getSignature().getReturnType().equals(UnresolvedType.OBJECT)) {
						return true;
					} else {
						ResolvedType shadowReturnType = shadow.getReturnType().resolve(world);
						ResolvedType adviceReturnType = getSignature().getGenericReturnType().resolve(world);

						if (shadowReturnType.isParameterizedType() && adviceReturnType.isRawType()) { // Set
							// <
							// Integer
							// >
							// and
							// Set
							ResolvedType shadowReturnGenericType = shadowReturnType.getGenericType(); // Set
							ResolvedType adviceReturnGenericType = adviceReturnType.getGenericType(); // Set
							if (shadowReturnGenericType.isAssignableFrom(adviceReturnGenericType)
									&& world.getLint().uncheckedAdviceConversion.isEnabled()) {
								world.getLint().uncheckedAdviceConversion.signal(
										new String[] { shadow.toString(), shadowReturnType.getName(), adviceReturnType.getName() },
										shadow.getSourceLocation(), new ISourceLocation[] { getSourceLocation() });
							}
						} else if (!shadowReturnType.isAssignableFrom(adviceReturnType)) {
							// System.err.println(this + ", " + sourceContext +
							// ", " + start);
							world.showMessage(IMessage.ERROR,
									WeaverMessages.format(WeaverMessages.INCOMPATIBLE_RETURN_TYPE, shadow), getSourceLocation(),
									shadow.getSourceLocation());
							return false;
						}
					}
				}
			}
			return true;
		} else {
			return false;
		}
	}

	/**
	 * In after returning advice if we are binding the extra parameter to a parameterized type we may not be able to do a type-safe
	 * conversion.
	 *
	 * @param resolvedExtraParameterType the type in the after returning declaration
	 * @param shadowReturnType the type at the shadow
	 * @param world
	 */
	private void maybeIssueUncheckedMatchWarning(ResolvedType afterReturningType, ResolvedType shadowReturnType, Shadow shadow,
			World world) {
		boolean inDoubt = !afterReturningType.isAssignableFrom(shadowReturnType);
		if (inDoubt && world.getLint().uncheckedArgument.isEnabled()) {
			String uncheckedMatchWith = afterReturningType.getSimpleBaseName();
			if (shadowReturnType.isParameterizedType() && (shadowReturnType.getRawType() == afterReturningType.getRawType())) {
				uncheckedMatchWith = shadowReturnType.getSimpleName();
			}
			if (!Utils.isSuppressing(getSignature().getAnnotations(), "uncheckedArgument")) {
				world.getLint().uncheckedArgument.signal(new String[] { afterReturningType.getSimpleName(), uncheckedMatchWith,
						afterReturningType.getSimpleBaseName(), shadow.toResolvedString(world) }, getSourceLocation(),
						new ISourceLocation[] { shadow.getSourceLocation() });
			}
		}
	}

	// ----

	public AdviceKind getKind() {
		return kind;
	}

	public Member getSignature() {
		return signature;
	}

	public boolean hasExtraParameter() {
		return (getExtraParameterFlags() & ExtraArgument) != 0;
	}

	protected int getExtraParameterFlags() {
		return attribute.getExtraParameterFlags();
	}

	protected int getExtraParameterCount() {
		return countOnes(getExtraParameterFlags() & ParameterMask);
	}

	public UnresolvedType[] getBindingParameterTypes() {
		return bindingParameterTypes;
	}

	public void setBindingParameterTypes(UnresolvedType[] types) {
		bindingParameterTypes = types;
	}

	public static int countOnes(int bits) {
		int ret = 0;
		while (bits != 0) {
			if ((bits & 1) != 0) {
				ret += 1;
			}
			bits = bits >> 1;
		}
		return ret;
	}

	public int getBaseParameterCount() {
		return getSignature().getParameterTypes().length - getExtraParameterCount();
	}

	public String[] getBaseParameterNames(World world) {
		String[] allNames = getSignature().getParameterNames(world);
		int extras = getExtraParameterCount();
		if (extras == 0) {
			return allNames;
		}
		String[] result = new String[getBaseParameterCount()];
		if (result.length >= 0) System.arraycopy(allNames, 0, result, 0, result.length);
		return result;
	}

	/**
	 * Return the type of the 'extra argument'. For either after returning or after throwing advice, the extra argument will be the
	 * returned value or the thrown exception respectively. With annotation style the user may declare the parameters in any order,
	 * whereas for code style they are in a well defined order. So there is some extra complexity in here for annotation style that
	 * looks up the correct parameter in the advice signature by name, based on the name specified in the annotation. If this fails
	 * then we 'fallback' to guessing at positions, where the extra argument is presumed to come at the end.
	 *
	 * @return the type of the extraParameter
	 */
	public UnresolvedType getExtraParameterType() {
		if (!hasExtraParameter()) {
			return ResolvedType.MISSING;
		}
		if (signature instanceof ResolvedMember) {
			ResolvedMember method = (ResolvedMember) signature;
			UnresolvedType[] parameterTypes = method.getGenericParameterTypes();
			if (getConcreteAspect().isAnnotationStyleAspect()) {

				// Examine the annotation to determine the parameter name then look it up in the parameters for the method
				String[] pnames = method.getParameterNames();
				if (pnames != null) {
					// It is worth attempting to look up the correct parameter
					AnnotationAJ[] annos = getSignature().getAnnotations();
					String parameterToLookup = null;
					if (annos != null && (getKind() == AdviceKind.AfterThrowing || getKind() == AdviceKind.AfterReturning)) {
						for (int i = 0; i < annos.length && parameterToLookup == null; i++) {
							AnnotationAJ anno = annos[i];
							String annosig = anno.getType().getSignature();
							if (annosig.equals("Lorg/aspectj/lang/annotation/AfterThrowing;")) {
								// the 'throwing' value in the annotation will name the parameter to bind to
								parameterToLookup = anno.getStringFormOfValue("throwing");
							} else if (annosig.equals("Lorg/aspectj/lang/annotation/AfterReturning;")) {
								// the 'returning' value in the annotation will name the parameter to bind to
								parameterToLookup = anno.getStringFormOfValue("returning");
							}
						}
					}
					if (parameterToLookup != null) {
						for (int i = 0; i < pnames.length; i++) {
							if (pnames[i].equals(parameterToLookup)) {
								return parameterTypes[i];
							}
						}
					}
				}

				// Don't think this code works so well... why isnt it getBaseParameterCount()-1 ?

				int baseParmCnt = getBaseParameterCount();

				// bug 122742 - if we're an annotation style aspect then one
				// of the extra parameters could be JoinPoint which we want
				// to ignore
				while ((baseParmCnt + 1 < parameterTypes.length)
						&& (parameterTypes[baseParmCnt].equals(AjcMemberMaker.TYPEX_JOINPOINT)
								|| parameterTypes[baseParmCnt].equals(AjcMemberMaker.TYPEX_STATICJOINPOINT) || parameterTypes[baseParmCnt]
									.equals(AjcMemberMaker.TYPEX_ENCLOSINGSTATICJOINPOINT))) {
					baseParmCnt++;
				}
				return parameterTypes[baseParmCnt];
			} else {
				return parameterTypes[getBaseParameterCount()];
			}
		} else {
			return signature.getParameterTypes()[getBaseParameterCount()];
		}
	}

	public UnresolvedType getDeclaringAspect() {
		return getOriginalSignature().getDeclaringType();
	}

	protected Member getOriginalSignature() {
		return signature;
	}

	protected String extraParametersToString() {
		if (getExtraParameterFlags() == 0) {
			return "";
		} else {
			return "(extraFlags: " + getExtraParameterFlags() + ")";
		}
	}

	@Override
	public Pointcut getPointcut() {
		return pointcut;
	}

	// ----

	/**
	 * @param fromType is guaranteed to be a non-abstract aspect
	 * @param clause has been concretized at a higher level
	 */
	@Override
	public ShadowMunger concretize(ResolvedType fromType, World world, PerClause clause) {
		// assert !fromType.isAbstract();
		Pointcut p = pointcut.concretize(fromType, getDeclaringType(), signature.getArity(), this);
		if (clause != null) {
			Pointcut oldP = p;
			p = new AndPointcut(clause, p);
			p.copyLocationFrom(oldP);
			p.state = Pointcut.CONCRETE;

			// FIXME ? ATAJ copy unbound bindings to ignore
			p.m_ignoreUnboundBindingForNames = oldP.m_ignoreUnboundBindingForNames;
		}

		Advice munger = world.getWeavingSupport().createAdviceMunger(attribute, p, signature, fromType);
		munger.bindingParameterTypes = bindingParameterTypes;
		munger.setDeclaringType(getDeclaringType());
		// System.err.println("concretizing here " + p + " with clause " +
		// clause);
		return munger;
	}

	// ---- from object

	@Override
	public String toString() {
		StringBuilder sb = new StringBuilder();
		sb.append("(").append(getKind()).append(extraParametersToString());
		sb.append(": ").append(pointcut).append("->").append(signature).append(")");
		return sb.toString();
		// return "("
		// + getKind()
		// + extraParametersToString()
		// + ": "
		// + pointcut
		// + "->"
		// + signature
		// + ")";
	}

	// XXX this perhaps ought to take account of the other fields in advice ...
	@Override
	public boolean equals(Object other) {
		if (!(other instanceof Advice)) {
			return false;
		}
		Advice o = (Advice) other;
		return o.kind.equals(kind) && ((o.pointcut == null) ? (pointcut == null) : o.pointcut.equals(pointcut))
				&& ((o.signature == null) ? (signature == null) : o.signature.equals(signature));
		// && (AsmManager.getDefault().getHandleProvider().dependsOnLocation() ? ((o.getSourceLocation() == null) ?
		// (getSourceLocation() == null)
		// : o.getSourceLocation().equals(getSourceLocation()))
		// : true) // pr134471 - remove when handles are improved
		// // to be independent of location
		// ;

	}

	private volatile int hashCode = 0;

	@Override
	public int hashCode() {
		if (hashCode == 0) {
			int result = 17;
			result = 37 * result + kind.hashCode();
			result = 37 * result + ((pointcut == null) ? 0 : pointcut.hashCode());
			result = 37 * result + ((signature == null) ? 0 : signature.hashCode());
			hashCode = result;
		}
		return hashCode;
	}

	// ---- fields

	public static final int ExtraArgument = 0x01;
	public static final int ThisJoinPoint = 0x02;
	public static final int ThisJoinPointStaticPart = 0x04;
	public static final int ThisEnclosingJoinPointStaticPart = 0x08;
	public static final int ParameterMask = 0x0f;
	// For an if pointcut, this indicates it is hard wired to access a constant of either true or false
	public static final int ConstantReference = 0x10;
	// When the above flag is set, this indicates whether it is true or false
	public static final int ConstantValue = 0x20;
	// public static final int CanInline = 0x40; // didnt appear to be getting used
	public static final int ThisAspectInstance = 0x40;

	// cant use 0x80 ! the value is written out as a byte and -1 has special meaning (-1 is 0x80...)

	// for testing only
	public void setLexicalPosition(int lexicalPosition) {
		start = lexicalPosition;
	}

	public boolean isAnnotationStyle() {
		return isAnnotationStyle;
	}

	public ResolvedType getConcreteAspect() {
		return concreteAspect;
	}

	public boolean hasMatchedSomething() {
		return hasMatchedAtLeastOnce;
	}

	public void setHasMatchedSomething(boolean hasMatchedSomething) {
		hasMatchedAtLeastOnce = hasMatchedSomething;
	}

	public abstract boolean hasDynamicTests();

}
