/*
 * Copyright 2014 - 2020 Rafael Winterhalter
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package net.bytebuddy.matcher;

import net.bytebuddy.build.HashCodeAndEqualsPlugin;
import net.bytebuddy.description.field.FieldDescription;
import net.bytebuddy.description.method.MethodDescription;
import net.bytebuddy.description.type.RecordComponentDescription;
import net.bytebuddy.description.type.TypeDescription;

import java.util.Arrays;
import java.util.List;

import static net.bytebuddy.matcher.ElementMatchers.*;

A latent matcher that resolves an ElementMatcher after supplying a type description. 
Type parameters:
<T> – The type of the matched element./**
 * A latent matcher that resolves an {@link ElementMatcher} after supplying a type description.
 *
 * @param <T> The type of the matched element.
 */
public interface LatentMatcher<T> {

    
Resolves the element matcher this instance represents for the supplied type description.
Params:
typeDescription – The type description for which the represented matcher should be resolved.
Returns:
An ElementMatcher that represents this matcher's resolved form./**
     * Resolves the element matcher this instance represents for the supplied type description.
     *
     * @param typeDescription The type description for which the represented matcher should be resolved.
     * @return An {@link ElementMatcher} that represents this matcher's resolved form.
     */
    ElementMatcher<? super T> resolve(TypeDescription typeDescription);

    
A latent matching methods that are declared by the resolved type.
/**
     * A latent matching methods that are declared by the resolved type.
     */
    enum ForSelfDeclaredMethod implements LatentMatcher<MethodDescription> {

        
Matches any method declared by the resolved type.
/**
         * Matches any method declared by the resolved type.
         */
        DECLARED(false),

        
Matches any method not declared by the resolved type.
/**
         * Matches any method not declared by the resolved type.
         */
        NOT_DECLARED(true);

        
true if the matcher is inverted. /**
         * {@code true} if the matcher is inverted.
         */
        private final boolean inverted;

        
Creates a new latent matcher for a self-declared method.
Params:
inverted – true if the matcher is inverted./**
         * Creates a new latent matcher for a self-declared method.
         *
         * @param inverted {@code true} if the matcher is inverted.
         */
        ForSelfDeclaredMethod(boolean inverted) {
            this.inverted = inverted;
        }

        
{@inheritDoc}
/**
         * {@inheritDoc}
         */
        @SuppressWarnings("unchecked")
        public ElementMatcher<? super MethodDescription> resolve(TypeDescription typeDescription) {
            // Casting is required by some Java 6 compilers.
            return (ElementMatcher<? super MethodDescription>) (inverted
                    ? not(isDeclaredBy(typeDescription))
                    : isDeclaredBy(typeDescription));
        }
    }

    
A latent matcher representing an already resolved ElementMatcher. 
Type parameters:
<S> – The type of the matched element./**
     * A latent matcher representing an already resolved {@link ElementMatcher}.
     *
     * @param <S> The type of the matched element.
     */
    @HashCodeAndEqualsPlugin.Enhance
    class Resolved<S> implements LatentMatcher<S> {

        
The resolved matcher.
/**
         * The resolved matcher.
         */
        private final ElementMatcher<? super S> matcher;

        
Creates a new resolved latent matcher.
Params:
matcher – The resolved matcher./**
         * Creates a new resolved latent matcher.
         *
         * @param matcher The resolved matcher.
         */
        public Resolved(ElementMatcher<? super S> matcher) {
            this.matcher = matcher;
        }

        
{@inheritDoc}
/**
         * {@inheritDoc}
         */
        public ElementMatcher<? super S> resolve(TypeDescription typeDescription) {
            return matcher;
        }
    }

    
A latent matcher where the field token is being attached to the supplied type description before matching.
/**
     * A latent matcher where the field token is being attached to the supplied type description before matching.
     */
    @HashCodeAndEqualsPlugin.Enhance
    class ForFieldToken implements LatentMatcher<FieldDescription> {

        
A token representing the field being matched.
/**
         * A token representing the field being matched.
         */
        private final FieldDescription.Token token;

        
Creates a new latent matcher for a field token.
Params:
token – A token representing the field being matched./**
         * Creates a new latent matcher for a field token.
         *
         * @param token A token representing the field being matched.
         */
        public ForFieldToken(FieldDescription.Token token) {
            this.token = token;
        }

        
{@inheritDoc}
/**
         * {@inheritDoc}
         */
        public ElementMatcher<? super FieldDescription> resolve(TypeDescription typeDescription) {
            return new ResolvedMatcher(token.asSignatureToken(typeDescription));
        }

        
A resolved matcher of a latent field matcher for a field token.
/**
         * A resolved matcher of a latent field matcher for a field token.
         */
        @HashCodeAndEqualsPlugin.Enhance
        protected static class ResolvedMatcher implements ElementMatcher<FieldDescription> {

            
The signature token representing the matched field.
/**
             * The signature token representing the matched field.
             */
            private final FieldDescription.SignatureToken signatureToken;

            
Creates a new resolved matcher.
Params:
signatureToken – The signature token representing the matched field./**
             * Creates a new resolved matcher.
             *
             * @param signatureToken The signature token representing the matched field.
             */
            protected ResolvedMatcher(FieldDescription.SignatureToken signatureToken) {
                this.signatureToken = signatureToken;
            }

            
{@inheritDoc}
/**
             * {@inheritDoc}
             */
            public boolean matches(FieldDescription target) {
                return target.asSignatureToken().equals(signatureToken);
            }
        }
    }

    
A latent matcher where the method token is being attached to the supplied type description before matching.
/**
     * A latent matcher where the method token is being attached to the supplied type description before matching.
     */
    @HashCodeAndEqualsPlugin.Enhance
    class ForMethodToken implements LatentMatcher<MethodDescription> {

        
A token representing the method being matched.
/**
         * A token representing the method being matched.
         */
        private final MethodDescription.Token token;

        
Creates a new latent matcher for a method token.
Params:
token – A token representing the method being matched./**
         * Creates a new latent matcher for a method token.
         *
         * @param token A token representing the method being matched.
         */
        public ForMethodToken(MethodDescription.Token token) {
            this.token = token;
        }

        
{@inheritDoc}
/**
         * {@inheritDoc}
         */
        public ElementMatcher<? super MethodDescription> resolve(TypeDescription typeDescription) {
            return new ResolvedMatcher(token.asSignatureToken(typeDescription));
        }

        
A resolved matcher of a latent method matcher for a method token.
/**
         * A resolved matcher of a latent method matcher for a method token.
         */
        @HashCodeAndEqualsPlugin.Enhance
        protected static class ResolvedMatcher implements ElementMatcher<MethodDescription> {

            
The signature token representing the matched field.
/**
             * The signature token representing the matched field.
             */
            private final MethodDescription.SignatureToken signatureToken;

            
Creates a new resolved matcher.
Params:
signatureToken – The signature token representing the matched field./**
             * Creates a new resolved matcher.
             *
             * @param signatureToken The signature token representing the matched field.
             */
            protected ResolvedMatcher(MethodDescription.SignatureToken signatureToken) {
                this.signatureToken = signatureToken;
            }

            
{@inheritDoc}
/**
             * {@inheritDoc}
             */
            public boolean matches(MethodDescription target) {
                return target.asSignatureToken().equals(signatureToken);
            }
        }
    }

    
A latent matcher for a record component token.
/**
     * A latent matcher for a record component token.
     */
    @HashCodeAndEqualsPlugin.Enhance
    class ForRecordComponentToken implements LatentMatcher<RecordComponentDescription> {

        
The token being matched.
/**
         * The token being matched.
         */
        private final RecordComponentDescription.Token token;

        
Creates a latent matcher for a record component token.
Params:
token – The token being matched./**
         * Creates a latent matcher for a record component token.
         *
         * @param token The token being matched.
         */
        public ForRecordComponentToken(RecordComponentDescription.Token token) {
            this.token = token;
        }

        
{@inheritDoc}
/**
         * {@inheritDoc}
         */
        public ElementMatcher<? super RecordComponentDescription> resolve(TypeDescription typeDescription) {
            return ElementMatchers.<RecordComponentDescription>named(token.getName());
        }
    }

    
A matcher that computes the conjunction of all supplied latent matchers.
Type parameters:
<S> – The type of the matched element./**
     * A matcher that computes the conjunction of all supplied latent matchers.
     *
     * @param <S> The type of the matched element.
     */
    @HashCodeAndEqualsPlugin.Enhance
    class Conjunction<S> implements LatentMatcher<S> {

        
The matchers this conjunction represents.
/**
         * The matchers this conjunction represents.
         */
        private final List<? extends LatentMatcher<? super S>> matchers;

        
Creates a new conjunction of latent matchers.
Params:
matcher – The matchers this conjunction represents./**
         * Creates a new conjunction of latent matchers.
         *
         * @param matcher The matchers this conjunction represents.
         */
        @SuppressWarnings("unchecked") // In absence of @SafeVarargs
        public Conjunction(LatentMatcher<? super S>... matcher) {
            this(Arrays.asList(matcher));
        }

        
Creates a new conjunction of latent matchers.
Params:
matchers – The matchers this conjunction represents./**
         * Creates a new conjunction of latent matchers.
         *
         * @param matchers The matchers this conjunction represents.
         */
        public Conjunction(List<? extends LatentMatcher<? super S>> matchers) {
            this.matchers = matchers;
        }

        
{@inheritDoc}
/**
         * {@inheritDoc}
         */
        public ElementMatcher<? super S> resolve(TypeDescription typeDescription) {
            ElementMatcher.Junction<S> matcher = any();
            for (LatentMatcher<? super S> latentMatcher : matchers) {
                matcher = matcher.and(latentMatcher.resolve(typeDescription));
            }
            return matcher;
        }
    }

    
A matcher that computes the disjunction of all supplied latent matchers.
Type parameters:
<S> – The type of the matched element./**
     * A matcher that computes the disjunction of all supplied latent matchers.
     *
     * @param <S> The type of the matched element.
     */
    @HashCodeAndEqualsPlugin.Enhance
    class Disjunction<S> implements LatentMatcher<S> {

        
The matchers this disjunction represents.
/**
         * The matchers this disjunction represents.
         */
        private final List<? extends LatentMatcher<? super S>> matchers;

        
Creates a new disjunction of latent matchers.
Params:
matcher – The matchers this disjunction represents./**
         * Creates a new disjunction of latent matchers.
         *
         * @param matcher The matchers this disjunction represents.
         */
        @SuppressWarnings("unchecked") // In absence of @SafeVarargs
        public Disjunction(LatentMatcher<? super S>... matcher) {
            this(Arrays.asList(matcher));
        }

        
Creates a new disjunction of latent matchers.
Params:
matchers – The matchers this disjunction represents./**
         * Creates a new disjunction of latent matchers.
         *
         * @param matchers The matchers this disjunction represents.
         */
        public Disjunction(List<? extends LatentMatcher<? super S>> matchers) {
            this.matchers = matchers;
        }

        
{@inheritDoc}
/**
         * {@inheritDoc}
         */
        public ElementMatcher<? super S> resolve(TypeDescription typeDescription) {
            ElementMatcher.Junction<S> matcher = none();
            for (LatentMatcher<? super S> latentMatcher : matchers) {
                matcher = matcher.or(latentMatcher.resolve(typeDescription));
            }
            return matcher;
        }
    }
}