package org.paneris.bibliomania;
   
   import java.io.OutputStreamWriter;
   import java.io.Writer;
   import java.util.Enumeration;
   
   import org.melati.LogicalDatabase;
   import org.melati.Melati;
   import org.melati.poem.AccessToken;
  import org.melati.poem.PoemTask;
  import org.melati.poem.PoemThread;
  import org.melati.poem.Table;
  import org.melati.poem.UnexpectedExceptionPoemException;
  import org.melati.poem.util.ArrayUtils;
  import org.melati.poem.util.ConsEnumeration;
  import org.melati.poem.util.FlattenedEnumeration;
  import org.melati.poem.util.MappedEnumeration;
  import org.melati.util.MelatiRuntimeException;
  import org.webmacro.servlet.WebContext;
  
  public class BatchImporter extends BibliomaniaServlet {
  
    /**
     * 
     */
    private static final long serialVersionUID = 1L;
    public static final int KEYDOTTXT = 8, PAGINATE = 4, INDEX = 2, ENCACHE = 1;
  
    public static class Result {
      public Exception trouble;
      public Unit unit;
    }
  /*
    private static final class Stopwatch {
      public long datum;
  
      public Stopwatch() {
        datum = System.currentTimeMillis();
      }
  
      public long click() {
        long now = System.currentTimeMillis();
        try {
          return now - datum;
        } finally {
          datum = now;
        }
      }
    }
  */
    public static Enumeration importResults(
      final Unit unit,
      final boolean recurse,
      final int actions,
      final boolean doChapters,
      final boolean flushDuring) {
  
      Result result = new Result();
      result.unit = unit;
  
      try {
        if ((actions & KEYDOTTXT) != 0)
          unit.readKeyDotTxt();
  
        if ((actions & PAGINATE) != 0) {
          unit.paginate();
          unit.getBibliomaniaDatabase().pagination().flush();
        }
  
        if ((actions & ENCACHE) != 0)
          unit.encache();
  
        if ((actions & INDEX) != 0) {
          try {
            unit.index();
          } finally {
            // FIXME there are two of these but we shouldn't have to know that
            // here
  
            if (flushDuring) {
              unit.getBibliomaniaDatabase().fti().flush();
              unit.getBibliomaniaDatabase().infoFTI().flush();
            }
          }
        }
  
        PoemThread.commit();
      } catch (Exception e) {
        e.printStackTrace();
        result.trouble = e;
        PoemThread.rollback();
      }
  
      return new ConsEnumeration(
        result,
        recurse
          && !(unit instanceof Book && !doChapters)
            ? new FlattenedEnumeration(new MappedEnumeration(
              unit
             .getMembersSlowly()) {
       public Object mapped(Object member) {
         return importResults(
           (Unit)member,
           recurse,
           actions,
           doChapters,
           flushDuring);
       }
     }) : null);
   }
 
   protected String bibliomaniaHandle(Melati melati, WebContext context)
     throws Exception {
     melati.setBufferingOff();
     melati.setFlushingOn();
     melati.setVariableExceptionHandler(
       melati.getPassbackVariableExceptionHandler());
 
     context.put(
       "results",
       importResults(
         (Unit)melati.getObject(),
         "true".equals(context.getForm("recurse")),
         Integer.parseInt(context.getForm("actions")),
         !"true".equals(context.getForm("skipChaps")),
         true));
 
     return bibliomaniaTemplate("admin/BatchImport");
   }
 
   private static void doImport(
     BibliomaniaDatabase db,
     String[] args,
     final Writer commentary)
     throws Exception {
     final boolean recurse, skipChaps;
 
     if (args[1].equals("recurse")) {
       recurse = true;
       skipChaps = false;
     } else if (args[1].equals("skipChaps")) {
       recurse = true;
       skipChaps = true;
     } else if (args[1].equals("norecurse")) {
       recurse = false;
       skipChaps = false;
     } else
       throw new IllegalArgumentException("second arg must be norecurse, recurse or skipChaps");
 
     final boolean flushDuring;
 
     if (args.length > 4) {
       if (args[4].equals("flushDuring"))
         flushDuring = true;
       else if (args[4].equals("flushAfter"))
         flushDuring = false;
       else
         throw new IllegalArgumentException("fifth arg must be flushDuring or flushAfter");
     } else
       flushDuring = true;
 
     final int actions = Integer.parseInt(args[0]);
 
     Table table = db.getTable(args[2]);
 
     Enumeration results;
 
     if (args[3].equals("_"))
       results =
         new FlattenedEnumeration(new MappedEnumeration(table.selection()) {
       public Object mapped(Object member) {
         return importResults(
           (Unit)member,
           recurse,
           actions,
           !skipChaps,
           flushDuring);
       }
     });
     else
       results =
         importResults(
           (Unit)table.getObject(Integer.parseInt(args[3])),
           recurse,
           actions,
           !skipChaps,
           flushDuring);
 
     while (results.hasMoreElements()) {
       Result result = (Result)results.nextElement();
       commentary.write(
         "=== ... finished "
           + result.unit.getTable().getName()
           + "/"
           + result.unit.getTroid()
           + " `"
           + result.unit.getPath());
       if (result.unit instanceof Chapter)
         commentary.write(((Chapter)result.unit).getFilename());
       commentary.write("'\n\n");
 
       if (result.trouble != null)
         commentary.write("!!! " + result.trouble + "\n");
       commentary.flush();
     }
 
     if (!flushDuring) {
       long now = System.currentTimeMillis();
 
       // FIXME there are two of these but we shouldn't have to know that here
       db.fti().flush();
       db.infoFTI().flush();
 
       commentary.write(
         "... final flush millis " + (System.currentTimeMillis() - now) + "\n");
       commentary.flush();
 
     }
   }
 
   public static void main(final String[] args) {
     final BibliomaniaDatabase db = new BibliomaniaDatabase(false);
     db.connect("bibliomania",
       "org.melati.poem.dbms.Postgresql",
       "jdbc:postgresql:bibliomania",
       "postgres",
       "*",
       8);
 
     db.inSession(AccessToken.root, // FIXME
     new PoemTask() {
       public void run() {
         try {
           doImport(db, args, new OutputStreamWriter(System.err));
         } catch (Exception e) {
           throw new UnexpectedExceptionPoemException(e);
         }
       }
     });
   }
 
   public static class Interpreter implements CommandServer.Interpreter {
 
     public static class AuthenticationException
       extends MelatiRuntimeException {
       /**
        * 
        */
       private static final long serialVersionUID = 1L;
 
       public String getMessage() {
         return "Authentication failed";
       }
     }
 
     public void interpret(
       final String[] args,
       final Writer output,
       final Writer errors)
       throws Exception {
 
       final BibliomaniaDatabase db =
         (BibliomaniaDatabase)LogicalDatabase.getDatabase(args[0]);
 
       db.inSession(AccessToken.root, new PoemTask() {
         public void run() {
           try {
             User user =
               (User)PoemThread
                 .database()
                 .getUserTable()
                 .getLoginColumn()
                 .firstWhereEq(
                 args[1]);
             if (user == null || !user.getPassword_unsafe().equals(args[2]))
               throw new AuthenticationException();
 
             PoemThread.setAccessToken(user);
 
             doImport(
               db,
               (String[])ArrayUtils.section(args, 3, args.length),
               errors);
           } catch (Exception e) {
             try {
               errors.write(e + "\n");
             } catch (Exception ee) {
             }
           }
         }
       });
     }
   }
 }