package org.paneris.bibliomania;
   
   import java.io.BufferedOutputStream;
   import java.io.BufferedWriter;
   import java.io.File;
   import java.io.FileOutputStream;
   import java.io.FileWriter;
   import java.io.OutputStream;
   import java.io.Writer;
  import java.sql.Timestamp;
  import java.util.Enumeration;
  import java.util.Hashtable;
  import java.util.Vector;
  
  import org.melati.poem.CachedSelection;
  import org.melati.poem.Column;
  import org.melati.poem.util.EmptyEnumeration;
  import org.melati.poem.util.MappedEnumeration;
  import org.melati.util.IoUtils;
  import org.melati.util.MelatiRuntimeException;
  import org.paneris.bibliomania.generated.UnitBase;
  
  public abstract class Unit extends UnitBase {
  
    public BibliomaniaDatabase getBibliomaniaDatabase () {
        return (BibliomaniaDatabase)getDatabase();
    }
  
    public Unit() {}
  
    public abstract long ftiTextID_start();
    public abstract long ftiTextID_limit();
    public abstract Unit getParentUnit();
    public abstract String getName();
    
    public abstract String getMetatag_description();
    public abstract String getMetatag_keywords();
    public abstract void appendCacheSubpath(StringBuffer buffer);
  
    public Enumeration getAncestors() {
        Vector v = new Vector();
        Unit p = getParentUnit();
        while ( p!= null) {
            v.addElement(p);
            p = p.getParentUnit();
        }
        return v.elements();
    }
    /*
  
  This only sort of works, ie it does not stop deleted 
  rows from being returned by normal select.
  If we really want to do this we do actually have to set the flags in the records.
  In which case might as well do it in SQL outside.
    public Boolean getDeleted() {
      return super.getDeleted().booleanValue() || 
              (getParentUnit() != null && getParentUnit().getDeleted().booleanValue()) 
             ? new Boolean(true) : new Boolean(false);
    }
    */
    private CachedSelection productAssociations = null;
    protected Enumeration getProductAssociations(Column c) {
      if (getTroid() == null)
        return new EmptyEnumeration();
      else {
        if (productAssociations == null)
          productAssociations =
              c.cachedSelectionWhereEq(getTroid());
        return productAssociations.objects();
      }
    }
    public abstract Enumeration getProductAssociations();
    
    public Enumeration getRelatedProducts() {
      return new MappedEnumeration(getProductAssociations()) {
            public Object mapped(Object productAssociation) {
                 return ((ProductAssociation)productAssociation).getProduct();
               }
            };
    }
   
    public static class NoSourceDirException extends MelatiRuntimeException {
      /**
       * 
       */
      private static final long serialVersionUID = 1L;
      public String description;
      public File dir;
  
      public NoSourceDirException(String description, File dir) {
        this.description = description;
        this.dir = dir;
      }
  
      public String getMessage() {
        return
            "Can't access the source directory " + dir + " for " + description +
            "---either it doesn't exist or it doesn't have the right permissions";
      }
   }
 
   public void appendCachePath(StringBuffer buffer) {
     buffer.append(getBibliomaniaDatabase().getCachedContentRootDir());
     appendCacheSubpath(buffer);
   }
 
   public String getCachePath() {
     StringBuffer buffer = new StringBuffer();
     appendCachePath(buffer);
     return buffer.toString();
   }
 
   public String getBoardName() {
     String n = getPath();
     if (n.endsWith("/"))
       n = n.substring(0, n.length() - 1);
     if (n.startsWith("/"))
       n = n.substring(1, n.length());
     return n.replace('/','.'); 
       
   }
 
   protected Hashtable speciallyTreatedInCache() {
     return null;
   }
 
   protected void writeLock() {
     super.writeLock();
     lastencached = null;
   }
 
   public abstract Enumeration<Unit> getMembersSlowly();
 
   public abstract String getDisplayName();
 
   public void readKeyDotTxt() throws Exception {
   }
 
   public void paginate() throws Exception {
   }
 
   public void index() throws Exception {
   }
 
   public void encache() throws Exception {
     assertCanWrite();
 
     File sourceDir = new File(getBibliomaniaDatabase().getContentRootDir(),
                               getPath());
     String[] sources = sourceDir.list();
     if (sources == null)
       sources = new String[0];
     // rather than throw new NoSourceDirException(toString(), sourceDir);
 
     File cachePath = new File(getCachePath());
     cachePath.mkdirs();
 
     Hashtable speci = speciallyTreatedInCache();
 
     for (int s = 0; s < sources.length; ++s) {
       String source = sources[s];
       File from = new File(sourceDir, source);
 
       if (!from.isDirectory() &&
           (speci == null || !speci.containsKey(source))) {
         File to;
         if (source.endsWith(".wm")) {
           to =
               new File(cachePath,
                        source.substring(0, source.length() - 3) + ".html");
           OutputStream w = new BufferedOutputStream(new FileOutputStream(to));
 
           try {
             getBibliomaniaDatabase().writeContentHeader(w, this, null);
             getBibliomaniaDatabase().interpolateAsTemplate(from, w, this);
             getBibliomaniaDatabase().writeContentFooter(w, this, null);
           }
           finally {
             try { w.close(); } catch (Exception e) {}
           }
         }
         else
           IoUtils.copy(from, 16384, to = new File(cachePath, source));
 
         BibliomaniaDatabase.notifyNewContentFile(to);
       }
     }
 
     File defaul = new File(cachePath, "index.html");
     if (!defaul.exists()) {
       Writer w = new BufferedWriter(new FileWriter(defaul));
       try {
         getBibliomaniaDatabase().interpolateTemplateToFile(
             "read/Default.wm", defaul, this);
       }
       finally {
         try { w.close(); } catch (Exception e) {}
       }
     }
 
     File redirec = new File(cachePath, "contents.html");
 
     {
       Writer w = new BufferedWriter(new FileWriter(redirec));
       try {
         getBibliomaniaDatabase().interpolateTemplateToFile(
             "Contents.wm", redirec, this);
       }
       finally {
         try { w.close(); } catch (Exception e) {}
       }
     }
 
     setLastencached(new Timestamp(System.currentTimeMillis()));
   }
 
   public String getURLSubpath() {
     return getBibliomaniaDatabase().getBib().urlPrefixed(
                "", null, null, this, null);
   }
 
   public String getURLSubpathReally() {
     return getBibliomaniaDatabase().getBib().urlPrefixedReally(
                "", null, null, this, null);
   }
 
   public abstract SectionGroup getReadArea();
 }