package org.opensync.tools;
   
   import java.io.IOException;
   import java.io.InterruptedIOException;
   import java.io.File;
   import java.net.MalformedURLException;
   
   import org.opensync.tools.Constants;
   import org.opensync.tools.Utils;
  
  /***
    * Connect to url, send data, and recieve data insided a timed thread
    * so we don't block indefinitely if url has a socket issue.
    * @author Keith Stumpf
    */
  public class DeleteFile
  {
  
    /***
    *
    */
    public DeleteFile()
    {
    }
  
    /***
     * Attempts to delete a file
     *
     * @param       sFileName               Filename to delete
     * @param       lSleepBeforeDelete      Amount of time to sleep before deleting file.
     * @param       lTimeoutInterval        Amount of time in milliseconds to timeout request.
     * @param       lSleepTime              Amount of time to sleep in between checking timeout interval.
     * @exception   MalformedURLException   If there is a URL error
     * @exception   InterruptedIOException  If there is an interupt sent to the thread.
     * @exception   IOException             If there is an I/O error
     */
    public void go(String sFileName,
                   long lSleepBeforeDelete,
                   long lTimeoutInterval,
                   long lSleepTime)
        throws Exception, InterruptedIOException, IOException, MalformedURLException
    {
      //long lTimeoutInterval = new Long(sTimeoutInterval).longValue();
      //long lSleepTime       = new Long(sSleepTime).longValue();
      //long lSleepBeforeDelete       = new Long(nSleepBeforeDelete).longValue();
      //String sResult="";
  
      // Create a new socket thread, and start it running
      DeleteFileThread deleteFileThread = new DeleteFileThread(sFileName,lSleepBeforeDelete);
      deleteFileThread.start();
  
      // Don't wait if timeout interval is zero.
      if (lTimeoutInterval == 0){
        return;
      }
      long lTimer = 0;
      for (;;)
      {
        // Check to see if a thread is finished
        if (deleteFileThread.isFinished())
        {
          // Yes ...  assign result data to thread and break out of loop
          //sResult = DeleteFileThread.getResult();
          break;
        }
        else
        {
          // Check to see if an error occurred
          if (deleteFileThread.isError())
          {
            // No connection could be established
            throw (deleteFileThread.getException());
          }
          try
          {
            // Sleep for a short period of time
            Thread.sleep (lSleepTime);
          }
          catch (InterruptedException ie) {}
  
          // Increment timer
          lTimer += lSleepTime;
  
          // Check to see if time limit exceeded
          if (lTimer > lTimeoutInterval)
          {
            String sErrorText = "Timed out trying to delete file="+sFileName+ " within " + lTimeoutInterval + " milliseconds";
            throw new Exception(sErrorText);
          }
        }
      }
      //return sResult;
    }
  
    /***
     * Inner thread class which actually does the file delete
     * @author Keith Stumpf
     */
    class DeleteFileThread extends Thread
   {
     //
 
     // Exception in the event an exception was thrown
     private Exception m_exception = null;
     //
     boolean m_bFinished = false;
 
     String m_sFilename;
     long m_lSleepBeforeDelete;
 
     // Connect to the specified host and port number
     public DeleteFileThread (String sFilename, long lSleepBeforeDelete )
     {
       // Assign to member variables
       m_sFilename = sFilename;
       m_lSleepBeforeDelete = lSleepBeforeDelete;
     }
 
     public void run()
     {
       if (Utils.debug) System.out.println("DeleteFileThread::run - begin="+m_sFilename+" Thread name="+getName());
       try
       {
         m_bFinished = false;
         if (m_sFilename == null || m_sFilename.equals("")){
           m_bFinished = true;
           if (Utils.debug) System.out.println("DeleteFileThread::run - end - no file to delete.");
           return;
         }
         // Allow some time to render the html before deleting image files.
         // Otherwise image files are gone before painting html in browser.
         if (Constants.DELETE_FILES_IND){
           try{
               Thread.currentThread().sleep(m_lSleepBeforeDelete);
           }catch(InterruptedException e){ }
           if (m_sFilename != null && !m_sFilename.equals("")){
             File fileImage = new File (m_sFilename);
             if (Utils.debug) System.out.println("DeleteFileThread::run - deleted file="+m_sFilename+" Thread name="+getName());
             fileImage.delete();
           }
         }
         m_bFinished = true;
       }
       catch (Exception e)
       {
         // Assign to our exception member variable
         m_exception = e;
         return;
       }
       if (Utils.debug) System.out.println("DeleteFileThread::run - end");
     }
 
     // Are we finished?
     public boolean isFinished()
     {
       return m_bFinished;
     }
 
     // Did an error occur?
     public boolean isError()
     {
       if (m_exception == null)
         return false;
       else
         return true;
     }
 
     // Get exception
     public Exception getException()
     {
       return m_exception;
     }
   }
 }