/*
    * Copyright 2006-2010 the original author or authors.
    *
    * 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.sourceforge.domian.specification;
  
  
  import java.util.HashSet;
  import java.util.Map;
  import java.util.Set;
  
  import org.apache.commons.lang.Validate;
  
  import static java.lang.Boolean.FALSE;
  import static java.lang.Boolean.TRUE;
  import static net.sourceforge.domian.util.ReflectionUtils.canCast;
  import static net.sourceforge.domian.util.ReflectionUtils.canCastAtLeastOneWay;
  
  
  /**
   * A composite specification where <i>all</i> of the wrapped specifications
   * must be satisfied for this overall composite specification to be satisfied.
   * <p/>
   * The boolean logic operator equivalent is <i><b>AND</b></i>.
   *
   * @author Eirik Torske
   * @since 0.1
   */
  final class ConjunctionSpecification<T> extends AbstractCompositeSpecification<T> {
  
      ConjunctionSpecification(final Class<T> type) {
          super(type);
      }
  
      @Override
      public Boolean isSatisfiedBy(final T candidate) {
          if (super.isSatisfiedBy(candidate)) {
              for (final Specification<? super T> wrappedSpec : this.specifications) {
                  if (wrappedSpec != null && !wrappedSpec.isSatisfiedBy(candidate)) {
                      return false;
                  }
              }
              return true;
          }
          return false;
      }
  
  
      @Override
      public Boolean isDisjointWith(final Specification<?> specification) {
          Validate.notNull(specification, "Specification parameter cannot be null");
  
          // Pruning: if same/equal specifications
          if (this == specification || this.equals(specification)) {
              return FALSE;
          }
  
          // Pruning: if specifications and types are fundamentally disjoint
          if (!canCastAtLeastOneWay(this.getType(), specification.getType())) {
              return TRUE;
          }
  
          // Pruning: if type-only spec - and candidate is negated type-only-spec
          if (this.isSpecifyingAllInstancesOfItsType()) {
              if (specification instanceof JointDenialSpecification) {
                  final Specification<?> negatedSpec = getNegatedSpecification((JointDenialSpecification<T>) specification);
                  if (negatedSpec.equals(this)) {
                      return TRUE;
                  }
              }
              return FALSE;
          }
  
          // Pruning: if building a composite specification with ParameterizedSpecification
          if (specification instanceof ParameterizedSpecification) {
              return FALSE;
          }
  
          if (specification instanceof ValueBoundSpecification) {
              for (final Specification<?> spec : this.specifications) {
                  if (!spec.isDisjointWith(specification)) {
                      return FALSE;
                  }
              }
              return TRUE;
          }
  
          if (specification instanceof JointDenialSpecification) {
             // Pruning: if specification and types are fundamentally disjoint
             final JointDenialSpecification jointDenialSpecification = (JointDenialSpecification) specification;
             final Specification negatedSpec = getNegatedSpecification(jointDenialSpecification);
             if (canCast(this.getType(), negatedSpec.getType()) && jointDenialSpecification.isTypeExcludingSpecification()) {
                 return TRUE;
             }
             // Delegate negated stuff to JointDenialSpecification
             return specification.isDisjointWith(this);
         }
 
         if (specification instanceof DisjunctionSpecification) {
             // Delegate to DisjunctionSpecification
             return specification.isDisjointWith(this);
         }
 
         // We have two conjunctions at hand...
         if (this.hasParameterization()) {
             final AbstractCompositeSpecification candidateCompositeSpecification = (AbstractCompositeSpecification) specification;
             if (candidateCompositeSpecification.hasParameterization()) {
                 final Map<String, Set<LeafSpecification>> leafSpecificationMap = this.getLeafSpecificationMap();
                 final Map<String, Set<LeafSpecification>> candidateLeafSpecificationMap = candidateCompositeSpecification.getLeafSpecificationMap();
                 for (final String memberName : leafSpecificationMap.keySet()) {
                     if (candidateLeafSpecificationMap.keySet().contains(memberName)) {
                         final Set<LeafSpecification> specificationSet = leafSpecificationMap.get(memberName);
                         final Set<LeafSpecification> memberSpecificationSet = candidateLeafSpecificationMap.get(memberName);
                         for (final Specification leafSpecification : specificationSet) {
                             for (final Specification memberLeafSpecification : memberSpecificationSet) {
                                 if (leafSpecification.isDisjointWith(memberLeafSpecification)) {
                                     return TRUE;
                                 }
                             }
                         }
                     } else {
                         return FALSE;
                     }
                 }
                 for (final String memberName : candidateLeafSpecificationMap.keySet()) {
                     if (leafSpecificationMap.keySet().contains(memberName)) {
                         final Set<LeafSpecification> specificationSet = leafSpecificationMap.get(memberName);
                         final Set<LeafSpecification> memberSpecificationSet = candidateLeafSpecificationMap.get(memberName);
                         for (final Specification leafSpecification : memberSpecificationSet) {
                             for (final Specification memberLeafSpecification : specificationSet) {
                                 if (leafSpecification.isDisjointWith(memberLeafSpecification)) {
                                     return TRUE;
                                 }
                             }
                         }
                     } else {
                         return FALSE;
                     }
                 }
                 return FALSE;
 
             } else {
                 return FALSE;
             }
 
         } else {
 
             // We have a non-parametrized/simple conjunction at hand...
             // Lemma: hvis alle disjointe til alle -> disjoint
             // Lemma: hvis alle de kandidat-wrappede specs som de "conjuncte" wrappede specs ikke er disjoint til tilsammen er lik kandidat-wrappede-spec'ene -> disjoint
             final AbstractCompositeSpecification<?> compositeSpecification = (AbstractCompositeSpecification) specification;
             final Set<Specification> notDisjointToSpecSet = new HashSet<Specification>();
             for (final Specification wrappedSpec : this.specifications) {
                 for (final Specification spec : compositeSpecification.specifications) {
                     if (!wrappedSpec.isDisjointWith(spec)) {
                         notDisjointToSpecSet.add(spec);
                     }
                 }
             }
             return notDisjointToSpecSet.isEmpty() || notDisjointToSpecSet.equals(compositeSpecification.specifications);
         }
     }
 
 
     @Override
     protected Boolean isSpecifyingAllInstancesOfItsType() {
         for (final Specification<? super T> wrappedSpec : this.specifications) {
             if (wrappedSpec instanceof AbstractCompositeSpecification) {
                 if (!((AbstractCompositeSpecification) wrappedSpec).isSpecifyingAllInstancesOfItsType()) {
                     return false;
                 }
             } else {
                 return false;
             }
         }
         return true;
     }
 
 
     @Override
     protected AbstractSpecification<T> purify(final boolean doPurifyInversions) {
         //setPurified(true);
         if (this.specifications.isEmpty()) {
             return this;
         }
         if (this.specifications.size() == 1) {
             Specification<? super T> wrappedSpec = this.specifications.iterator().next();
             // N/A for parameterized specs
             if (!(wrappedSpec instanceof ParameterizedSpecification)) {
                 return ((AbstractSpecification<T>) wrappedSpec).purify(true);
             }
         }
         final ConjunctionSpecification<T> newPurifiedConjunctionSpecification = new ConjunctionSpecification<T>(this.getType());
         //newPurifiedConjunctionSpecification.setPurified(true);
         for (final Specification wrappedSpec : this.specifications) {
             AbstractSpecification wrappedAbstractSpec = ((AbstractSpecification) wrappedSpec);
             //if (!wrappedAbstractSpec.isPurified()) {
             wrappedAbstractSpec = wrappedAbstractSpec.purify(true);
             //}
             if (wrappedAbstractSpec instanceof AbstractCompositeSpecification) {
                 if (((AbstractCompositeSpecification) wrappedAbstractSpec).isSpecifyingAllInstancesOfItsType()) {
                     if (this.specifications.size() < 2) {
                         newPurifiedConjunctionSpecification.specifications.add(wrappedAbstractSpec);
                     }
                 } else {
                     newPurifiedConjunctionSpecification.specifications.add(wrappedAbstractSpec);
                 }
             } else {
                 newPurifiedConjunctionSpecification.specifications.add(wrappedAbstractSpec);
 
             }
         }
         // Check one last time...
         if (this.specifications.size() == 1) {
             Specification<? super T> wrappepSpec = this.specifications.iterator().next();
             // N/A for parameterized specs
             if (!(wrappepSpec instanceof ParameterizedSpecification)) {
                 return ((AbstractSpecification<T>) wrappepSpec).purify(true);
             }
         }
         return newPurifiedConjunctionSpecification;
     }
 
 
     @Override
     protected Boolean isInvertible() {
         return containsValueBoundSpecificationsOnly(this) || containsSimpleCompositesOnly(this);
     }
 
 
     @Override
     protected Specification<T> invert() {
         if (containsValueBoundSpecificationsOnly(this) || containsSimpleCompositesOnly(this)) {
             return doBooleanAlgebraInversion();
         }
         throw new IllegalStateException();
     }
 
 
     private Specification<T> doBooleanAlgebraInversion() {
         final DisjunctionSpecification<T> disjunctionSpecification = new DisjunctionSpecification<T>(getType());
         for (final Specification<?> specification : this.getAllSpecifications()) {
             disjunctionSpecification.specifications.add(((AbstractSpecification<? super T>) specification).invert());
         }
         return disjunctionSpecification;
     }
 }