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();

   }

 }