package org.paneris.bibliomania;
   
   
   import java.io.File;
   import java.io.FileInputStream;
   import java.sql.Timestamp;
   
   import javax.servlet.ServletConfig;
   import javax.servlet.ServletException;
  import javax.servlet.ServletOutputStream;
  
  import org.melati.Melati;
  import org.melati.poem.AccessPoemException;
  import org.melati.poem.AccessToken;
  import org.melati.poem.Capability;
  import org.melati.poem.PoemTask;
  import org.melati.poem.PoemThread;
  import org.melati.PoemContext;
  import org.melati.servlet.TrappedException;
  import org.melati.template.TemplateContext;
  import org.melati.template.TemplateEngine;
  import org.melati.template.TemplateEngineException;
  import org.melati.util.MelatiRuntimeException;
  import org.melati.poem.util.StringUtils;
  
  
  public class DownloadFile extends org.melati.servlet.ConfigServlet {
  
    /**
     * 
     */
    private static final long serialVersionUID = 1L;
    // the template engine
    protected TemplateEngine templateEngine;
  
    /**
     * Inititialise WebMacro
     * @param config
     */
    public void init(ServletConfig config) throws ServletException {
      super.init(config);
      try {
        templateEngine = melatiConfig.getTemplateEngine();
        if (templateEngine != null)
          templateEngine.init(melatiConfig);
      } catch (TemplateEngineException e) {
        // log it to system.err as ServletExceptions go to the
        // servlet runner log (eg jserv.log), and don't have a stack trace!
        e.printStackTrace(System.err);
        throw new ServletException(e.toString());
      }
    }
  
    protected void doConfiguredRequest(final Melati melatiIn)
      throws Exception {
  
      melatiIn.setTemplateEngine(templateEngine);
      TemplateContext templateContext =
                        templateEngine.getTemplateContext();
      melatiIn.setTemplateContext(templateContext);
  
      final DownloadWrapper downloadWrapper = new DownloadWrapper();
      try {
        melatiIn.getDatabase().inSession (
          AccessToken.root, new PoemTask() {
            public void run () {
              try {
                Melati melati =
                  melatiIn.getConfig().getAccessHandler().establishUser(melatiIn);
                try {
                  downloadWrapper.download = establishUser(melati);
                } catch (Exception e) {
                  handleException (melatiIn, e);
                }
              } catch (DownloadException e) {
                throw (e);
              } catch (Exception e) {
                  error(melatiIn, e);
                  throw new TrappedException(e);
              }
            }
          }
        );
        
        doDownload(melatiIn, downloadWrapper.download);
        
        melatiIn.getDatabase().inSession (
          AccessToken.root, new PoemTask() {
            public void run () {
              try {
                Melati melati =
                  melatiIn.getConfig().getAccessHandler().establishUser(melatiIn);
                try {
                  recordDownload(melati, downloadWrapper.download);
                } catch (Exception e) {
                  handleException (melatiIn, e);
                }
              } catch (DownloadException e) {
                throw (e);
             } catch (Exception e) {
                 // we have to log this here, otherwise we loose the stacktrace
                 error(melatiIn, e);
                 throw new TrappedException(e);
             }
           }
         }
       );
     } catch (DownloadException e) {
       error(melatiIn, e, downloadWrapper.download);
     }
   }
 
   public DownloadItem establishUser(Melati melati) 
          throws AccessPoemException, DownloadException {
     DownloadItem download = new DownloadItem();
     BibliomaniaDatabase db = (BibliomaniaDatabase) melati.getDatabase();
     String pathInfo = melati.getRequest().getPathInfo();
     String filename = pathInfo.substring(pathInfo.lastIndexOf("/")+1);
     download.filename = filename;
     Capability registeredUser = db.getRegisteredUserCapability();
     AccessToken token = PoemThread.accessToken();
     if (!token.givesCapability(registeredUser)) {
       throw new AccessPoemException(token, registeredUser);
     } else {
       Download document = (Download)db.getDownloadTable().getFilenameColumn().firstWhereEq(filename);
       download.document = document;
       if (document == null) {
         throw new DownloadException("Sorry, the requested Document (" + filename + ") does not exist.  Please contact <a href='mailto:help@bibliomania.com'>Bibliomania.com</a> so that this problem can be corrected.");
       } else {        
         // check we have purchased this doc
         if (!((User)melati.getUser()).hasPurchased(document.getTroid())) {
           throw new DownloadException("You have not purchased the requested Document, click <a href=org.paneris.ftc365.controller.Account>here</a> to buy more Modules.");
         } else {
           File file = new File(db.getSettingTable().get("filepath") + filename);
 //          File file = new File(filename);
           download.file = file;
           if (!file.exists()) {
             throw new DownloadException("Sorry, the requested file (" + file.getPath() + ") has not been found, please contact mailto:help@bibliomania.com'>Bibliomania.com</a>,  so that this problem can be corrected.");
           }
         }
       }
     }
     return download;
   }
   
   public void doDownload(Melati melati, DownloadItem download) throws Exception {
       FileInputStream filein = new FileInputStream(download.file);
       melati.getResponse().setContentLength(new Long(download.file.length()).intValue());
       if (download.filename.endsWith("pdf")) {
         melati.getResponse().setContentType("application/pdf");
       } else {
         melati.getResponse().setContentType("application");
       }            
       ServletOutputStream os = melati.getResponse().getOutputStream();
       int i = 0;
       byte[] bbuf = new byte[10000];
       while (i != -1) {
         i = filein.read(bbuf, 0, 10000);
         if (i > -1) os.write(bbuf, 0, i);
       }
   }
   
   public void recordDownload(Melati melati, DownloadItem downloaditem) {
                                
     BibliomaniaDatabase db = (BibliomaniaDatabase)melati.getDatabase();
     // make record of download
     DownloadEvent downloadEvent = (DownloadEvent)db.getDownloadEventTable()
                                   .newPersistent();
     downloadEvent.setUser((User)melati.getUser());
     downloadEvent.setDocument(downloaditem.document);
     downloadEvent.setDate(new Timestamp((new java.util.Date()).getTime()));
     downloadEvent.getDownloadEventTable().create(downloadEvent);
   }
   
   public void error(Melati melati, Exception e, DownloadItem download) {
     try {
       TemplateContext templateContext = melati.getTemplateContext();
       templateContext.put("melati",melati);
       templateContext.put("exception", e);
       templateContext.put("download", download);
       String templateName = "DownloadFail.wm";
       templateEngine.expandTemplate(melati.getWriter(), 
                                     templateName,
                                     templateContext);
     } catch (Exception f) {
       f.printStackTrace(System.err);
     }
   }
   
   protected PoemContext melatiContext(Melati melati) {
      PoemContext it = new PoemContext();
      String[] parts = melati.getPathInfoParts();
      if (parts.length > 0)
       it.setMethod(StringUtils.nulled(parts[parts.length - 1]));
     it.setLogicalDatabase("bibliomania");
     return it;
   }
    
   public String getSysAdminName() {
     return "TimP";
   }
   public String getSysAdminEmail() {
     return "timp@paneris.org";
   }
 
   // default method to handle an exception withut a template engine
   protected void handleException(Melati melati, Exception exception)
                  throws Exception {
 
     if (exception instanceof AccessPoemException) {
       melati.getConfig().getAccessHandler()
         .handleAccessException(melati,(AccessPoemException)exception);
     }
     else
       throw exception;
   }
 
   public class DownloadException extends MelatiRuntimeException {
 
     /**
      * 
      */
     private static final long serialVersionUID = 1L;
 
     public DownloadException(String message) {
       super(message,null);
     }
   }
   
   private class DownloadWrapper {
     DownloadItem download;
   }
   
   private class DownloadItem {
     String filename;
     File file;
     Download document;
   }
 
 }