package org.paneris.bibliomania.pagination;

 import java.io.BufferedReader;

 import java.io.BufferedWriter;

 import java.io.ByteArrayOutputStream;

 import java.io.File;

 import java.io.FileInputStream;

 import java.io.FileNotFoundException;

 import java.io.FileWriter;

 import java.io.IOException;

 import java.io.InputStream;

 import java.io.InputStreamReader;

 import java.io.PrintWriter;

 import java.io.Reader;

 import java.io.StreamTokenizer;

 import java.io.StringWriter;

 import java.io.Writer;

 import java.net.URL;

 import java.util.Enumeration;

 import java.util.Hashtable;

 import java.util.Stack;

 import java.util.Vector;

 import javax.swing.text.AttributeSet;

 import javax.swing.text.BadLocationException;

 import javax.swing.text.MutableAttributeSet;

 import javax.swing.text.html.HTML;

 import javax.swing.text.html.HTMLEditorKit;

 import org.melati.Melati;

 import org.melati.MelatiConfig;

 import org.melati.template.webmacro.MelatiFastWriter;

 import org.paneris.bibliomania.util.FictionalNotifiableParserCallback;

 import org.paneris.bibliomania.util.FictionalNotifyingDocumentParser;

 import org.melati.util.FtellPrintWriter;

 import org.melati.util.FtellWriter;

 import org.melati.util.HTMLUtils;

 import org.melati.util.IoUtils;

 import org.melati.util.MelatiRuntimeException;

 import org.melati.poem.util.StringUtils;

 import org.melati.util.UnexpectedExceptionException;

 import org.paneris.bibliomania.fti.DbUtils;

 import org.paneris.bibliomania.fti.FivePacker;

 import org.paneris.bibliomania.fti.FourPacker;

 import org.paneris.bibliomania.fti.Text;

 import org.webmacro.Context;

 import org.webmacro.WM;

 import org.webmacro.WebMacro;

 import org.webmacro.engine.FileTemplate;

 import com.sleepycat.db.Database;

 import com.sleepycat.db.DatabaseException;

 import com.sleepycat.db.DatabaseEntry;

 import com.sleepycat.db.LockMode;

 import com.sleepycat.db.OperationStatus;

 public class Pagination {

   public static final String pageAnchorPrefix = "__page__";

   /**

    * If you change this, no shell metacharacters please.

    */

   public static final File tempDir = new File("/tmp");

   public static final String dvi2ttyWithBreakinfo = "dvi2tty_breakinfo";

   private Database pageBreaksOfTextID;

   public Pagination(File dbHome) throws DatabaseException, IOException {

     pageBreaksOfTextID = DbUtils.openOrCreateBTreeDb(dbHome, "pageBreaksOfTextID", 0);

     //pageBreaksOfTextID.open(null, new File(dbHome, "pageBreaksOfTextID.db")

     //    .getPath(), null, DbConstants.DB_BTREE, DbConstants.DB_CREATE, 0644);

     // provoke exception now rather than later:

     HTMLUtils.dtdForHTMLParser();

   }

   public class PageSpan {

     public int number;

     public int startOffset, endOffset;

     public int totalPages;

     public PageSpan(int number, int startOffset, int endOffset, int totalPages) {

       this.number = number;

       this.startOffset = startOffset;

       this.endOffset = endOffset;

       this.totalPages = totalPages;

     }

     public String toString() {

       return number + "/" + totalPages + ":" + startOffset + "-" + endOffset;

     }

   }

   public static class TagInTexException extends RuntimeException {

     private static final long serialVersionUID = 1L;

     public HTML.Tag tag;

     public AttributeSet atts;

     public TagInTexException(HTML.Tag tag, AttributeSet atts) {

       this.tag = tag;

       this.atts = atts;

     }

     public String getMessage() {

       return "The element `"

           + (atts == null ? tag.toString() : HTMLUtils.stringOf(tag, atts))

           + "' occurs inside <span class=tex>. "

           + "If you really want to put < or > in the literal TeX code, you "

           + "should use < and >.";

     }

   }

   public static class FootnoteSequence {

     public int lastNumber = 0;

     private int spansOnStack = 0;

     public static class NestingException extends RuntimeException {

       private static final long serialVersionUID = 1L;

       public HTML.Tag tag;

       public AttributeSet atts;

       public NestingException(HTML.Tag tag, AttributeSet atts) {

         this.tag = tag;

         this.atts = atts;

       }

       public String getMessage() {

         return "The element " + HTMLUtils.stringOf(tag, atts) + " "

             + "constitutes a footnote-within-a-footnote, which is not allowed";

       }

     }

     public int number(HTML.Tag tag, AttributeSet atts) {

       boolean isSpan = tag.toString().equalsIgnoreCase("span");

       boolean isFootnote = isSpan

           && atts.isDefined(HTML.Attribute.CLASS)

           && atts.getAttribute(HTML.Attribute.CLASS).toString()

               .equalsIgnoreCase("footnote");

       if (spansOnStack > 0) {

         if (isSpan)

           ++spansOnStack;

         if (isFootnote)

           throw new NestingException(tag, atts);

       } else {

         if (isFootnote) {

           ++spansOnStack;

           if (atts.isDefined("number")) {

             try {

               lastNumber = Integer.parseInt(atts.getAttribute("number")

                   .toString());

             } catch (Exception e) {

               ++lastNumber;

             }

           } else

             ++lastNumber;

           return lastNumber;

         }

       }

       return -1;

     }

     public boolean inFootnote() {

       return spansOnStack > 0;

     }

     public boolean footnoteEnded(HTML.Tag tag) {

       if (spansOnStack != 0 && tag.toString().equalsIgnoreCase("span")

           && --spansOnStack == 0) {

         return true;

       } else

         return false;

     }

   }

   public class PageFinder {

     private DatabaseEntry textID = DbUtils.userMemDatabaseEntry(5);

     private DatabaseEntry pageBreaks = DbUtils.userMemDatabaseEntry(1000);

     private long theTextID = -1;

     private byte[] thePageBreaks = null;

     private synchronized byte[] pageBreaks(long textIdP) throws DatabaseException {

       if (theTextID != textIdP) {

         FivePacker.set_(this.textID.getData(), 0, textIdP);

         theTextID = textIdP;

         if (pageBreaksOfTextID.get(null, this.textID, pageBreaks, LockMode.DEFAULT) == OperationStatus.SUCCESS) {

           thePageBreaks = new byte[pageBreaks.getSize() + 4];

           System.arraycopy(pageBreaks.getData(), 0, thePageBreaks, 4,

               thePageBreaks.length - 4);

         } else

           thePageBreaks = null;

       }

       return thePageBreaks;

     }

     public int totalPages(long textIdP) throws DatabaseException {

       byte[] pageBreaksL = pageBreaks(textIdP);

       return pageBreaksL == null ? 0 : pageBreaksL.length / 4 - 1;

     }

     public PageSpan pageOfNumber(long textIdP, int number) throws DatabaseException {

       byte[] pageBreaksL = pageBreaks(textIdP);

       if (pageBreaksL == null || pageBreaksL.length < (number + 2) * 4)

         return null;

       else

         return new PageSpan(number,

             FourPacker.number_(pageBreaksL, number * 4), FourPacker.number_(

                 pageBreaksL, (number + 1) * 4), pageBreaksL.length / 4 - 1);

     }

     public PageSpan pageOfOffset(long textIdP, int offset) throws DatabaseException {

       byte[] pageBreaksL = pageBreaks(textIdP);

       if (pageBreaksL == null || pageBreaksL.length == 0)

         return null;

       int lastBreakOffset = FourPacker.number_(pageBreaksL,

           pageBreaksL.length - 4);

       if (offset >= lastBreakOffset)

         return null;

       int totalPages = pageBreaksL.length / 4 - 1;

       int p = (int)((long)offset * pageBreaksL.length / lastBreakOffset);

       if ((p + 1) * 4 >= pageBreaksL.length)

         p = (pageBreaksL.length / 4) - 1;

       int offP = FourPacker.number_(pageBreaksL, p * 4);

       if (offP == offset)

         return (p + 2) * 4 >= pageBreaksL.length ? null : new PageSpan(p, offP,

             FourPacker.number_(pageBreaksL, (p + 1) * 4), totalPages);

       else if (offP < offset) {

         for (;;) {

           int offP1 = FourPacker.number_(pageBreaksL, (p + 1) * 4);

           if (offP1 > offset)

             return new PageSpan(p, offP, offP1, totalPages);

           ++p;

           offP = offP1;

         }

       } else {

         int offP1;

         do {

           --p;

           if (p < 0)

             return new PageSpan(0, 0, offP, totalPages);

           offP1 = offP;

           offP = FourPacker.number_(pageBreaksL, p * 4);

         } while (offP > offset);

         return new PageSpan(p, offP, offP1, totalPages);

       }

     }

   }

   private static class TexGeneratingCallback extends

       HTMLEditorKit.ParserCallback {

     private static final int NONE = 0, SPACE = 1, NOSPACE = 2;

     private int wordBreak = SPACE;

     private FtellPrintWriter tex;

     private int pos = 0;

     //private int inFootnote = 0;

     private FootnoteSequence footnoteSequence = new FootnoteSequence();

     private boolean passthrough = false;

     private long lastTexLineBreak = 0;

     public TexGeneratingCallback(FtellPrintWriter tex) {

       this.tex = tex;

     }

     private void writeTexSpace() {

       long here = tex.ftell();

       if (here - lastTexLineBreak > 1000) {

         tex.write('\n');

         lastTexLineBreak = here;

       } else

         tex.write(' ');

     }

     public void handleText(char[] text, int _pos) {

       if (passthrough) {

         tex.write("in passthough:");

         tex.write(text);

         tex.write(":");

       } else if (!footnoteSequence.inFootnote()) {

         tex.write('{');

         for (int i = 0; i < text.length; ++i) {

           char c = text[i];

           if (Character.isWhitespace(c)) {

             writeTexSpace();

             wordBreak = SPACE;

           } else if (c == '-' || c == 173) {

             tex.write(c);

             wordBreak = NOSPACE;

           } else {

             if (wordBreak == SPACE)

               writeTexSpace();

             switch (c) {

             case '!':

             case '@':

             case '*':

             case '(':

             case ')':

             case '.':

             case ',':

             case '/':

             case '?':

             case '[':

             case ']':

             case '|':

             case '=':

             case '+':

               tex.write(c);

               break;

             case 151:

               tex.write("---");

               break;

             case 145:

               tex.write('`');

               break;

             case 146:

               tex.write('\'');

               break;

             case 147:

               tex.write("``");

               break;

             case 148:

               tex.write("''");

               break;

             default:

               if ('a' <= c && c <= 'z' || 'A' <= c && c <= 'Z' || '0' <= c

                   && c <= '9')

                 tex.write(c);

               else if (32 <= c && c < 128) {

                 tex.write("\\char");

                 tex.write(Integer.toString(c));

                 writeTexSpace();

               }

             }

             if (wordBreak != NONE) {

               tex.write("\\special{.=");

               tex.write("" + (pos + i));

               tex.write("}");

               wordBreak = NONE;

             }

           }

         }

         tex.write('}');

       }

       else tex.write("Seem to be in footnote:" + text);

     }

     public void handleSimpleTag(HTML.Tag tag, MutableAttributeSet a, int posP) {

       if (passthrough)

         throw new TagInTexException(tag, a);

       if (!footnoteSequence.inFootnote())

         this.pos = posP;

     }

     private static class TagTranslation {

       String begin, end;

       TagTranslation(String begin, String end) {

         this.begin = begin;

         this.end = end;

       }

       public void begin(PrintWriter tex, HTML.Tag tag, MutableAttributeSet a) {

         tex.write(begin);

       }

       public void end(PrintWriter tex, HTML.Tag tag) {

         tex.write(end);

       }

     }

     private static final Hashtable<HTML.Tag, TagTranslation> tagTranslations = new Hashtable<HTML.Tag, TagTranslation>();

     static {

       tagTranslations.put(HTML.Tag.P, new TagTranslation("\n\n", ""));

       tagTranslations.put(HTML.Tag.H1, new TagTranslation("\\H{I}{", "}"));

       tagTranslations.put(HTML.Tag.H2, new TagTranslation("\\H{II}{", "}"));

       tagTranslations.put(HTML.Tag.H3, new TagTranslation("\\H{III}{", "}"));

       tagTranslations.put(HTML.Tag.H4, new TagTranslation("\\H{IIII}{", "}"));

       TagTranslation i = new TagTranslation("{\\it ", "}");

       tagTranslations.put(HTML.Tag.I, i);

       tagTranslations.put(HTML.Tag.EM, i);

       TagTranslation b = new TagTranslation("{\\bf ", "}");

       tagTranslations.put(HTML.Tag.B, b);

       tagTranslations.put(HTML.Tag.STRONG, b);

       tagTranslations.put(HTML.Tag.OL, new TagTranslation("\\orderedlist ",

           "\\endorderedlist "));

       tagTranslations.put(HTML.Tag.UL, new TagTranslation("\\unorderedlist ",

           "\\endunorderedlist "));

       tagTranslations.put(HTML.Tag.LI, new TagTranslation("\\li ", ""));

     }

     public void handleStartTag(HTML.Tag tag, MutableAttributeSet a, int posP) {

       if (passthrough)

         throw new TagInTexException(tag, a);

       if (tag.toString().equalsIgnoreCase("span")

           && a.isDefined(HTML.Attribute.CLASS)

           && a.getAttribute(HTML.Attribute.CLASS).toString().equalsIgnoreCase(

               "tex")) {

         passthrough = true;

       } else {

         int footnum = footnoteSequence.number(tag, a);

         if (footnum != -1) {

           tex.write("\\footnotenumber{" + footnum + "}");

           this.pos = posP;

         } else if (!footnoteSequence.inFootnote()) {

           TagTranslation translation = (TagTranslation)tagTranslations.get(tag);

           if (translation != null)

             translation.begin(tex, tag, a);

           if (tag.breaksFlow())

             wordBreak = SPACE;

           this.pos = posP;

         }

       }

     }

     public void handleEndTag(HTML.Tag tag, int posL) {

       if (passthrough) {

         if (tag.toString().equalsIgnoreCase("span"))

           passthrough = false;

         else

           throw new TagInTexException(tag, null);

       } else if (footnoteSequence.footnoteEnded(tag)) {

         wordBreak = NOSPACE;

         this.pos = posL;

       } else if (!footnoteSequence.inFootnote()) {

         TagTranslation translation = (TagTranslation)tagTranslations.get(tag);

         if (translation != null)

           translation.end(tex, tag);

         if (tag.breaksFlow())

           wordBreak = SPACE;

         this.pos = posL;

       }

     }

     public void handleError(String msg, int posP) {

       if (msg.startsWith("start") || msg.startsWith("end")

           || msg.startsWith("unmatched") || msg.startsWith("invalid")) {

       } else

         System.err.println("Bibliomania pagination: " + posP + ": " + msg);

     }

     public void flush() throws BadLocationException {

       // ready for the next time

       wordBreak = SPACE;

     }

   }

   private static final String defaultTexHeaderName = "header.tex";

   public static class DefaultTexHeaderNotFoundException extends

       MelatiRuntimeException {

     private static final long serialVersionUID = 1L;

     public DefaultTexHeaderNotFoundException(Exception problem) {

       super(problem);

     }

     public String getMessage() {

       return "Strangely, a problem arose opening the default TeX header for "

           + "pagination; it ought to be in the software source tree as `"

           + defaultTexHeaderName + "'!?\n" + subException.getMessage();

     }

   }

   public String defaultTexHeader() {

     try {

       URL it = getClass().getResource(defaultTexHeaderName);

       if (it == null)

         throw new FileNotFoundException("Resource `" + defaultTexHeaderName

             + "' not found by " + getClass());

       return new String(IoUtils.slurp(new InputStreamReader(it.openStream()),

           5000));

     } catch (Exception e) {

       throw new DefaultTexHeaderNotFoundException(e);

     }

   }

   private void htmlToTEX(Reader html, String texHeader, Writer tex)

       throws IOException {

     tex.write(texHeader == null ? defaultTexHeader() : texHeader);

     tex.write('\n');

     FtellPrintWriter texP = new FtellPrintWriter(tex);

     newDocumentParser().parse(html, new TexGeneratingCallback(texP),

         true);

     if (texP.checkError())

       throw new IOException("Error writing to TeX buffer");

     tex.write("\n\\bye\n");

   }

   /**

    * @return a new parser  

    */  

   public static FictionalNotifyingDocumentParser newDocumentParser() {   

     return new FictionalNotifyingDocumentParser(HTMLUtils.dtdForHTMLParser());   

   }

   public static class TexFailedException extends IOException {

     private static final long serialVersionUID = 1L;

     public String[] command;

     public File texFile;

     public TexFailedException(String[] command, File texFile) {

       this.command = command;

       this.texFile = texFile;

     }

     public String getLogFile() {

       String p = texFile.getPath();

       return (p.endsWith(".tex") ? p.substring(0, p.length() - 4) : p) + ".log";

     }

     public String getMessage() {

       return "Nonzero exit status from [["

           + StringUtils.concatenated(" ", command) + "]]; "

           + "look for errors in " + getLogFile();

     }

   }

   public void texToDVI(File texTemp) throws IOException, InterruptedException {

     String[] command = {

         "/bin/sh",

         "-c",

         "cd " + tempDir + " && " + "tex " + texTemp

             + " </dev/null >/dev/null 2>&1" };

     if (Runtime.getRuntime().exec(command).waitFor() != 0)

       throw new TexFailedException(command, texTemp);

   }

   public static class BreakInfoOfDVI {

     public static final int LINE = 0, PAGE = 1;

     private Process dvi2tty;

     private StreamTokenizer tokens;

     private int kind = -1, position = -1;

     public BreakInfoOfDVI(File dviTemp) throws IOException {

       String[] command = {

           "/bin/sh",

           "-c",

           dvi2ttyWithBreakinfo + " -b " + dviTemp.getPath() + "| "

               + "sort -n -k2" };

       dvi2tty = Runtime.getRuntime().exec(command);

       tokens = new StreamTokenizer(new BufferedReader(new InputStreamReader(

           dvi2tty.getInputStream())));

       if (tokens.nextToken() == StreamTokenizer.TT_EOF)

         throw new IOException("[[" + StringUtils.concatenated(" ", command)

             + "]] produced no output");

       tokens.pushBack();

     }

     public boolean next() throws IOException {

       if (tokens.nextToken() == StreamTokenizer.TT_EOF) {

         close();

         kind = -1;

         position = -1;

         return false;

       }

       if (tokens.ttype != StreamTokenizer.TT_WORD)

         throw new IOException("Unexpected nonword " + tokens + " from "

             + dvi2ttyWithBreakinfo);

       if (tokens.sval.equals("line"))

         kind = LINE;

       else if (tokens.sval.equals("page"))

         kind = PAGE;

       else

         throw new IOException("Unexpected " + tokens + " from "

             + dvi2ttyWithBreakinfo + ": " + "expected `line' or `page'");

       if (tokens.nextToken() != StreamTokenizer.TT_NUMBER)

         throw new IOException("Unexpected nonnumber " + tokens + " from "

             + dvi2ttyWithBreakinfo);

       position = (int)tokens.nval;

       return true;

     }

     public int kind() {

       return kind;

     }

     public int position() {

       return position;

     }

     public void close() {

       dvi2tty.destroy();

     }

     protected void finalize() throws Throwable {

       close();

     }

   }

   private class LineFixatingCallback extends FictionalNotifiableParserCallback {

     private FtellWriter linedHTML;

     private StringWriter footnote = null;

     private Vector pages;

     private BreakInfoOfDVI breaks;

     private boolean inWord = false, inLine = true, hadBreak = false;

     private int pos = 0;

     private Stack openTags = new Stack();

     private Vector pendingStartTags = new Vector();

     private int pageNum = 0;

     private FootnoteSequence footnoteSequence = new FootnoteSequence();

     private org.webmacro.Template footnoteTemplate;

     private WebMacro footnoteWebmacro;

     private String contentEncoding;

     private boolean currentIsFictional = false;

     private boolean literalTeX = false;

     private int footnoteSeqInDoc = 0;

     public LineFixatingCallback(FtellWriter linedHTML, BreakInfoOfDVI breaks,

         Vector pages, org.webmacro.Template footnoteTemplate,

         WebMacro footnoteWebmacro, String contentEncoding) throws IOException {

       this.linedHTML = linedHTML;

       this.breaks = breaks;

       this.pages = pages;

       this.footnoteTemplate = footnoteTemplate;

       this.footnoteWebmacro = footnoteWebmacro;

       this.contentEncoding = contentEncoding;

       breaks.next();

     }

     public void notifyCurrentIsFictional(boolean is) {

       currentIsFictional = is;

     }

     /**

      * Just added to remove warning.

      * @return whether current is fictional 

      */

     protected boolean getCurrentIsFictional() {

       return currentIsFictional;

     }

     public void checkBreaks(int posP) {

       try {

         while (breaks.position() != -1 && breaks.position() <= posP) {

           if (breaks.kind() == BreakInfoOfDVI.PAGE) {

             for (int e = openTags.size() - 1; e >= 0; --e) {

               linedHTML.write("</");

               linedHTML

                   .write(((HTMLUtils.TagInstance)openTags.elementAt(e)).tag

                       .toString());

               linedHTML.write(">");

             }

             linedHTML

                 .write("<a name=" + pageAnchorPrefix + ++pageNum + "></a>");

             pages.addElement(new Integer((int)linedHTML.ftell()));

             for (int e = 0; e < openTags.size(); ++e)

               emitTag((HTMLUtils.TagInstance)openTags.elementAt(e));

             emitPendingStartTags();

           }

           inLine = false;

           breaks.next();

         }

       } catch (IOException e) {

         throw new UnexpectedExceptionException(e);

       }

     }

     public void handleText(char[] text, int _pos) {

       if (!literalTeX)

         try {

           if (footnote != null) {

             for (int i = 0; i < text.length; ++i) {

               char c = text[i];

               if (c < 32 || 128 <= c)

                 footnote.write("&#" + (int)c + ';');

               else

                 footnote.write(c);

             }

           } else {

             checkBreaks(pos);

             emitPendingStartTags();

             for (int i = 0; i < text.length; ++i) {

               char c = text[i];

               if (Character.isWhitespace(c)) {

                 if (c == '\n')

                   inLine = false;

                 inWord = false;

               } else {

                 checkBreaks(pos + i);

                 if (!inLine) {

                   if (!hadBreak)

                     linedHTML.write('\n');

                   inLine = true;

                 } else if (!inWord)

                   linedHTML.write(' ');

                 if (c < 32 || 128 <= c)

                   linedHTML.write("&#" + (int)c + ';');

                 else

                   linedHTML.write(c);

                 inWord = true;

                 hadBreak = false;

               }

             }

           }

         } catch (IOException e) {

           throw new UnexpectedExceptionException(e);

         }

     }

     private void emitFootnote() {

       try {

         Context context = footnoteWebmacro.getContext();

         context.put("seqInDoc", new Integer(++footnoteSeqInDoc));

         context.put("number", new Integer(footnoteSequence.lastNumber));

         context.put("text", footnote.toString());

         ByteArrayOutputStream buf = new ByteArrayOutputStream();

         MelatiFastWriter fmw = new MelatiFastWriter(footnoteWebmacro

             .getBroker(), buf, contentEncoding);

         Melati m = new Melati(new MelatiConfig(), fmw);

         context.put("melati", m);

         footnoteTemplate.write(fmw.getFastWriter().getOutputStream(), context);

         fmw.flush();

         /*

          * Melati m = new Melati( new MelatiConfig(), new SimpleMelatiWriter(new

          * OutputStreamWriter(buf))); 

          * m.setBufferingOff(false);

          * context.put("melati", m); 

          * footnoteTemplate.write(new FastWriter(buf,

          * contentEncoding), context);

          */

         linedHTML.write(buf.toString().trim());

       } catch (Exception e) {

         throw new UnexpectedExceptionException(e);

       } finally {

         footnote = null;

       }

     }

     private void emitTag(HTML.Tag tag, AttributeSet attributes)

         throws IOException {

       if (!inWord) {

         linedHTML.write(' ');

         inWord = true;

       }

       if (tag.breaksFlow()) {

         inLine = true;

         inWord = true;

         hadBreak = true;

       }

       if (tag == HTML.Tag.P || tag == HTML.Tag.LI)

         linedHTML.write("     " + preStart); // Spaces are hack to replace

                                               // <pre> without upsetting

                                               // pagination

       // following is

       // HTMLUtils.write(linedHTML, tag, attributes);

       // except that we don't write P CLASS=footnote

       // as a workaround for a bug in Sun's HTML parser :(

       linedHTML.write('<');

       linedHTML.write(tag.toString());

       for (Enumeration<?> a = attributes.getAttributeNames(); a.hasMoreElements();) {

         Object n = a.nextElement();

         if (attributes.isDefined(n)) {

           linedHTML.write(' ');

           String name = n.toString();

           String value = attributes.getAttribute(n).toString();

           if (!(tag == HTML.Tag.P && name.equalsIgnoreCase("class") && value

               .equalsIgnoreCase("footnote"))) {

             linedHTML.write(name);

             linedHTML.write("=\"");

             linedHTML.write(HTMLUtils.entitied(value));

             linedHTML.write('"');

           }

         }

       }

       linedHTML.write('>');

     }

     private void emitTag(HTMLUtils.TagInstance tag) throws IOException {

       emitTag(tag.tag, tag.attributes);

     }

     public static final String preStart = "";

     public static final String preEnd = "";

     private void emitPendingStartTags() throws IOException {

       for (int i = 0; i < pendingStartTags.size(); ++i) {

         HTMLUtils.TagInstance tag = (HTMLUtils.TagInstance)pendingStartTags

             .elementAt(i);

         emitTag(tag);

         openTags.push(tag);

       }

       pendingStartTags.clear();

     }

     public void handleSimpleTag(HTML.Tag tag, MutableAttributeSet attributes,

         int posP) {

       if (literalTeX)

         throw new TagInTexException(tag, null);

       if (!tag.toString().equals("__EndOfLineTag__"))

         try {

           if (footnote != null)

             HTMLUtils.write(footnote, tag, attributes);

           else {

             emitPendingStartTags();

             // if (tag != HTML.Tag.IMG)

             emitTag(tag, attributes);

             this.pos = posP;

           }

         } catch (IOException e) {

           throw new UnexpectedExceptionException(e);

         }

     }

     public void handleStartTag(HTML.Tag tag, MutableAttributeSet attributes,

         int posP) {

       if (literalTeX)

         throw new TagInTexException(tag, attributes);

       if (tag.toString().equalsIgnoreCase("span")

           && attributes.isDefined(HTML.Attribute.CLASS)

           && attributes.getAttribute(HTML.Attribute.CLASS).toString()

               .equalsIgnoreCase("tex")) {

         literalTeX = true;

       } else {

         int footnoteNumber = footnoteSequence.number(tag, attributes);

         if (footnoteNumber != -1) {

           footnote = new StringWriter();

           this.pos = posP;

         } else if (footnote != null) {

           try {

             HTMLUtils.write(footnote, tag, attributes);

           } catch (IOException e) {

             throw new UnexpectedExceptionException(e);

           }

         } else {

           if (tag != HTML.Tag.HTML && tag != HTML.Tag.HEAD

               && tag != HTML.Tag.BODY)

             pendingStartTags.addElement(new HTMLUtils.TagInstance(tag,

                 attributes.copyAttributes()));

           this.pos = posP;

         }

       }

     }

     public void handleEndTag(HTML.Tag tag, int posP) {

       if (literalTeX) {

         if (tag.toString().equalsIgnoreCase("span"))

           literalTeX = false;

         else

           throw new TagInTexException(tag, null);

       } else

         try {

           if (footnoteSequence.footnoteEnded(tag)) {

             emitFootnote();

             this.pos = posP;

           } else if (footnote != null)

             footnote.write("</" + tag + ">");

           else {

             emitPendingStartTags();

             if (tag.breaksFlow()) {

               inLine = false;

               inWord = true;

               hadBreak = true;

             }

             if (tag != HTML.Tag.HTML && tag != HTML.Tag.HEAD

                 && tag != HTML.Tag.BODY) {

               linedHTML.write("</" + tag + ">");

               if (tag == HTML.Tag.P || tag == HTML.Tag.LI)

                 linedHTML.write(preEnd + "     \n"); // Spaces are hack to

                                                       // replace <pre> without

                                                       // upsetting pagination

               while (!openTags.empty()

                   && ((HTMLUtils.TagInstance)openTags.pop()).tag != tag)

                 ;

             }

             this.pos = posP;

           }

         } catch (IOException e) {

           throw new UnexpectedExceptionException(e);

         }

     }

     public void handleError(String msg, int posP) {

       if (msg.startsWith("start") || msg.startsWith("end")

           || msg.startsWith("unmatched") || msg.startsWith("invalid")) {

       } else

         System.err.println("Bibliomania pagination: " + posP + ": " + msg);

     }

   }

   private String tempPrefix() {

     return getClass().getName();

   }

   public boolean isTempFile(File file) {

     return file.getPath().startsWith(new File(tempDir, tempPrefix()).getPath());

   }

   public void paginate(Text text, String texHeader, Writer linedHTML,

       org.webmacro.Template footnoteTemplate, WebMacro footnoteWebmacro,

       String contentEncoding) throws IOException, DatabaseException {

     Reader html = new InputStreamReader(text.body());

     File texTemp = File.createTempFile(tempPrefix(), ".tex", tempDir);

     String base = texTemp.getPath()

         .substring(0, texTemp.getPath().length() - 4);

     File dviTemp = new File(base + ".dvi");

     Writer toTEXTemp = new BufferedWriter(new FileWriter(texTemp));

     BreakInfoOfDVI breaks = null;

     try {

       htmlToTEX(html, texHeader, toTEXTemp);

       html.close();

       toTEXTemp.close();

       try {

         texToDVI(texTemp);

       } catch (InterruptedException e) {

         throw new IOException("Interrupted while waiting for tex");

       }

       html = new InputStreamReader(text.body());

       breaks = new BreakInfoOfDVI(dviTemp);

       Vector pages = new Vector();

       FtellWriter linedF = new FtellWriter(linedHTML);

       try {

         newDocumentParser().parse(

             html,

             new LineFixatingCallback(linedF, breaks, pages, footnoteTemplate,

                 footnoteWebmacro, contentEncoding), true);

       } catch (UnexpectedExceptionException e) {

         if (e.subException instanceof IOException)

           throw (IOException)e.subException;

         else

           throw e;

       }

       linedF.flush();

       pages.addElement(new Integer((int)linedF.ftell()));

       DatabaseEntry pageBreaks = DbUtils.userMemDatabaseEntry(pages.size() * 4);

       for (int i = 0; i < pages.size(); ++i)

         FourPacker.set_(pageBreaks.getData(), i * 4, ((Integer)pages

             .elementAt(i)).intValue());

       DatabaseEntry textID = DbUtils.userMemDatabaseEntry(5);

       FivePacker.set_(textID.getData(), 0, text.ftiTextID());

       pageBreaksOfTextID.put(null, textID, pageBreaks);

       // we deliberately don't delete these if there was a problem

       if (!new File(tempDir, "bibliomania.Pagination.leaveTempFiles").exists()) {

         texTemp.delete();

         dviTemp.delete();

         new File(base + ".log").delete();

       }

     } finally {

       try {

         if (breaks != null) 

           breaks.close();

       } catch (Exception e) {

       }

       try {

         html.close();

       } catch (Exception e) {

       }

       try {

         toTEXTemp.close();

       } catch (Exception e) {

       }

     }

   }

   public void flush() throws DatabaseException {

     pageBreaksOfTextID.sync();

   }

   public void close() {

     try {

       pageBreaksOfTextID.close();

     } catch (Exception e) {

       throw new RuntimeException();

     }

   }

   protected void finalize() throws Throwable {

     close();

   }

   public static void main(final String[] args) throws Exception {

     WebMacro wm = new WM();

     Pagination pagination = new Pagination(new File("/tmp"));

     if (args[0].equals("-page"))

       System.out.println(pagination.new PageFinder().pageOfNumber(Integer

           .parseInt(args[1]), Integer.parseInt(args[2])));

     else if (args[0].equals("-offset"))

       System.out.println(pagination.new PageFinder().pageOfOffset(Integer

           .parseInt(args[1]), Integer.parseInt(args[2])));

     else if (args[0].equals("-paginate")) {

       // FIXME

       File templateFile = new File(

           "/dist/Bibliomania/src/org/paneris/bibliomania/html/pagination/footnote.wm");

       org.webmacro.Template fnt = new FileTemplate(wm.getBroker(),

           templateFile, "UTF8");

       fnt.parse();

       pagination.paginate(new Text() {

         public InputStream body() throws IOException {

           return new FileInputStream(args[1]);

         }

         public InputStream bodyForFragment() throws IOException {

           return body();

         }

         public long ftiTextID() {

           return Long.parseLong(args[2]);

         }

       }, null, new BufferedWriter(new FileWriter("/tmp/lined.html")), fnt, wm,

           "UTF8");

     }

     pagination.close();

   }

 }