/*
    * Copyright 2008 Hippo
    *
    * 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 nl.hippo.client.webdav.caching;
  
  import java.io.IOException;
  import java.io.StringReader;
  import java.util.ArrayList;
  import java.util.Iterator;
  import java.util.List;
  
  import nl.hippo.client.api.ClientException;
  import nl.hippo.client.api.content.Property;
  import nl.hippo.client.api.event.EventValidity;
  import nl.hippo.client.api.event.EventValidityImpl;
  import nl.hippo.client.webdav.WebdavRequest;
  
  import org.apache.commons.lang.StringUtils;
  import org.xmlpull.v1.XmlPullParser;
  import org.xmlpull.v1.XmlPullParserException;
  import org.xmlpull.v1.XmlPullParserFactory;
  
  class EventValidityCalculator {
  
      private static final String SCOPE_ELEMENT_NAME = "scope";
      private static final String HREF_ELEMENT_NAME = "href";
  
      private static EventValidityCalculator calculator;
  
      private static XmlPullParserFactory factory;
      static {
          try {
              factory = XmlPullParserFactory.newInstance();
              factory.setNamespaceAware(true);
          } catch (XmlPullParserException e) {
              throw new ExceptionInInitializerError("Error while creating xpp pull parser" + e.getMessage());
          }
      }
  
      static EventValidity[] calculate(WebdavRequest request) throws ClientException {
          if (request == null) {
              throw new IllegalArgumentException("request may not be null");
          }
          if (request.getPath() == null) {
              return new EventValidity[0];
          }
          if (request.getRequestBody() == null) {
              return new EventValidityImpl[] { new EventValidityImpl(request.getPath().getFullPath()) };
          }
          try {
              // xmlpullparser is not thread safe: create new parser for each calculation
              return new EventValidityCalculator(factory.newPullParser()).execute(request);
          } catch (XmlPullParserException e) {
              // failed to calculate validity, just return empty
              return new EventValidity[0];
          }
      }
  
      private XmlPullParser xpp;
  
      private EventValidityCalculator(XmlPullParser xpp) {
          this.xpp = xpp;
      }
  
      private EventValidity[] execute(WebdavRequest request) throws ClientException {
          List validities = new ArrayList();
          try {
              xpp.setInput(new StringReader(request.getRequestBody()));
  
              while (nextElement(SCOPE_ELEMENT_NAME, Property.DAV_NAMESPACE)) {
                  if (nextElement(HREF_ELEMENT_NAME, Property.DAV_NAMESPACE)) {
                      xpp.next();
                      String scope = StringUtils.strip(getText());
                      if (scope != null) {
                          scope = StringUtils.stripEnd(scope, "/");
                          if (scope.startsWith("/")) {
                              validities.add(scope);
                          } else {
                              String validityPath = getValidityPath(request, scope);
                              validities.add(validityPath);
                          }
                      }
                  }
                  xpp.nextToken();
              }
  
              if (validities.size() == 0) {
                 validities.add(request.getPath().getFullPath());
             }
             return toArray(validities);
 
         } catch (XmlPullParserException e) {
             throw new ClientException("Error parsing document " + currentPositionString(), e);
         } catch (IOException e) {
             throw new ClientException("Error accessing document", e);
         }
     }
 
     private String getValidityPath(WebdavRequest request, String scope) {
         String result = request.getPath().getFullPath();
         if (StringUtils.isNotEmpty(scope)) {
             result += "/" + scope;
         }
         return result;
     }
 
     private boolean nextElement(String name, String namespace) throws XmlPullParserException, IOException {
         int type = xpp.getEventType();
         while (type != XmlPullParser.END_DOCUMENT) {
             type = xpp.next();
             if (type == XmlPullParser.START_TAG) {
                 if (verifyName(name) && verifyNamespace(namespace)) {
                     return true;
                 }
             }
         }
         return false;
     }
 
     private String getText() throws XmlPullParserException, IOException {
         int type = xpp.getEventType();
         while (type != XmlPullParser.TEXT) {
             if (type == XmlPullParser.START_TAG || type == XmlPullParser.END_DOCUMENT) {
                 return null;
             }
             type = xpp.next();        
         }
         if (type == XmlPullParser.TEXT) {
             return xpp.getText();
         } else {
             return null;
         }
     }
 
     private boolean verifyName(String name) {
         return xpp.getName().equals(name);
     }
 
     private boolean verifyNamespace(String ns) {
         if (ns == null || "".equals(ns)) {
             return xpp.getNamespace().length() == 0;
         } else {
             return ns.equals(xpp.getNamespace());
         }
     }
 
     private EventValidity[] toArray(List list) throws ClientException {
         int i = 0;
         EventValidity[] result = new EventValidity[list.size()];
         Iterator it = list.iterator();
         while (it.hasNext()) {
             result[i++] = new EventValidityImpl((String) it.next());
         }
         return result;
     }
 
     private String currentPositionString() {
         StringBuffer buf = new StringBuffer();
         buf.append("(line ").append(xpp.getLineNumber()).append(", col ").append(xpp.getColumnNumber()).append("): ");
         if (xpp.getNamespace() == null || "".equals(xpp.getNamespace())) {
             buf.append("\"").append(xpp.getName()).append("\"");
         } else {
             buf.append("\"{").append(xpp.getNamespace()).append("}").append(xpp.getName()).append("\"");
         }
         return buf.toString();
     }
 }