package org.webslinger.rules;

 import java.io.IOException;

 import java.util.Arrays;

 import java.util.ListIterator;

 import javax.servlet.ServletException;

 import javax.servlet.ServletRequest;

 import org.webslinger.Webslinger;

 import org.webslinger.container.WebslingerContainer;

 public abstract class AbstractSelector extends SimpleNode {

     protected int[] specificity;

     protected AbstractRestriction[] restrictions = new AbstractRestriction[0];

     public AbstractSelector(int id) {

         super(id);

     }

     public AbstractSelector(Rules p, int id) {

         super(p, id);

     }

     public boolean matches(ServletRequest request, Webslinger top) throws IOException, ServletException {

         if (!checkRestrictions(request, top)) return false;

         if (parent instanceof AbstractSelector) {

             if (top.getParent() == null) return false;

             return ((AbstractSelector) parent).matches(request, top.getParent());

         }

         return true;

     }

     public void updateSpecificity(int[] specificity, boolean[] isConstantHolder) {

         if (parent instanceof AbstractSelector) ((AbstractSelector) parent).updateSpecificity(specificity, isConstantHolder);

         for (AbstractRestriction restriction: restrictions) {

             restriction.updateSpecificity(specificity, isConstantHolder);

         }

     }

     protected boolean checkRestrictions(ServletRequest request, Webslinger top) throws IOException, ServletException {

         for (AbstractRestriction restriction: restrictions) {

             if (!restriction.matches(request, top)) return false;

         }

         return true;

     }

     public void addRestriction(AbstractRestriction restriction) {

         AbstractRestriction[] tmp = new AbstractRestriction[restrictions.length + 1];

         System.arraycopy(restrictions, 0, tmp, 0, restrictions.length);

         tmp[restrictions.length] = restriction;

         restrictions = tmp;

     }

     public void compile(WebslingerContainer container) throws IOException {

         ListIterator it = getChildrenIterator();

         while (it.hasNext()) {

             Node child = (Node) it.next();

             if (child instanceof AbstractRestriction) {

                 addRestriction((AbstractRestriction) child);

                 it.remove();

             } else if (child instanceof AbstractSelector) {

                 ((AbstractSelector) child).compile(container);

             } else {

                 throw new InternalError("Unknown child: " + child);

             }

         }

     }

     public String toString() {

         if (restrictions.length == 0) return super.toString();

         return super.toString() + Arrays.asList(restrictions).toString();

     }

 }