package org.paneris.bibliomania;
   
   import java.io.BufferedOutputStream;
   import java.io.BufferedWriter;
   import java.io.File;
   import java.io.FileInputStream;
   import java.io.FileOutputStream;
   import java.io.FileWriter;
   import java.io.IOException;
  import java.io.InputStream;
  import java.io.InputStreamReader;
  import java.io.Reader;
  import java.io.Writer;
  import java.sql.Timestamp;
  import java.util.Enumeration;
  import java.util.Map;
  
  import org.melati.Melati;
  import org.melati.admin.AdminSpecialised;
  import org.melati.poem.AccessPoemException;
  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.EmptyEnumeration;
  import org.melati.poem.util.IntegerEnumeration;
  import org.melati.util.IoUtils;
  import org.melati.poem.Treeable;
  import org.melati.util.UnexpectedExceptionException;
  import org.paneris.bibliomania.fti.FTIException;
  import org.paneris.bibliomania.fti.Text;
  import org.paneris.bibliomania.generated.ChapterBase;
  import org.paneris.bibliomania.pagination.Pagination;
  import org.webmacro.WebMacroException;
  
  import com.sleepycat.db.DbException;
  
  public class Chapter extends ChapterBase implements Text, AdminSpecialised {
    public Chapter() {
    }
  
    private int page;
  
    public int getPageNumber() {
      return page;
    }
    public int getPreviousPageNumber() {
      return page - 1;
    }
    public int getNextPageNumber() {
      return page + 1;
    }
  
    private CachedSelection previous = null;
  
    public Chapter getPrevious() {
      if (previous == null) {
        ChapterTable t = getChapterTable();
  
        String whereClause =
          t.getBookColumn().eqClause(getBook().troid())
            + " AND "
            + t.getSequenceColumn().eqClause(
              new Integer(getSequence().intValue() - 1));
  
        previous = new CachedSelection(t, whereClause, null);
      }
  
      return (Chapter)previous.firstObject();
    }
  
    private CachedSelection next = null;
  
    public Chapter getNext() {
      if (next == null) {
        ChapterTable t = getChapterTable();
  
        String whereClause =
          t.getBookColumn().eqClause(getBook().troid())
            + " AND "
            + t.getSequenceColumn().eqClause(
              new Integer(getSequence().intValue() + 1));
  
        next = new CachedSelection(t, whereClause, null);
      }
  
      return (Chapter)next.firstObject();
    }
  
    public Advert getAdvert() {
      return getBook().getAdvert();
    }
    public Layout getLayout() {
      return getBook().getLayout();
    }
  
    public Boolean getPaginated() {
      return getBook().getPaginated();
   }
 
   public String getFilepath() {
     return getPath() + getFilename();
   }
 
   public void setFilepath(String path, String filename) {
     setPath(path.charAt(path.length() - 1) == '/' ? path : path + '/');
     setFilename(filename);
   }
 
   public File originalBodyFile() {
     return new File(
       getBibliomaniaDatabase().getContentRootDir(),
       getFilepath());
   }
 
   public InputStream originalBody() throws IOException {
     InputStream it = new FileInputStream(originalBodyFile());
     PoemThread.toTidy().add(it);
     return it;
   }
 
   public void appendCacheSubpath(StringBuffer buffer) {
     getBook().appendCacheSubpath(buffer);
     buffer.append('/');
     buffer.append(troid());
   }
 
   public String getCachePath(int pageP) {
     StringBuffer buffer = new StringBuffer();
     appendCachePath(buffer);
     buffer.append('/');
     buffer.append(pageP);
     buffer.append(".html");
     return buffer.toString();
   }
 
   public File allPagedFile() {
     return new File(getCachePath(), "all.html");
   }
 
   public InputStream bodyUnsafe() throws IOException {
     InputStream it = new FileInputStream(allPagedFile());
     PoemThread.toTidy().add(it);
     return it;
   }
 
   public InputStream body() throws IOException {
     Capability canReadContent = getBook().getCanReadContent();
     if (canReadContent != null
       && !PoemThread.accessToken().givesCapability(canReadContent))
       throw new ContentAccessPoemException(
         getBook(),
         PoemThread.accessToken(),
         canReadContent);
 
     return bodyUnsafe();
   }
 
   public InputStream bodyForFragment() throws IOException {
     return bodyUnsafe();
   }
 
   public String bodyText() throws IOException {
     return new String(IoUtils.slurp(body(), 4096));
   }
 
   public static final int ftiTextID_section_shift = 32,
     ftiTextID_section_limit = 256,
     ftiTextID_author_shift = 21,
     ftiTextID_author_limit = 2048,
     ftiTextID_book_shift = 10,
     ftiTextID_book_limit = 2048,
     ftiTextID_sequence_shift = 0,
     ftiTextID_chapter_limit = 1024;
 
   public static final long ftiTextID_section_mask =
     ~((1l << ftiTextID_section_shift) - 1),
     ftiTextID_author_mask =
       ((1l << ftiTextID_section_shift) - 1)
         & ~((1l << ftiTextID_author_shift) - 1),
     ftiTextID_book_mask =
       ((1l << ftiTextID_author_shift) - 1)
         & ~((1l << ftiTextID_book_shift) - 1),
     ftiTextID_sequence_mask = (1l << ftiTextID_book_shift) - 1;
 
   public static long ftiTextID(int section, int author, int book, int seq) {
 
     // section author book seq
     //    8      11    11   10
 
     return (((long)section) << ftiTextID_section_shift)
       | (((long)author) << ftiTextID_author_shift)
       | (((long)book) << ftiTextID_book_shift)
       | (((long)seq) << ftiTextID_sequence_shift);
   }
 
   public long ftiTextID() {
     return ftiTextID(
       getBook().getSectionTroid().intValue(),
       getBook().getAuthorTroid().intValue(),
       getBook().getAuthorsequence().intValue(),
       sequence.intValue());
   }
 
   public long ftiTextID_start() {
     return ftiTextID();
   }
 
   public long ftiTextID_limit() {
     return ftiTextID() + (1L << ftiTextID_sequence_shift);
   }
 
   public Unit getParentUnit() {
     return getBook();
   }
 
   void notifyChangedTextID() {
     Long textidL = this.textid;
     if (book != null && sequence != null && textidL != null) {
       if (textidL.longValue() != ftiTextID()) {
         try {
           getBibliomaniaDatabase().fti().unIndex(textidL.longValue());
         } catch (Exception e) {
           throw new FTIException(e);
         }
 
         setTextid(null);
       }
     }
   }
 
   public void setBook(Book book) throws AccessPoemException {
     super.setBook(book);
     notifyChangedTextID();
   }
 
   public class TooManyChaptersException extends SequenceFTILimitsException {
     /**
      * 
      */
     private static final long serialVersionUID = 1L;
 
     public TooManyChaptersException(int seq, int limit) {
       super(seq, limit);
     }
 
     public Table getTable() {
       return getChapterTable();
     }
 
     public String getParentTable() {
       return "book";
     }
   }
 
   public void setSequence(Integer sequence) throws AccessPoemException {
     if (sequence != null && sequence.intValue() >= ftiTextID_chapter_limit)
       throw new TooManyChaptersException(
         sequence.intValue(),
         ftiTextID_chapter_limit);
     super.setSequence(sequence);
     notifyChangedTextID();
   }
 
   public static class PageBody {
     public Object textStringOrReader;
     public Integer nextPage;
 
     public PageBody(Reader text, Integer nextPage) {
       textStringOrReader = text;
       this.nextPage = nextPage;
     }
 
     public PageBody(InputStream text, Integer nextPage) {
       this(new InputStreamReader(text), nextPage);
     }
 
     public PageBody(String text, Integer nextPage) {
       textStringOrReader = text;
       this.nextPage = nextPage;
     }
   }
 
   public PageBody bodyTextOfPage(Pagination.PageSpan span) throws IOException {
     InputStream whole = body();
     whole.skip(span.startOffset);
     byte[] stuff = new byte[span.endOffset - span.startOffset];
 
     return new PageBody(
       new String(stuff, 0, whole.read(stuff, 0, stuff.length)),
       span.number + 2 > span.totalPages ? null : new Integer(span.number + 2));
   }
 
   public Pagination.PageSpan spanOfPage(int pageP) {
     try {
       return getBibliomaniaDatabase()
         .pagination()
         .new PageFinder()
         .pageOfNumber(
         ftiTextID(),
         pageP - 1);
     } catch (com.sleepycat.db.DbException e) {
       throw new UnexpectedExceptionException(e);
     }
   }
 
   public Pagination.PageSpan spanOfPage(Integer pageP) {
     return spanOfPage(pageP.intValue());
   }
 
   public PageBody bodyTextOfPage(Integer pageP) throws IOException {
     if (pageP == null || Boolean.FALSE.equals(getPaginated()))
       return new PageBody(body(), null);
     else {
       Pagination.PageSpan span = spanOfPage(pageP);
       return span == null ? new PageBody(body(), null) : bodyTextOfPage(span);
     }
   }
 
   public int totalPages() {
     try {
       return getBibliomaniaDatabase().pagination().new PageFinder().totalPages(
         ftiTextID());
     } catch (Exception e) {
       throw new UnexpectedExceptionException(e);
     }
   }
 
   public Enumeration pageNumbers() {
     return new IntegerEnumeration(1, totalPages());
   }
 
   public Enumeration getMembersSlowly() {
     return EmptyEnumeration.it;
   }
 
   public String getDisplayName() {
     return getTitle();
   }
 
   public void index() throws IOException {
     try {
       setTextid(ftiTextID()); // this does an assertCanWrite
       getBibliomaniaDatabase().fti().index(this);
     } catch (IOException e) {
       throw e;
     } catch (Exception e) {
       throw new FTIException(e);
     }
   }
 
   public void unIndex() {
     Long tid = getTextid();
     if (tid != null)
       try {
         getBibliomaniaDatabase().fti().unIndex(tid.longValue());
       } catch (Exception e) {
         throw new UnexpectedExceptionException(e);
       }
   }
 
   public void delete_unsafe_butCleanFTI() {
     unIndex();
     super.delete_unsafe();
   }
 
   public void delete(Map integrityFixOfColumn) {
     unIndex();
     super.delete(integrityFixOfColumn);
   }
 
   public void splitOutPages()
     throws WebMacroException, IOException {
 
     // this isn't as efficient as it could be but doesn't happen often
 
     for (int p = 1; p <= totalPages(); ++p) {
       page = p;
       File file = new File(getCachePath(p));
       file.getParentFile().mkdirs();
       BufferedOutputStream w =
         new BufferedOutputStream(new FileOutputStream(file));
       try {
         getBibliomaniaDatabase().writeContentHeader(
           w,
           this,
           p == 1 ? "page1Header.wm" : "pageHeader.wm");
         w.write(
           bodyTextOfPage(spanOfPage(p))
             .textStringOrReader
             .toString()
             .getBytes());
         getBibliomaniaDatabase().writeContentFooter(w, this, "pageFooter.wm");
       } finally {
         try {
           w.close();
         } catch (Exception e) {
         }
       }
 
       BibliomaniaDatabase.notifyNewContentFile(file);
     }
   }
 
   /**
    * Completely overrides Unit.encache
    */
 
   public void paginate() throws Exception {
     assertCanWrite();
 
     BibliomaniaDatabase db = getBibliomaniaDatabase();
 
     File allPaged = allPagedFile();
     allPaged.getParentFile().mkdirs();
 
     final File temp = File.createTempFile("Chapter.encache", null, null);
 
     try {
       db.macroexpand(originalBodyFile(), temp, this);
 
       final long textID = ftiTextID();
 
       Text unpaged = new Text() {
         public InputStream body() throws IOException {
           FileInputStream it = new FileInputStream(temp);
           PoemThread.toTidy().add(it);
           return it;
         }
 
         public InputStream bodyForFragment() throws IOException {
           return body();
         }
 
         public long ftiTextID() {
           return textID;
         }
       };
 
       Writer allPagedW = new BufferedWriter(new FileWriter(allPaged));
       try {
         db.pagination().paginate(
           unpaged,
           db.getPaginationTexHeader(),
           allPagedW,
           db.getFootnoteTemplate(),
           db.getWebMacro(),
           db.getContentEncoding());
       } finally {
         try {
           allPagedW.close();
         } catch (Exception e) {
         }
       }
     } finally {
       temp.delete();
     }
   }
 
   public void encache() throws Exception {
     assertCanWrite();
     splitOutPages();
     setLastencached(new Timestamp(System.currentTimeMillis()));
   }
 
   public String getMetatag_description() {
     return getBook().getMetatag_description();
   }
 
   public String getMetatag_keywords() {
     return getBook().getMetatag_keywords();
   }
   public String getLongTitle() {
     String titleCandidate = getLongtitle();
     return titleCandidate == null ? getTitle() : titleCandidate;
   }
 
   public Integer pageOfAnchor(String anchor) {
     try {
       BibliomaniaDatabase db = getBibliomaniaDatabase();
 
       String blockmarker =
         db.fti().blockmarkerBeforeFirstOccurrence(ftiTextID(), '#' + anchor);
 
       return blockmarker == null ? null : db.pageFromAnchor(blockmarker);
     } catch (DbException e) {
       throw new UnexpectedExceptionException(e);
     }
   }
 
   public String adminHandle(Melati melati, MarkupLanguage markupLanguage)
     throws Exception {
     return null;
   }
 
   public String adminSpecialFacilities(
     Melati melatiContext,
     MarkupLanguage markupLanguage)
     throws Exception {
     return getWMTemplet("Chapter-specials");
   }
 
   public SectionGroup getReadArea() {
     return getBook().getReadArea();
   }
 
   public Enumeration getProductAssociations() {
     return EmptyEnumeration.it;
   }
   
   /* 
    * @see org.melati.util.Treeable#getChildren()
    */
   public Treeable[] children = null;
    
   public Treeable[] getChildren() {
     return children;
   }
   /* 
    * @see org.melati.util.Treeable#getName()
    */
   public String getName() {
     return getDisplayName();
   }
 
 }