package org.paneris.jammyjoes.upload;
   
   import java.text.SimpleDateFormat;
   import java.util.Calendar;
   import java.util.Date;
   
   import org.melati.LogicalDatabase;
   //import org.melati.MelatiConfig;
   import org.melati.poem.AccessToken;
  import org.melati.poem.PoemTask;
  import org.melati.util.DatabaseInitException;
  import org.paneris.jammyjoes.model.JammyjoesDatabase;
  
  import com.cqs.ftp.FTP;
  
  /**
   * The Warden is a Thread which waits for 24 hours before generating and
   * uploading new data for ecentives
   *
   * This thread becomes an org.melati.PoemThread by doing all its work
   * inside a database.inSession() call. This ensures that there is a
   * org.melati.PoemTransaction (think of sql transactions) available which
   * can be commited or rolled back at any point by calling
   * org.melati.PoremThread.commit() or org.melati.PoremThread.rollback()
   *
   * @see org.melati.poem.PoemThread#commit()
   * @see org.melati.poem.PoemThread#rollback()
   * @see org.melati.poem.Database#inSession()
   */
  
  public class Warden implements Runnable {
  
    private JammyjoesDatabase database;
    private WardenLauncher launcher = null;
    //private MelatiConfig melatiConfig;
  
    SimpleDateFormat dateFormat = new SimpleDateFormat("dd MMM yyyy");
    private String uploadDir;
  
    private static String databaseName = "jammyjoes";
    private static long pausetime = 1000 * 60 * 60; // 1 hour
    private static int runHour = 19; // run at 7pm or thereabouts
    private static String ftphost = "hedwig.google.com";
    private static String ftpuser = "timj";
    private static String ftppass = "camel55";
    private String filename = "jammyjoes.txt";
  
    /**
     * Constructor
     * <p>
     * Allows the WardenLauncher to pass on parameters
     * objects.
     */
  
    public Warden(WardenLauncher launcher) {
      this.launcher = launcher;
      /*
      try {
        melatiConfig = new MelatiConfig();
      } catch (Exception e) {
        e.printStackTrace(System.err);
      }
      */
    }
  
    /**
     * Thread run method. Creates a transaction in our database, in which
     * the warden does the rounds, and has a rest.
     */
    public void run() {
      if (database == null) {
        try {
          database = (JammyjoesDatabase) LogicalDatabase.getDatabase(databaseName);
        } catch (DatabaseInitException e) {
          e.printStackTrace();
        }
      }
      final Thread myThread = Thread.currentThread();
      // die when WardenLauncher is 'destroy'ed
      // (and sets its warden to null)
      while (launcher.warden == myThread) {
        database.inSession(AccessToken.root, new PoemTask() {
          public void run() {
            uploadDir = database.getSettingTable().get("UploadDir") + "/../";
            doUploading();
          }
        });
        try {
          // Take a coffee break
          Thread.sleep(pausetime);
        } catch (InterruptedException e) {
        }
      }
    }
  
    /**
     * Check the directory for new data. It tries to enter
     * any it finds into the database. It reports any exceptions and error
     * conditions to an error file.
    * <p>
    */
 
   void doUploading() {
     try {
       Calendar rightNow = Calendar.getInstance();
       if (rightNow.get(Calendar.HOUR_OF_DAY) == runHour) {
         // time to run
         System.err.println(new Date() + " Generating files for JammyJoes");
         generateFiles();
         System.err.println(new Date() + " Generated files for JammyJoes");
         ftpUpload();
         System.err.println(new Date() + " Uploaded Product file to Froogle");
       }
     } catch (Exception e) {
       e.printStackTrace(System.err);
     }
   }
 
   public void generateFiles() throws Exception {
     Froogle froogle = new Froogle(database);
     froogle.writeFile(uploadDir, filename);
   }
 
   public void ftpUpload() {
     FTP ftp = new FTP(ftphost, 21);
     ftp.setLogFile(uploadDir + "/ftp.log");
 
     int i = 0;
     boolean connected = false;
     while (!connected && i < 20) {
       try {
         Thread.sleep(1000*30);
       } catch (InterruptedException e) {
         e.printStackTrace();
       }
       i++;
       connected = connect(ftp);
     }
     if (connected) {
 
       ftp.setTransfer(FTP.TRANSFER_PASV);
       ftp.setMode(FTP.MODE_AUTO);
 
       ftp.upload(uploadDir + "/" + filename, filename);
       System.err.print(ftp.lastReply());
       if (ftp.lastCode() != FTP.CODE_TRANSFER_OK) {
         System.err.println("error while uploading.");
         ftp.disconnect();
         return;
       }
 
       ftp.disconnect();
       System.err.print(ftp.lastReply());
       if (ftp.lastCode() != FTP.CODE_DISCONNECT_OK) {
         System.err.println("disconnection failed.");
         return;
       }
 
       ftp.closeLogFile();
       System.err.println("OK.");
     }
   }
 
   private boolean connect(FTP ftp) {
     ftp.connect();
     System.err.print(ftp.lastReply());
     if (ftp.lastCode() != FTP.CODE_CONNECT_OK) {
       System.err.println("Connection failed.");
       return false;
     }
 
     ftp.login(ftpuser, ftppass);
     System.err.print(ftp.lastReply());
     if (ftp.lastCode() != FTP.CODE_LOGGEDIN) {
       System.err.println("incorrect login.");
       ftp.disconnect();
       return false;
     }
     return true;
 
   }
 }