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.Hashtable;

 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.DatabaseException;

 public class Chapter extends ChapterBase implements Text, AdminSpecialised {

   public Chapter() {

   }

   private int pageNumber;

   public int getPageNumber() {

     return pageNumber;

   }

   public int getPreviousPageNumber() {

     return pageNumber - 1;

   }

   public int getNextPageNumber() {

     return pageNumber + 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 (DatabaseException 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 (NullPointerException e) {

       return 1; //FIXME Sticking plaster, I have no idea what is going on here, just stop the bleeding 

     } catch (Exception e) {

       throw new UnexpectedExceptionException(e);

     }

   }

   public Enumeration pageNumbers() {

     return new IntegerEnumeration(1, totalPages());

   }

   public Enumeration getMembersSlowly() {

     return new EmptyEnumeration();

   }

   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) {

       pageNumber = p;

       File file = new File(getCachePath(p));

       file.getParentFile().mkdirs();

       BufferedOutputStream w =

         new BufferedOutputStream(new FileOutputStream(file));

       try {

         Hashtable<String, Object> extras = new Hashtable<String, Object>();

         extras.put("pageNumber", new Integer(p));

         extras.put("content", bodyTextOfPage(spanOfPage(p)).textStringOrReader);

         getBibliomaniaDatabase().interpolateTemplateToFile("page.wm", file, this, extras);

       } finally {

         try {

           w.close();

         } catch (Exception e) {

           throw new RuntimeException(e);        

         }

       }

       BibliomaniaDatabase.notifyNewContentFile(file);

     }

   }

   public void paginate() throws Exception {

     System.err.println("Paginating chapter");

     assertCanWrite();

     BibliomaniaDatabase db = getBibliomaniaDatabase();

     File allPaged = allPagedFile();

     allPaged.getParentFile().mkdirs();

     final File temp = File.createTempFile("Chapter.encache", null, null);

     try {

       db.interpolateAsTemplate(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 = null;

       try {

         allPagedW = new BufferedWriter(new FileWriter(allPaged));

         db.pagination().paginate(

           unpaged,

           db.getPaginationTexHeader(),

           allPagedW,

           db.getFootnoteTemplate(),

           db.getWebMacro(),

           db.getContentEncoding());

       } finally {

         try {

           allPagedW.close();

         } catch (Exception e) {

           throw new RuntimeException(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 (DatabaseException 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 getBibliomaniaDatabase().getWMTemplet("Chapter-specials");

   }

   public SectionGroup getReadArea() {

     return getBook().getReadArea();

   }

   public Enumeration<ProductAssociation> getProductAssociations() {

     return new EmptyEnumeration<ProductAssociation>();

   }

   /* 

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

   }

 }