package org.paneris.bibliomania;
   
   import java.io.BufferedWriter;
   import java.io.ByteArrayInputStream;
   import java.io.File;
   import java.io.FileInputStream;
   import java.io.FileWriter;
   import java.io.IOException;
   import java.io.InputStream;
  import java.io.Writer;
  import java.util.Enumeration;
  import java.util.Hashtable;
  
  import org.melati.Melati;
  import org.melati.admin.AdminSpecialised;
  import org.melati.poem.CachedSelection;
  import org.melati.poem.Capability;
  import org.melati.poem.PoemThread;
  import org.melati.poem.Table;
  import org.melati.template.MarkupLanguage;
  import org.melati.poem.util.ArrayUtils;
  import org.melati.poem.util.EmptyEnumeration;
  import org.melati.poem.Treeable;
  import org.paneris.bibliomania.fti.FTIException;
  import org.paneris.bibliomania.fti.Text;
  import org.paneris.bibliomania.generated.BookBase;
  
  public class Book extends BookBase implements AdminSpecialised, Text {
  
    public String getFulltitle() {
      String it = getFulltitleifdifferent();
      return it == null ? getTitle() : it;
    }
  
    public File getSourceDir() {
      return new File(getBibliomaniaDatabase().getContentRootDir(), getPath());
    }
  
    public class TooManyBooksException extends SequenceFTILimitsException {
      /**
       * 
       */
      private static final long serialVersionUID = 1L;
  
      public TooManyBooksException(int seq, int limit) {
        super(seq, limit);
      }
  
      public Table getTable() {
        return getBookTable();
      }
  
      public String getParentTable() {
        return "author";
      }
    }
  
    public void setAuthorsequence(Integer s) {
      if (s != null && s.intValue() >= Chapter.ftiTextID_book_limit)
        throw new TooManyBooksException(
          s.intValue(),
          Chapter.ftiTextID_book_limit);
      super.setAuthorsequence(s);
    }
  
    private void notifyChangedTextIDs() {
      for (Enumeration c = getChapters(); c.hasMoreElements();)
         ((Chapter)c.nextElement()).notifyChangedTextID();
    }
  
    public void setAuthor(Author author) {
      if (!author.troid().equals(this.author)) {
        super.setAuthor(author);
        setAuthorsequence(author.firstFreeAuthorsequence());
        notifyChangedTextIDs();
      }
    }
  
    private CachedSelection<Chapter> chapters = null;
  
    public Enumeration getChapters() {
      if (getTroid() == null)
        return new EmptyEnumeration<Chapter>();
      else {
        if (chapters == null)
          chapters =
            getBibliomaniaDatabase()
              .getChapterTable()
              .getBookColumn()
              .cachedSelectionWhereEq(getTroid());
        return chapters.objects();
      }
    }
  
    public Enumeration getProductAssociations() {
      return getProductAssociations(
        getBibliomaniaDatabaseTables()
          .getProductAssociationTable()
          .getBookColumn());
   }
 
   public Enumeration getMembersSlowly() {
     return getChapters();
   }
 
   public Chapter chapter(int sequence) {
     getChapters();
     return (Chapter)chapters.nth(sequence);
   }
 
   public Chapter getChapter0() {
     getChapters();
     return (Chapter)chapters.firstObject();
   }
 
   public String getCha0JS() {
     Boolean hnfp = getHasnofrontpage();
     if (hnfp != null && hnfp.booleanValue()) {
       Chapter c0 = getChapter0();
       if (c0 != null)
         return c0.troid().toString();
     }
 
     return "null";
   }
 
   public void setSection(Section section) {
     if (!(section == null
       ? this.section == null
       : section.troid().equals(this.section))) {
       super.setSection(section);
       notifyChangedTextIDs();
     }
   }
 
   public Capability getCanReadContent() {
     Capability it = getOverridecanreadcontent();
     return it == null ? getSection().getDefaultcanreadcontent() : it;
   }
 
   public String adminHandle(Melati melati, MarkupLanguage markupLanguage)
     throws Exception {
     return null;
   }
 
   public String adminSpecialFacilities(
     Melati melati,
     MarkupLanguage markupLanguage)
     throws Exception {
     return getBibliomaniaDatabase().getWMTemplet("Book-specials");
   }
 
   public long ftiTextID() {
     return ftiTextID_start() | ((1L << Chapter.ftiTextID_book_shift) - 1);
   }
 
   public InputStream body() throws IOException {
     if (Boolean.TRUE.equals(getHasnofrontpage()))
       return new ByteArrayInputStream((getTitle() +
       /* FIXME */
       " xyxyx xyxyx").getBytes());
     else {
       File f = getFrontPageFile();
       if (f.exists()) {
         InputStream it = new FileInputStream(f);
         PoemThread.toTidy().add(it);
         return it;
       } else
         return new ByteArrayInputStream(new byte[0]);
     }
   }
 
   public InputStream bodyForFragment() throws IOException {
     return body();
   }
 
   public long ftiTextID_start() {
     return Chapter.ftiTextID(
       getSectionTroid().intValue(),
       getAuthorTroid().intValue(),
       getAuthorsequence().intValue(),
       0);
   }
 
   public long ftiTextID_limit() {
     return ftiTextID_start() + (1L << Chapter.ftiTextID_book_shift);
   }
 
   public Unit getParentUnit() {
     return getAuthor();
   }
 
   public String getDisplayName() {
     return getFulltitle();
   }
 
   public void appendCacheSubpath(StringBuffer buffer) {
     getAuthor().appendCacheSubpath(buffer);
     buffer.append('/');
     buffer.append(troid());
   }
 
   public void readKeyDotTxt() {
     org.paneris.bibliomania.population.KeyDotTxtFilter.populate(this);
   }
 
   public static final String frontPageFileName = "index.html";
   public static final String frontPageSourceFileName = "index.wm";
 
   protected Hashtable<String, Boolean> speciallyTreatedInCache() {
     Hashtable<String, Boolean> them = new Hashtable<String, Boolean>();
     for (Enumeration c = getChapters(); c.hasMoreElements();)
       them.put(((Chapter)c.nextElement()).getFilename(), Boolean.TRUE);
     them.put(frontPageSourceFileName, Boolean.TRUE);
     them.put(frontPageFileName, Boolean.TRUE);
     return them;
   }
 
   public File getFrontPageFile() {
     return new File(getCachePath(), "index.html");
   }
 
   public boolean hasTOC() {
     File toc = new File(getSourceDir(), "index.wm");
     return toc.exists();
   }
   public void index() throws IOException {
     try {
       getBibliomaniaDatabase().infoFTI().index(this);
     } catch (IOException e) {
       throw e;
     } catch (Exception e) {
       throw new FTIException(e);
     }
   }
 
   public void encache() throws Exception {
     super.encache();
     File whole = new File(getCachePath(), "whole.html");
 
     {
       Writer w = new BufferedWriter(new FileWriter(whole));
       try {
         getBibliomaniaDatabase().interpolateTemplateToFile("Whole.wm", whole, this);
       } finally {
         try {
           w.close();
         } catch (Exception e) {
         }
       }
     }
 
     Boolean hnfp = getHasnofrontpage();
     if (hnfp != null && !hnfp.booleanValue()) {
       getBibliomaniaDatabase().interpolateTemplateToFile(
         "read/Book.wm",
         getFrontPageFile(),
         this);
     }
   }
 
   public SectionGroup getReadArea() {
     return getSection().getReadArea();
   }
 
   /* 
    * @see org.melati.util.Treeable#getChildren()
    */
   public Treeable[] children = null;
 
   @SuppressWarnings({ "rawtypes", "unchecked" })
   public Treeable[] getChildren() {
     if (children == null) {
       Object[] kids = ArrayUtils.arrayOf((Enumeration<Object>)getChapters());
       children = new Treeable[kids.length];
       for (int i=0; i<kids.length; i++) {
         children[i] = (Treeable)kids[i];
       }
     }
     return children;
   }
   /* 
    * @see org.melati.util.Treeable#getName()
    */
   public String getName() {
     return getDisplayName();
   }
 }