/** A tab pane to display properties of a server workflow.
 * 
 * Copyright (c) 2010 The Regents of the University of California.
 * All rights reserved.
 *
 * '$Author: crawl $'
 * '$Date: 2010-06-03 16:45:10 -0700 (Thu, 03 Jun 2010) $' 
 * '$Revision: 24730 $'
 * 
 * Permission is hereby granted, without written agreement and without
 * license or royalty fees, to use, copy, modify, and distribute this
 * software and its documentation for any purpose, provided that the above
 * copyright notice and the following two paragraphs appear in all copies
 * of this software.
 *
 * IN NO EVENT SHALL THE UNIVERSITY OF CALIFORNIA BE LIABLE TO ANY PARTY
 * FOR DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES
 * ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF
 * THE UNIVERSITY OF CALIFORNIA HAS BEEN ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 *
 * THE UNIVERSITY OF CALIFORNIA SPECIFICALLY DISCLAIMS ANY WARRANTIES,
 * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE
 * PROVIDED HEREUNDER IS ON AN "AS IS" BASIS, AND THE UNIVERSITY OF
 * CALIFORNIA HAS NO OBLIGATION TO PROVIDE MAINTENANCE, SUPPORT, UPDATES,
 * ENHANCEMENTS, OR MODIFICATIONS.
 *
 */
 
package org.kepler.workflowscheduler.gui;

import java.awt.BorderLayout;
import java.awt.Cursor;
import java.awt.Dimension;
import java.awt.GridBagConstraints;
import java.awt.GridBagLayout;
import java.awt.Insets;
import java.awt.event.ActionEvent;
import java.awt.event.ItemEvent;
import java.awt.event.ItemListener;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.StringReader;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Collections;
import java.util.Date;
import java.util.HashMap;
import java.util.TimeZone;
import java.util.Vector;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

import javax.swing.AbstractAction;
import javax.swing.BorderFactory;
import javax.swing.Box;
import javax.swing.BoxLayout;
import javax.swing.JButton;
import javax.swing.JComboBox;
import javax.swing.JComponent;
import javax.swing.JLabel;
import javax.swing.JOptionPane;
import javax.swing.JPanel;
import javax.swing.JTextArea;
import javax.swing.JTextField;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.kepler.gui.TabManager;
import org.kepler.module.workflowschedulergui.Initialize;
import org.kepler.objectmanager.repository.Repository;
import org.kepler.objectmanager.repository.RepositoryManager;
import org.kepler.util.DotKeplerManager;
import org.xml.sax.ContentHandler;
import org.xml.sax.ErrorHandler;
import org.xml.sax.InputSource;
import org.xml.sax.XMLReader;
import org.xml.sax.helpers.XMLReaderFactory;

import edu.ucsb.nceas.schedulerclient.WorkflowSchedulerClient;
import ptolemy.actor.gui.TableauFrame;


/** A tab pane to display a scheduler of a server workflow.
 * 
 * @author Daniel Crawl
 * @version $Id: ServerWorkflowPropertiesPanel.java 24730 2010-06-03 23:45:10Z crawl $
 */
public class WorkflowSchedulerPanel extends JPanel 
{
  private static final Log log = LogFactory.getLog(WorkflowSchedulerPanel.class
      .getName());
    private static final int LEADSPACESIZE = 50; // leading space of each row
    private static final int TEXTFIELDSIZE = 400;
    public static final String[] INTERVALUNITLABEL = {"hours", "days", "weeks", "months"};
    public static final String[] INTERVALUNITVALUE = {Schedule.HOUR, Schedule.DAY, Schedule.WEEK, Schedule.MONTH};
    public static final String WORKFLOWRUNENGINECOMBOBOX = "workflowRunEngineCombo";
    public static final String DESTINATIONSERVERCOMBOBOX = "destinationServerCombo";
    public static final String TIMEEXAMPLE = "MM/dd/yyyy hh:mm:ss";
    private static final int UINTCOMBOXWIDTH = 100;
    private static final String WARNING = "Warning";
    public static final String TIMESTAMPFORMAT = "MM/dd/yyyy HH:mm:ss";
    public static final String TIMESTAMPFORMATWITHTIMEZONE =  TIMESTAMPFORMAT+" zzzz";
    private static final String URL = "url";
    private static final String NOTE = "Schedule the selected workflow by filling in "+
                                    "the fields below, choosing an execution engine, and the "+
                                     "destination repository for the workflow result archive:";
    private static final String UNKNOWN = "Unknown";
    private static final String SOURCEKARLOCATION = "Location     ";
    private static final int TIMEZONESTYLE = TimeZone.LONG;
    private static final String TIMEZONEIDCACHEFILENAME = "time_zone_ids_cache_";
    private TableauFrame parent;
    private JPanel schedulerPanel = null;
    private JPanel parameterPanel = null;
    private JPanel buttonPanel = null;
    private ExistingSchedulePanel existingSchedulePanel = null;
    private GridBagConstraints textFieldConstraint = null;
    private GridBagConstraints labelConstraint = null;
    private GridBagConstraints lastConstraint = null;
    private JLabel nameTextLabel = null;
    private JLabel karSourceLocationLabel = null;
    private JTextField intervalTextField = null;
    private JTextField startTimeTextField = null;
    private JTextField endTimeTextField = null;
    private String startTime = null;
    private String endTime = null;
    private String interval = null;
    private JComboBox intervalUnitComboBox = null;
    private JComboBox startTimeZoneComboBox = null;
    private JComboBox endTimeZoneComboBox = null;
    //private String intervalUnit = INTERVALUNITVALUE[0];
    private String workflowId = null;
    private String workflowName = null;
    private String karLSID = null;
    private String karSourceRepositoryName = null;
    private String runKarDestinationRepositoryName = null;
    private String workflowRunEngineURL = null;
    //private String schedulerURL = "http://fakeurl";
    //private String returnedWorkflowJobName = null;
    private Schedule[] existingScheduleList = null;
    private ScheduleWorkflowAction scheduleAction = null;
    private ScheduleChangeController scheduleChangeController = null;
    private JComboBox workflowRunEngineBox = null;
    private JComboBox resultDestinationBox = null;
    private Vector<WorkflowRunEngine> workflowRunEngineList = new Vector<WorkflowRunEngine>();
    private Vector <Repository> repositoryList = null;
    private SearchScheduleSwingWorker searchWorker = null;
    private Vector<String> availableTimeZoneIDsInServer = new Vector<String>();
    private static String[] availableTimeZoneIDsInLocal = null;
    private Vector <String> availableTimeZoneNames = new Vector<String>();
    //private SearchSchedulesWorkerListenerInterface searchWorkerListener = null;
    WorkflowSchedulerParentPanel schedulerParentPanel = null;
    private final Lock existingScheduleTablelock = new ReentrantLock();
    private IntervalUnitComboBoxAction intervalUnitSelectionaction = new IntervalUnitComboBoxAction();
    private HashMap<String, TimeZone> timeZoneDisplayHash = new HashMap <String, TimeZone>();
    private String startTimeZoneID = null;
    private String startTimeZoneName = null;
    private String startTimeLabel = null;
    private String endTimeZoneID = null;
    private String endTimeZoneName = null;
    private String endTimeLabel = null;
    private File  timeZoneIDsCacheFile = null;
    private String schedulerURL = Initialize.getSchedulerURL();
  

    /** Construct a new ServerWorkflowSchedulePanel in a frame with a specific title. */
    public WorkflowSchedulerPanel(TableauFrame parent, WorkflowSchedulerParentPanel schedulerParentPanel,
                                ScheduleChangeController scheduleChangeController) throws Exception 
    {
        super();
        this.parent = parent;
        this.schedulerParentPanel = schedulerParentPanel;
        this.scheduleChangeController = scheduleChangeController;
        try
        {
          initialize();
        }
        catch (Exception e)
        {
          throw new Exception("\nWorkflowSchedulerPanel -- couldn't initialize the workflow scheduler panel -- "+e.getMessage());
        }

        setBackground(TabManager.BGCOLOR);
    }
    
   
    /**
     * This method must return the TableauFrame this tab is associated with.
     */
    public TableauFrame getParentFrame()
    {
      return parent;
    }

    
    /* Initialize the contents of the panel. */
    private void initialize() throws Exception
    {
      //getSchedulerURL();
      initializeTimeZones();
      initializeGridBagLayout();
      initializeSchedulerPanel();
      //initializeParameterPanel();
      initializeButtonPanel();
      initializeExistingSchedulePanel();
     
      //whole panel will be box layout
      this.setLayout(new BoxLayout(this, BoxLayout.Y_AXIS));
      this.add(Box.createVerticalStrut(10));      
      Box box = Box.createHorizontalBox();
      //JLabel noteLabel = new JLabel(NOTE, JLabel.LEFT);
      //noteLabel.setForeground(Color.blue);
      //noteLabel.setOpaque(true);
      //noteLabel.setBackground(Color.blue);
      JTextArea noteTextArea = new JTextArea(NOTE);
      noteTextArea.setEditable(false);
      noteTextArea.setLineWrap(true);
      noteTextArea.setWrapStyleWord(true);
      //descriptionTextArea.setPreferredSize(new Dimension(400, 400));
      noteTextArea.setBackground(TabManager.BGCOLOR);
      box.add(noteTextArea);
      box.add(Box.createHorizontalGlue());
      this.add(box);
      
      this.add(Box.createVerticalStrut(15));
      
      this.add(schedulerPanel);
      //this.add(parameterPanel);
      this.add(buttonPanel);
      //this.add(Box.createVerticalStrut(60));
      this.add(existingSchedulePanel);
          
      
    }
    
    
    /*
     * Initialize the available time zones
     */
    private void initializeTimeZones() throws Exception
    {
      
      if(schedulerURL != null && !schedulerURL.trim().equals(""))
      {
        String newURL = schedulerURL.replaceAll("/", "_");
        newURL = newURL.replaceAll(":", "_");
        timeZoneIDsCacheFile = new File(DotKeplerManager.getInstance().getTransientModuleDirectory(Initialize.MODULENAME),
            TIMEZONEIDCACHEFILENAME+newURL);
        //System.out.println("The cache file path is "+timeZoneIDsCacheFile.getAbsolutePath());
      }
      
      //System.out.println("start !!!!!!!!!!!!!!!!!!!!!!!!!!!11 initialize time zone");
      availableTimeZoneIDsInLocal = TimeZone.getAvailableIDs();
      initializeSchedulerServerAvailableTimeZoneIDs();
      for( String id : availableTimeZoneIDsInServer)
      {
        //only display the ids found in both server and local
        if(localContainsTimeZoneID(id))
        {
          //add standard time zone name
          Boolean notDayLight = false;
          TimeZone zone = TimeZone.getTimeZone(id);
          String standName = zone.getDisplayName(notDayLight, TIMEZONESTYLE);
          if(!availableTimeZoneNames.contains(standName))
          {
            availableTimeZoneNames.add(standName);  
            timeZoneDisplayHash.put(standName, zone);
          }
          //add day light time zone name if it is available
          Boolean useDayLight = zone.useDaylightTime();
          if(useDayLight) 
          {
            String dayLightName = zone.getDisplayName(useDayLight, TIMEZONESTYLE);
            if (!availableTimeZoneNames.contains(dayLightName))
            {
              availableTimeZoneNames.add(dayLightName);
              timeZoneDisplayHash.put(dayLightName, zone);
            }
          }
        }
        
      }
      Collections.sort(availableTimeZoneNames);
      //System.out.println("end !!!!!!!!!!!!!!!!!!!!!!!!!!!11 initialize time zone");
    }
    
    
    private void initializeSchedulerServerAvailableTimeZoneIDs() throws Exception 
    {
      if(timeZoneIDsCacheFile != null && timeZoneIDsCacheFile.exists())
      {
        //try to get the available ids from the cache
        try
        {
          getAvailableServerTimeZoneIDFromCache();
          if(availableTimeZoneIDsInServer == null || availableTimeZoneIDsInServer.isEmpty())
          {
            getAvailableServerTimeZoneIDFromServer();
          }
        }
        catch(Exception e)
        {
          log.warn("WorkflowSchedulerPanel.initializeSchedulerServerAvailableTimeZoneIDs - Failed to get the available time zone from the cache.\n"+
                        "Try to get the time zone ids from server again");
          getAvailableServerTimeZoneIDFromServer();
        }
      }
      else
      {
        //try to get the available ids from the server
        getAvailableServerTimeZoneIDFromServer();
      }
      
    }
    
    /*
     * Get the available server time zone id from a cache file
     */
    private void getAvailableServerTimeZoneIDFromCache() throws Exception
    {
      if(timeZoneIDsCacheFile != null)
     {
        //System.out.println("===== get ids from cache ");
        FileInputStream fileInput = new FileInputStream(timeZoneIDsCacheFile);
        ObjectInputStream objectInput = new ObjectInputStream(fileInput);
        availableTimeZoneIDsInServer = (Vector<String>)objectInput.readObject();
     }
    }
    
    /*
     * Gets the available server time zone id from the workflow scheduler server
     */
    private void getAvailableServerTimeZoneIDFromServer() throws Exception
    {
      //System.out.println("===== get ids from sever ");
      String sessionID = "blank";
      String authURL = "blank";
      WorkflowSchedulerClient client = new WorkflowSchedulerClient(schedulerURL, sessionID, authURL); 
      String result = null;
      try
      {
        parent.setCursor(Cursor.getPredefinedCursor(Cursor.WAIT_CURSOR));
        result = client.getAvailableTimeZoneIDs();
        parent.setCursor(Cursor.getPredefinedCursor(Cursor.DEFAULT_CURSOR));
      }
      catch(Exception e)
      {
        parent.setCursor(Cursor.getPredefinedCursor(Cursor.DEFAULT_CURSOR));
        throw new Exception("\nCouldn't contact the scheduler -- "+schedulerURL+" to get its available time zone ids --\n "+e.getMessage());
      }
      if(result != null && !result.trim().equals(""))
      {
        StringReader xmlReader = new StringReader(result);
        try
        {
          XMLReader parser = null;
          parser = XMLReaderFactory.createXMLReader(SearchScheduleSwingWorker.PARSERNAME);
          ServerTimeZoneIDParser handler = new ServerTimeZoneIDParser();
          parser.setContentHandler((ContentHandler) handler);
          parser.setErrorHandler((ErrorHandler) handler);
          parser.parse(new InputSource(xmlReader));
          availableTimeZoneIDsInServer = handler.getValaibleTimeZoneIDs();
          saveAvailableServerTimeZoneIDToCache();
        }
        catch(Exception e)
        {
         throw new Exception("\nCouldn't parse the information about the server available time zone ids  in "+
           schedulerURL+" - "+e.getMessage());
        }
      }
    }
    
    
    /*
     * Save the time zone ids from the server into a cache file
     */
    private void saveAvailableServerTimeZoneIDToCache()
    {
      if(availableTimeZoneIDsInServer != null) {
        try
        {
          if(timeZoneIDsCacheFile != null)
          {
            timeZoneIDsCacheFile.delete();
          }
          FileOutputStream fileOutput = new FileOutputStream(timeZoneIDsCacheFile);
          ObjectOutputStream objectOutput = new ObjectOutputStream(fileOutput);
          objectOutput.writeObject(availableTimeZoneIDsInServer);
        }
        catch(Exception e)
        {
          log.error("WorkflowSchedulerPanel.saveAvailableServerTimeZoneIDToCache - Can't save the server time zone ids into a cache file :"+e.getMessage());
        }
      }
    }
    /*
     * Initialize the grid bag layout manager
     */
    private void initializeGridBagLayout()
    {
      textFieldConstraint = new GridBagConstraints();
      textFieldConstraint.fill = GridBagConstraints.HORIZONTAL;
      //lastConstraint.anchor = GridBagConstraints.NORTHWEST;
      // Give the "last" component as much space as possible
      textFieldConstraint.weightx = 1.0;
      //textFieldConstraint.gridwidth = GridBagConstraints.RELATIVE;     
      textFieldConstraint.insets = new Insets(4, 4, 4, 4);

      lastConstraint = (GridBagConstraints) textFieldConstraint.clone();
      //These still get as much space as possible, but do
      //not close out a row
      lastConstraint.gridwidth = GridBagConstraints.REMAINDER;
  
      // first component (usually it is a label) on each row
      labelConstraint = (GridBagConstraints) textFieldConstraint.clone();
      // Give these as little space as necessary
      labelConstraint.weightx = 0.0;
      labelConstraint.gridwidth = 1;

    }
    
    /*
     * Initialize the scheduler panel. This panel contains
     * workflow name, start time, end time and interval.
     */
    private void initializeSchedulerPanel()
    {
      schedulerPanel = new JPanel();
      GridBagLayout gridbag = new GridBagLayout();
      schedulerPanel.setLayout(gridbag);
      // Name row
      addLeadingSpace(schedulerPanel, gridbag);
      JLabel nameLabel = new JLabel("Workflow          ");
      addComponent(schedulerPanel, nameLabel, gridbag, labelConstraint);
      nameTextLabel = new JLabel(UNKNOWN);
      addFixWidthComponent(schedulerPanel, nameTextLabel, gridbag, textFieldConstraint);
      addEndingSpace(schedulerPanel, gridbag);
      
      //source kar file location row
      addLeadingSpace(schedulerPanel, gridbag);
      JLabel karSourceLocation = new JLabel(SOURCEKARLOCATION);
      addComponent(schedulerPanel, karSourceLocation, gridbag, labelConstraint);
      karSourceLocationLabel = new JLabel(UNKNOWN);
      addFixWidthComponent(schedulerPanel, karSourceLocationLabel, gridbag, textFieldConstraint);
      addEndingSpace(schedulerPanel, gridbag);
      
      //start time row
      addLeadingSpace(schedulerPanel, gridbag);
      JLabel startTimeLabel = new JLabel("Start Time          ");
      addComponent(schedulerPanel, startTimeLabel, gridbag, labelConstraint);
      startTimeTextField = new JTextField();
      startTimeTextField.setText(TIMEEXAMPLE);
      addFixWidthComponent(schedulerPanel, startTimeTextField , gridbag, textFieldConstraint);
      startTimeZoneComboBox = new JComboBox(availableTimeZoneNames);
      startTimeZoneComboBox.addItemListener(new StartTimeZoneItemListener());
      startTimeZoneComboBox.setSelectedItem(getDefaultTimeZoneName());
      addComponent(schedulerPanel, startTimeZoneComboBox, gridbag, labelConstraint);
      addEndingSpace(schedulerPanel, gridbag);
    
      //end time row
      addLeadingSpace(schedulerPanel, gridbag);
      JLabel endTimeLabel = new JLabel("End Time          ");
      addComponent(schedulerPanel, endTimeLabel, gridbag, labelConstraint);
      endTimeTextField = new JTextField();
      endTimeTextField.setText(TIMEEXAMPLE);
      addFixWidthComponent(schedulerPanel, endTimeTextField, gridbag, textFieldConstraint);
      endTimeZoneComboBox = new JComboBox(availableTimeZoneNames);
      endTimeZoneComboBox.addItemListener(new EndTimeZoneItemListener());
      endTimeZoneComboBox.setSelectedItem(getDefaultTimeZoneName());
      addComponent(schedulerPanel, endTimeZoneComboBox, gridbag, labelConstraint);
      addEndingSpace(schedulerPanel, gridbag);
     
      //interval row
      addLeadingSpace(schedulerPanel, gridbag);
      JLabel intervalLabel = new JLabel("Interval          ");
      addComponent(schedulerPanel, intervalLabel, gridbag, labelConstraint);
      intervalTextField = new JTextField();
      addFixWidthComponent(schedulerPanel, intervalTextField, gridbag, textFieldConstraint);
      intervalUnitComboBox = new JComboBox(INTERVALUNITLABEL);
     
      intervalUnitComboBox.addActionListener(intervalUnitSelectionaction);
      Dimension size = intervalUnitComboBox.getPreferredSize();
      size.width = UINTCOMBOXWIDTH;
      addComponent(schedulerPanel, intervalUnitComboBox, gridbag, labelConstraint);
      addEndingSpace(schedulerPanel, gridbag);     
      
      //workflow run engine combobox row
      addLeadingSpace(schedulerPanel, gridbag);
      JLabel workflowRunEngineLabel = new JLabel("Workflow Run Engine      ");
      addComponent(schedulerPanel, workflowRunEngineLabel, gridbag, labelConstraint);
      workflowRunEngineList = Initialize.getWorkflowRunEngineList();
      workflowRunEngineBox = new JComboBox(workflowRunEngineList);
      workflowRunEngineBox.setRenderer(new RepositoryAndRunEngineComboBoxRenderer(WORKFLOWRUNENGINECOMBOBOX));
      addFixWidthComponent(schedulerPanel, workflowRunEngineBox, gridbag, textFieldConstraint);
      addEndingSpace(schedulerPanel, gridbag);
      
      //result destination combobox row
      addLeadingSpace(schedulerPanel, gridbag);
      JLabel resultDestinationLabel = new JLabel("Result Destination    ");
      addComponent(schedulerPanel, resultDestinationLabel, gridbag, labelConstraint);
      try
      {
        repositoryList= RepositoryManager.getInstance().getRepositories();
      }
      catch(Exception e)
      {
        log.warn("ServerWorkflowSchedulePanel.initializeSchedulerPane - couldn't get repository list "+e.getMessage());
      }
      
      if(repositoryList == null)
      {
        repositoryList = new Vector<Repository>();
      }
      resultDestinationBox = new JComboBox(repositoryList);
      resultDestinationBox.setRenderer(new RepositoryAndRunEngineComboBoxRenderer(DESTINATIONSERVERCOMBOBOX));
      addFixWidthComponent(schedulerPanel, resultDestinationBox, gridbag, textFieldConstraint);
      addEndingSpace(schedulerPanel, gridbag);
      
      
    }
    
   
    
    /*
     * Initialize button panel. The panel contains "Schedule" button.
     */
    private void initializeButtonPanel()
    {
      scheduleAction = new ScheduleWorkflowAction(parent, schedulerParentPanel,scheduleChangeController);
      buttonPanel = new JPanel();
      buttonPanel.setLayout(new BoxLayout(buttonPanel, BoxLayout.X_AXIS));
      buttonPanel.setBorder(BorderFactory.createEmptyBorder(10, 10, 10, 10));
      buttonPanel.add(Box.createHorizontalGlue());
      JButton scheduleButton = new JButton("Schedule");
      scheduleButton.setPreferredSize(new Dimension(100, 50));
      scheduleButton.addActionListener(new AbstractAction()
      {
        public void actionPerformed(ActionEvent e) 
        {
          setCursor(Cursor.getPredefinedCursor(Cursor.WAIT_CURSOR));
          boolean valid = validateInputField();
          if (valid == true)
          {
             Schedule schedule = new Schedule();
             schedule.setWorkflowId(workflowId);
             schedule.setKarLSID(karLSID);
             schedule.setWorkflowName(workflowName);
             
             //appendTimeZoneToTimeString();
             //System.out.println("The start time is "+startTime);
             //System.out.println("The end time is "+endTime);
             schedule.setStartTime(startTime);
             schedule.setStartTimeLabel(startTime+" "+startTimeZoneName);
             schedule.setStartTimeZoneID(startTimeZoneID);
             schedule.setStartTimeFormat(TIMESTAMPFORMAT);
             schedule.setEndTime(endTime);
             schedule.setEndTimeLabel(endTime+" "+endTimeZoneName);
             schedule.setEndTimeZoneID(endTimeZoneID);
             schedule.setEndTimeFormat(TIMESTAMPFORMAT);
             schedule.setInterval(interval);
             
             schedule.setWorkflowRunEngine(
                 (WorkflowRunEngine)workflowRunEngineBox.getSelectedItem());
             schedule.setWorkflowRunDestination(
                 (Repository)resultDestinationBox.getSelectedItem());
             try
             {
               String intervalUnit = intervalUnitSelectionaction.getIntervalUnit();
               schedule.setIntervalUnit(intervalUnit);
             }
             catch(Exception ee)
             {
               JOptionPane.showMessageDialog(parent, ee.getMessage(), "Error", JOptionPane.ERROR_MESSAGE);
               return;
             }
             scheduleAction.setSchedule(schedule);
             scheduleAction.actionPerformed(e);
          }
          setCursor(Cursor.getPredefinedCursor(Cursor.DEFAULT_CURSOR));
        }
      });
      buttonPanel.add(scheduleButton);

    }
    
    /*
     * Initialize the existing schedule panel
     */
    private void initializeExistingSchedulePanel()
    {
      existingSchedulePanel = new ExistingSchedulePanel(existingScheduleList, parent, schedulerParentPanel, scheduleChangeController);
      scheduleChangeController.addListener(existingSchedulePanel);
    }
    
   
    
   
    /*
     *Add leading space in each row of a panel 
     */
    private void addLeadingSpace(JPanel panel, GridBagLayout layout)
    {
      String space = "       ";
      JLabel leadingLabel = new JLabel(space);
      Dimension size = leadingLabel.getPreferredSize();
      size.width = LEADSPACESIZE;
      leadingLabel.setPreferredSize(size);
      addComponent(panel, leadingLabel, layout, labelConstraint);
    }
    
    /*
     *Add ending space in each row of a panel 
     */
    private void addEndingSpace(JPanel panel, GridBagLayout layout)
    {
      String space = "       ";
      JLabel leadingLabel = new JLabel(space);
      addComponent(panel, leadingLabel, layout, lastConstraint);
    }
    
    private String getDefaultTimeZoneName()
    {
      String name = null;
      TimeZone timeZone = TimeZone.getDefault();
      boolean daylight = timeZone.inDaylightTime(new Date());
      name = timeZone.getDisplayName(daylight, TIMEZONESTYLE);
      return name;
    }
    
    /*
     * Create a blank "last field" component gets us to a new line.
     */
    /*private void addNewLine(JPanel panel, GridBagLayout layout)
    {
      String space = " ";
      JLabel leadingLabel = new JLabel(space);
      addComponentWithGridBagLayout(panel, leadingLabel, layout, lastConstraint);
    }*/
    
    /*
     * Add a component with specified layout to the given panel
     */
    public static void addComponent(JPanel panel, JComponent component, GridBagLayout layout, GridBagConstraints constraint)
    {
      if(component != null  && panel != null && layout != null)
      {
        layout.setConstraints(component, constraint);
        panel.add(component);
      }

    }
    
    /*
     * Add a component with specified layout to the given panel
     */
    public static void addFixWidthComponent(JPanel panel, JComponent component, GridBagLayout layout, GridBagConstraints constraint)
    {
      if(component != null  && panel != null && layout != null)
      {
        Dimension size = component.getPreferredSize();
        size.width = TEXTFIELDSIZE;
        layout.setConstraints(component, constraint);
        panel.add(component);
      }

    }
    
    /*
     * Validate the input fields on the schedule panel
     */
    private boolean validateInputField()
    {
      boolean success = true;
      startTime = startTimeTextField.getText();
      endTime = endTimeTextField.getText();
      interval = intervalTextField.getText();
      //validate startTime
      if(startTime== null || startTime.trim().equals(""))
      {
        JOptionPane.showMessageDialog(parent, "\"Start Time\" field can't be blank!", WARNING, JOptionPane.WARNING_MESSAGE);
        success = false;
        return success;
      }
      else
      {
         success = validateTimeString(startTime, TIMESTAMPFORMAT);
         if(success == false)
         {
           JOptionPane.showMessageDialog(parent, "\"Start Time\" field should be the format \"MM/dd/yyyy hh:mm:ss\"!", WARNING, JOptionPane.WARNING_MESSAGE);
           return success;
         }
      }
      //validate endTime
      if(endTime== null || endTime.trim().equals(""))
      {
        JOptionPane.showMessageDialog(parent, "\"End Time\" field can't be blank!", WARNING, JOptionPane.WARNING_MESSAGE);
        success = false;
        return success;
      }
      else
      {
         success = validateTimeString(endTime, TIMESTAMPFORMAT);
         if(success == false)
         {
           JOptionPane.showMessageDialog(parent, "\"End Time\" field should be the format \"MM/dd/yyyy hh:mm:ss\"!", WARNING, JOptionPane.WARNING_MESSAGE);
           return success;
         }
      }
      //validate interval
      if(interval == null || interval.trim().equals(""))
      {
        JOptionPane.showMessageDialog(parent, "\"Interval\" field can't be blank!", WARNING, JOptionPane.WARNING_MESSAGE);
        success = false;
        return success;
      }
      else
      {
         try
         {
           int intValue = Integer.parseInt(interval);
           if(intValue < 1)
           {
             JOptionPane.showMessageDialog(parent, "\"Interval\"  should be greater than zero!", WARNING, JOptionPane.WARNING_MESSAGE);
             success = false;
             return success;
           }
         }
         catch(NumberFormatException e)
         {
           JOptionPane.showMessageDialog(parent, "\"Interval\" field should be an integer!", WARNING, JOptionPane.WARNING_MESSAGE);
           success = false;
           return success;
         }
      }     
      return success;
    }
    
    /*
     * Validate the time string with specified format
     */
      private boolean validateTimeString(String dateString, String format)  
      {
        boolean valid = true;
      
        try 
        {
          SimpleDateFormat dateFormat = new SimpleDateFormat(format);
          dateFormat.setLenient(false);
          Date startDate = dateFormat.parse(dateString);         
        } 
        catch (ParseException pe) 
        {
          valid = false;
        }
      
        return valid;
      }
    
  
    
   /*
    * Set the kar source eporsitory name.
    * @param name
    */
   private void setKarSourceRepositoryName(String name)
   {
     this.karSourceRepositoryName = name;
   }
    /**
     * Get the id of the workflow (LSID format)
     * @return the id
     */
    public String getWorkflowId()
    {
      return workflowId;
    }
    
    /**
     * Set the workflow id (LSID format)
     * @param workflowId the id will be set
     */
    public void setWorkflowId(String workflowId)
    {
      this.workflowId = workflowId;
    }

    /**
     * Get the name of the workflow
     * @return the name
     */
    public String getWorkflowName()
    {
      return workflowName;
    }

    /*
     * Set the name of the workflow. It will update the workflow name label
     * on the gui as well
     * @param workflowName the name will be set
     */
    private void setWorkflowName(String workflowName)
    {
      if(workflowName == null || workflowName.trim().equals(""))
      {
        this.workflowName = UNKNOWN;
      }
      else
      {
        this.workflowName = workflowName;
      }
      //updateWorkflowNameLabel();
    }
    
    /*
     * Update workflow name text label
     */
    private void updateWorkflowNameLabel()
    {
      nameTextLabel.setText(workflowName);
      nameTextLabel.repaint();
      nameTextLabel.validate();
    }
    
    /*
     * Update the source kar file location
     */
    private void updateSourceKarFileLocationLabel()
    {
      if(karSourceRepositoryName != null && 
          !karSourceRepositoryName.trim().equals(""))
      {
        karSourceLocationLabel.setText(karSourceRepositoryName);
        karSourceLocationLabel.repaint();
        karSourceLocationLabel.validate();
      }
    }

    /**
     * Get the kar file id associated with the workflow.
     * @return the id fo the kar file
     */
    public String getKarLSID()
    {
      return karLSID;
    }

    /**
     * Set the id of the kar file
     * @param karId id will be set
     */
    public void setKarLSID(String karId)
    {
      this.karLSID = karId;
    }
    
    /**
     * Pass a workflow information to the scheulder. The scheduler will update
     * its gui as well.
     * @param workflowName name of the workflow
     * @param workflowLSID lsid of the workflow 
     * @param karSourceRepositoryName name of the repository where the kar file stays
     * @param karLSID lsid of the kar file which the workflow stays
     */
    public void setWorkflowForScheduling(String workflowName, String workflowLSID, 
                                      String karSourceRepositoryName, String karLSID, boolean hasReportLayout)
    {
      
      schedulerParentPanel.removeAll();
      schedulerParentPanel.add(this, BorderLayout.CENTER);
      setWorkflowId(workflowLSID);
      setKarSourceRepositoryName(karSourceRepositoryName);
      updateSourceKarFileLocationLabel();
      try
      {
        SchedulerAbstractAction.setSourceRespositoryName(karSourceRepositoryName);
        SchedulerAbstractAction.setHasReportLayout(hasReportLayout);
      }
      catch(Exception e)
      {
        JOptionPane.showMessageDialog(parent, "User will NOT do any schedule-related action since kepler couldn't find the repository named "+
            karSourceRepositoryName+" - "+e.getMessage(), "Error", JOptionPane.ERROR_MESSAGE);
      }
      setKarLSID(karLSID);
      setWorkflowName(workflowName);
      updateWorkflowNameLabel();
      addExistingSchedules();
    }
    
    /*
     * Search the scheudler to find the existing schedules for the workflow,
     * and add those schedules to the existing workflow panel.
     */
    private void addExistingSchedules()
    {
      if(searchWorker != null)
      {
        //System.out.println("interrupt====");
        searchWorker.cancel(true);
        searchWorker = null;
        
      }
      try
      {
        searchWorker = new SearchScheduleSwingWorker(scheduleChangeController,
                                                      workflowId, karLSID, existingScheduleTablelock);
        //searchWorker.setSearchWorkerListener(searchWorkerListener);
        searchWorker.execute();
      }
      catch(Exception e)
      {
        if(scheduleChangeController != null)
        {
          scheduleChangeController.stopProgressBar();
        }
        JOptionPane.showMessageDialog(parent, e.getMessage(), "Error", JOptionPane.ERROR_MESSAGE);
      }
    }
    
  
    /**
     * Look for couterpart of interval unit for a specified unit label
     * @param unitLabel the specified unit label
     * @return the actual unit for the label. Null will be returned if no match was found
     */
    public static String lookupIntervalUnit(String unitLabel)
    {
      String unit = null;
      if(unitLabel != null)
      {
        for(int i=0; i< INTERVALUNITLABEL.length; i++)
        {
          String label = INTERVALUNITLABEL[i];
          if(label != null && label.equals(unitLabel))
          {
            unit = INTERVALUNITVALUE[i];
            break;
          }
        }
      }
      return unit;
    }
   
    
    /**
     * Look for counterpart of interval unit label for a specified unit
     * @param unit the specified unit 
     * @return the unit label for the unit. Null will be returned if no match was found
     */
    public static String lookupIntervalUnitLabel(String unit)
    {
      String unitLabel = null;
      if(unit != null)
      {
        for(int i=0; i< INTERVALUNITVALUE.length; i++)
        {
          String unitValue =  INTERVALUNITVALUE[i];
          if(unitValue != null && unitValue.equals(unit))
          {
            unitLabel =INTERVALUNITLABEL[i];
            break;
          }
        }
      }
      return unitLabel;
    }
    
    /*
     * Append time zone to the time string.
     */
    /*private void appendTimeZoneToTimeString()
    {
      //TimeZone timeZone = Calendar.getInstance().getTimeZone();
      //String name = timeZone.getDisplayName(true, TimeZone.LONG);
      String selectedStartTimeZone = (String)startTimeZoneComboBox.getSelectedItem();
      //System.out.println("The selected start time zone is "+selectedStartTimeZone);
      startTime = startTime+" "+selectedStartTimeZone;
      //System.out.println("The start time is "+startTime);
      String selectedEndTimeZone = (String)endTimeZoneComboBox.getSelectedItem();
      //System.out.println("The selected end time zone is "+selectedEndTimeZone);
      endTime = endTime+" "+selectedEndTimeZone;
      //System.out.println("The end time is "+endTime);
      
    }*/
    
    public static boolean localContainsTimeZoneID(String id)
    {
      boolean contains = false;
      if(id != null && !id.trim().equals(""))
      {
        for(String timeZoneId : availableTimeZoneIDsInLocal)
        {
          if(timeZoneId != null && !timeZoneId.trim().equals("") && timeZoneId.equals(id))
          {
            //System.out.println("local time zone cotains the id "+id);
            contains = true;
            break;
          }
        }
      }
      return contains;
    }
    
    /*
     * A listener to handle a selection on the start time zone drop-down box.
     * It decides the start time zone id.
     * It also sets the end time zone as same as the start time zone when user
     * change the start time zone.
     */
    private class StartTimeZoneItemListener implements ItemListener
    {
       public void itemStateChanged(ItemEvent e)
       {
         //System.out.println("====== event: selec"+e.getItem());
         startTimeZoneName = (String) e.getItem();
         //System.out.println("The selected start time name is "+startTimeZoneName);
         TimeZone zone = timeZoneDisplayHash.get(startTimeZoneName);
         startTimeZoneID = zone.getID();
         //System.out.println("selected this id in start time zone"+startTimeZoneID);
         if(endTimeZoneComboBox != null) 
         {
           endTimeZoneComboBox.setSelectedItem(e.getItem());
         }
       }
    }
    
    
    /*
     * A listener to handle a selection on the end time zone drop-down box.
     * It decides the end time zone id.
     */
    private class EndTimeZoneItemListener implements ItemListener
    {
       public void itemStateChanged(ItemEvent e)
       {
         //System.out.println("====== event: selec"+e.getItem());
         endTimeZoneName = (String) e.getItem();
         //System.out.println("The selected end time name is "+endTimeZoneName);
         TimeZone zone = timeZoneDisplayHash.get(endTimeZoneName);
         endTimeZoneID = zone.getID();
         //System.out.println("selected this id in end time zone "+endTimeZoneID);

       }
    }
    
}