package org.paneris.bibliomania.population;

 import java.io.BufferedReader;

 import java.io.File;

 import java.io.FileReader;

 import java.util.Enumeration;

 import java.util.Vector;

 import org.melati.poem.AccessToken;

 import org.melati.poem.PoemTask;

 import org.melati.util.MelatiRuntimeException;

 import org.paneris.bibliomania.BibliomaniaDatabase;

 import org.paneris.bibliomania.Book;

 import org.paneris.bibliomania.Chapter;

 import org.paneris.bibliomania.util.OROUtils;

 import org.apache.oro.text.regex.MatchResult;

 import org.apache.oro.text.regex.Pattern;

 import org.apache.oro.text.regex.Perl5Compiler;

 import org.apache.oro.text.regex.Perl5Matcher;

 public class KeyDotTxtFilter {

   public static class PopulationException extends MelatiRuntimeException {

     private static final long serialVersionUID = 1L;

     public File keyDotTxtFile;

     public PopulationException(File keyDotTxtFile, Exception problem) {

       super(problem);

       this.keyDotTxtFile = keyDotTxtFile;

     }

     public String getMessage() {

       return "A problem was encountered importing " + keyDotTxtFile + ":\n" +

            subException.getMessage();

     }

   }

   public static class SyntaxException extends MelatiRuntimeException {

     private static final long serialVersionUID = 1L;

     public int linenum;

     public String line;

     public SyntaxException(int linenum, String line) {

       this.linenum = linenum;

       this.line = line;

     }

     public String getMessage() {

       return "Line " + linenum + " was not in the " +

              "<filename>.html <chapter title> format:\n" +

              "[[" + line + "]]";

     }

   }

   private static final Pattern

       data = OROUtils.perl5Pattern(

                 "^\\s*(.*?\\.html)\\s+(.*?)((  |\t)\\s*(.*?))?\\s*$",

                 Perl5Compiler.CASE_INSENSITIVE_MASK),

       white = OROUtils.perl5Pattern("^(#.*|\\s*)$", Perl5Compiler.DEFAULT_MASK);

   private static void populateFromDataRE(Book book, Vector oldChapters,

                                          int seq, MatchResult match) {

     Chapter chapter;

     if (oldChapters.size() <= seq)

       chapter = null;

     else {

       chapter = (Chapter)oldChapters.elementAt(seq);

       oldChapters.setElementAt(null, seq);

     }

     if (chapter == null)

       chapter = (Chapter)book.getBibliomaniaDatabase().getChapterTable().

                                                            newPersistent();

     chapter.setBook(book);

     chapter.setSequence(seq);

     chapter.setTitle(match.group(2));

     chapter.setLongtitle(match.group(5)); // may be null

     chapter.setFilepath(book.getPath(), match.group(1));

     if (!chapter.statusExistent())

       chapter.makePersistent();

   }

   public static void populate(Book book) {

     File keyDotTxtFile = new File(book.getSourceDir(), "key.txt");

     try {

       BufferedReader keyDotTxt =

         new BufferedReader(new FileReader(keyDotTxtFile));

       Perl5Matcher matcher = new Perl5Matcher();

       Vector oldChapters = new Vector();

       for (Enumeration existingChapters = book.getChapters();

            existingChapters.hasMoreElements();) {

         Chapter chapter = (Chapter)existingChapters.nextElement();

         int seq = chapter.getSequence().intValue();

         if (oldChapters.size() <= seq)

           oldChapters.setSize(seq + 1);

         oldChapters.setElementAt(chapter, seq);

       }

       int chapterCount = 0;

       for (int lineno = 0;; ++lineno) {

         String line = keyDotTxt.readLine();

         if (line == null)

           break;

         if (matcher.matches(line, white)) {}

         else if (matcher.matches(line, data))

             populateFromDataRE(book, oldChapters,

                                chapterCount++, matcher.getMatch());

         else 

           throw new SyntaxException(lineno, line);

       }

       for (int c = 0; c < oldChapters.size(); ++c) {

         Chapter chapter = (Chapter)oldChapters.elementAt(c);

         if (chapter != null)

           chapter.delete_unsafe_butCleanFTI();

       }

     }

     catch (Exception e) {

       throw new PopulationException(keyDotTxtFile, e);

     }

   }

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

     final BibliomaniaDatabase bib = new BibliomaniaDatabase();

     bib.connect("bibliomania", "org.melati.poem.dbms.Postgresql",

                 "jdbc:postgresql:bibliomania", "postgres", "*",8);

     bib.inSession(

         AccessToken.root,

         new PoemTask() {

           public void run() {

           populate((Book)bib.getBookTable().getTitleColumn().firstWhereEq(args[0]));

         }

         });

   }

 }