package org.paneris.bibliomania;
   
   import javax.servlet.ServletConfig;
   
   import org.melati.Melati;
   import org.melati.MelatiConfig;
   import org.melati.login.AccessHandler;
   import org.melati.poem.PoemThread;
   import org.melati.PoemContext;
  import org.melati.servlet.PathInfoException;
  import org.melati.template.webmacro.WebmacroMelatiServlet;
  import org.melati.poem.util.StringUtils;
  import org.webmacro.servlet.WebContext;
  
  abstract public class BibliomaniaServlet extends WebmacroMelatiServlet {
  
    public static final String templatePrefix = "org/paneris/bibliomania/html/";
  
    public String getSysAdminName () {
      return "TimP";
    }
    public String getSysAdminEmail () {
      return "timp@paneris.org";
    }
  
    /**
     * A template name. 
     * 
     * @param name the name excluding template engine specific extension
     * @return A template name
     */
    public static String bibliomaniaTemplate(String name) {
      return templatePrefix + name;
    }
  
    protected MelatiConfig melatiConfig() {
      MelatiConfig config = super.melatiConfig();
       config.setAccessHandler(new BibliomaniaAccessHandler());
      return config;
    }
  
    protected String bibliomaniaHandle(Melati melati, WebContext context) 
        throws Exception {
      String method = melati.getMethod();
      if (method == null) {
          method="undefinedMethod";
      }
      return bibliomaniaTemplate(method);
    }
  
    public class BibContext extends PoemContext {
      public Integer page;
      public String pathInfo;
    }
  
    protected void decipherExtraPathInfo(String[] parts, BibContext it) {
    }
  
    protected void fillContext(Melati melati, BibContext it)
        throws PathInfoException {
      it.setLogicalDatabase("bibliomania");
  
      String pathInfo = melati.getRequest().getPathInfo();
      it.pathInfo = pathInfo;
      if (pathInfo == null) return;
      String[] parts = StringUtils.split(pathInfo, '/');
      if (parts.length < 2) return;
  
      try {
        int p;
        for (p = 2; p < parts.length && p <= 7; ++p) {
          String part = parts[p];
          if (!part.equals("-") &&
              (part.length() == 0 || !Character.isDigit(part.charAt(0)) ||
              part.endsWith(".html")))
            break;
        }
  
        while (parts[p-1].equals("-")) --p;
  
        it.setTroid(new Integer(parts[p-1]));
  
        switch (p) {
          case 2:
            it.setTable("sectiongroup");
            break;
          case 3:
            it.setTable("section");
            break;
          case 4:
            it.setTable("author");
            break;
          case 5:
            it.setTable("book");
            break;
          case 7:
            it.page = new Integer(parts[p-1]);
            it.setTroid(new Integer(parts[p-2]));
            it.setTable("chapter");
           break;
         case 6:
           it.setTable("chapter");
           break;
         default:
           throw new ArrayIndexOutOfBoundsException();
       }
     }
     catch (Exception e) {
       throw new PathInfoException(pathInfo, e);
     }
   }
 
   protected BibContext melatiContext() {
     return new BibContext();
   }
 
   //private TempletLoader templetLoader = new ClassNameTempletLoader();
   protected PoemContext poemContext(Melati melati) 
       throws PathInfoException {
     BibContext it = melatiContext();
 
     fillContext(melati, it);
     return it;
   }
 
   protected final String handle (Melati melati, WebContext context)
       throws Exception {
 
     BibliomaniaDatabase db = (BibliomaniaDatabase)melati.getDatabase();
 
     //Persistent it = melati.getObject();
     //BibContext melatiContext = (BibContext)melati.getPoemContext();
 
     db.setupContext(melati, context, (Unit)melati.getObject());
 
     return bibliomaniaHandle(melati, context);
   }  
 
   private AccessHandler accessHandler = new BibliomaniaAccessHandler();
 
   protected AccessHandler accessHandler() {
     return accessHandler;
   }
   
   public void assertRegisteredUser(BibliomaniaDatabase db) {
     if (!PoemThread.accessToken().givesCapability(
         db.getRegisteredUserCapability()))
       throw new NotLoggedInException();
   }
   
   private static final Boolean[] startedCommandServer = new Boolean[1];
 
   public void init(ServletConfig config) throws javax.servlet.ServletException {
     super.init(config);
     if (startedCommandServer[0] == null) {
       synchronized (startedCommandServer) {
         if (startedCommandServer[0] == null) {
           try {
             new CommandServer(0xB1B, 1).start(); //2843
             System.err.println("Started command server");
           }
           catch (Exception e) {
             System.err.println("Unable to start command server: " + e);
           }
 
           startedCommandServer[0] = Boolean.TRUE;
         }
       }
     }
   }
 }