/**
 * Copyright (c) 2010 The Regents of the University of California.
 * All rights reserved.
 *
 * '$Author: tao $'
 * '$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.io.File;
import java.util.Stack;
import java.util.concurrent.atomic.AtomicBoolean;

import javax.swing.Box;
import javax.swing.BoxLayout;
import javax.swing.JLabel;
import javax.swing.JOptionPane;
import javax.swing.JPanel;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.ecoinformatics.ecogrid.client.IdentifierServiceClient;
import org.kepler.gui.TabPane;
import org.kepler.kar.KARFile;
import org.kepler.objectmanager.lsid.KeplerLSID;
import org.kepler.objectmanager.repository.Repository;
import org.kepler.objectmanager.repository.RepositoryManager;

import ptolemy.actor.gui.TableauFrame;

/**
 * This class represents the right panel of the scheduler dialog object.
 * It can show one panel of the two options - a JLabel which ask user to
 * select a remote workflow and a real scheduler panel.
 * @author tao
 *
 */
public class WorkflowSchedulerParentPanel extends JPanel implements TabPane,
                                                        UploadingKARFileListenerInterface
{
  private static final Log log = LogFactory.getLog(WorkflowSchedulerParentPanel.class
      .getName());
  static final String SCHEDULER = "Scheduler";
  private static final int ITEM = 0;
  
  private JLabel message = new JLabel("Select a workflow from the Components panel.");
  private TableauFrame parent = null;
  private WorkflowSchedulerPanel schedulerPanel = null;
  //private boolean showedMessage = true;
  private ScheduleChangeController scheduleChangeController;
  //private volatile boolean doneSelectRemoteWorkflow = false;
  private Stack trackSelectRemoteWorkflow = new Stack();
  private AtomicBoolean  previousSelectionIsWorkflow = new AtomicBoolean(false);
  
  /**
   * Constructor
   * @param parent
   */
  public WorkflowSchedulerParentPanel(TableauFrame parent, ScheduleChangeController scheduleChangeController)
  {
    this.parent = parent;
    this.scheduleChangeController = scheduleChangeController;
    if(this.scheduleChangeController != null)
    {
      this.scheduleChangeController.addListener(this);
    }   
    try
    {
      schedulerPanel = new WorkflowSchedulerPanel(parent,this, this.scheduleChangeController);
    }
    catch(Exception e)
    {
      JOptionPane.showMessageDialog(null, "Workflow scheduler couldn't function correctly -- "+e.getMessage(), "Error", JOptionPane.ERROR_MESSAGE);
      //log.error("Workflow scheduler couldn't function correctly -- "+e.getMessage());
    }
    
    initialize();
  }
  
  /*
   * Initialize the panel
   */
  private void initialize()
  {
    this.setLayout(new BoxLayout(this,BoxLayout.Y_AXIS));
    this.add(Box.createVerticalStrut(20));
    Box box = Box.createHorizontalBox();
    box.add(Box.createHorizontalStrut(250));
    box.add(message);
    box.add(Box.createHorizontalGlue());
    this.add(box);
    this.add(Box.createVerticalGlue());
  }

  /**
   * Return the parent frame
   */
  public TableauFrame getParentFrame()
  {
    return parent;
  }

  /**
   * This method should return the name of the tab which is used to label the
   * tab in the TabbedPane
   */
  public String getTabName()
  {    
    return SCHEDULER;
  }

  /**
   * Initialize the tab
   */
  public void initializeTab() throws Exception
  {
    
  }

  /**
   * Set the parent frame of this panel
   */
  public void setParentFrame(TableauFrame parent)
  {
    this.parent = parent;
  }
  
  /**
   * Action for selecting a remote workflow on component search panel
   * @param name name of the workflow
   * @param lsid  lsid of the workflow 
   * @param karSourceRepositoryName the name of repository storing the kar file
   * @param karId the id of the kar file
   * @param hasReporting if the workflow has a reporting module
   */
  public synchronized void selectRemoteWorkflow(String workflowName, String workflowLsid, 
                                          String karSourceRepositoryName, String karId, boolean hasReportLayout)
  {
    //System.out.println("The workflow name is "+workflowName);
    //System.out.println("The workflow lsid is "+workflowLsid);
    //System.out.println("The repository name is "+karSourceRepositoryName);
    //System.out.println("The kar id is "+karId);
    //System.out.println("Choosing yes=============== ");
    if(karId != null && workflowLsid != null && karSourceRepositoryName != null && schedulerPanel != null)
    {
      if(scheduleChangeController != null)
      {
        scheduleChangeController.startProgressBar();
      }    
      previousSelectionIsWorkflow.set(true);
      trackSelectRemoteWorkflow.add(ITEM);
      schedulerPanel.setWorkflowForScheduling(workflowName, workflowLsid, 
                                                  karSourceRepositoryName, karId, hasReportLayout);
    }
    else
    {
      selectNonSchedulalbeItem();
    }
    
  }
  
  /**
   * Set a local workflow on this panel for scheduling
   * @param karFilePath the path of kar file which contains the workflow
   * @param workflowName the name of the workflow
   * @param workflowLSID the id of the workflow
   */
  public synchronized void setLocalWorkflow(String karFilePath, String workflowName, String workflowLSID)
  {
    
    selectNonSchedulalbeItem();//set the background 
    Repository repository = null;
    
    if(schedulerPanel == null)
    {
      return;
    }
    
    try
    {
     repository = RepositoryManager.getInstance().getSaveRepository();     
    }
    catch(Exception e)
    {
     log.warn("Couldn't find saving repository -"+e.getMessage());
    }
   
     if(repository == null)
     {
       JOptionPane.showMessageDialog(parent,  "To schedule this workflow, you must first choose a remote repository.\n"
           +"Click the \"Sources\" button and mark \"Save\" next to a remote Source, and try again.","Warning" , JOptionPane.WARNING_MESSAGE);
        return;
     }
     
     
      
    //check if the kar file already in LocalRemoteWorkflwoMappingController
    String remoteKarFileLSID = getRemoteKarLSIDFromLocalRemoteWorkflowController(karFilePath, repository.getName());
    if(remoteKarFileLSID == null)
    {
      //LocalRemoteWorkflwoMappingController doesn't register it,
      //check remote the server
      if(scheduleChangeController != null)
      {
        scheduleChangeController.startProgressBar();
      }
      KARFile karFile = getKarFile(karFilePath);
      if(karFile == null)
      {
        if(scheduleChangeController != null)
        {
          scheduleChangeController.stopProgressBar();
        }
        return;
      }
      //check the remote repository
      boolean registered = isAlreadyRegistered(karFile.getLSID(), repository);
      if(!registered)
      {
        // has not been uploaded, please upload the kar file
        int choice = JOptionPane.showConfirmDialog(parent, 
            "To schedule this workflow on the "+repository.getName()+" repository, it must first"
           +" be uploaded.\nUpload KAR?", "Warning", JOptionPane.YES_NO_OPTION);
       
       if(choice == JOptionPane.NO_OPTION)
       {
         if(scheduleChangeController != null)
         {
           scheduleChangeController.stopProgressBar();
         }
         return;
       }
       uploadKarFile(karFile,karFilePath, workflowName, workflowLSID, repository.getName());
      
      }
      else
      {
        remoteKarFileLSID = karFile.getLSID().toString();
        boolean hasReportLayout = true;// we don't warn user again
        // success upload and we have the remote kar file at hand.
        selectRemoteWorkflow(workflowName, workflowLSID, 
            repository.getName(), remoteKarFileLSID, hasReportLayout);
      }   
    }
    else
    {
      boolean hasReportLayout = true;// we don't warn user again
      // success upload and we have the remote kar file at hand.
      selectRemoteWorkflow(workflowName, workflowLSID, 
          repository.getName(), remoteKarFileLSID, hasReportLayout);
    } 
  }
  
  /*
   * Get the remote kar lsid for the local workflow kar file from LocalRemoteWorkflowController
   * If null returned, this means the local kar file has not been uploaded to the 
   * remote repository
   */
  private String getRemoteKarLSIDFromLocalRemoteWorkflowController(String localKarFilePath, String repositoryName)
  {
    String remoteKarLSID = null;
    //first to see if the local-remote controller has the copy. This is memory checking.
    LocalRemoteWorkflowMap map = LocalRemoteWorkflowMappingController.getMap(localKarFilePath, repositoryName);
    if(map != null)
    {
      remoteKarLSID = map.getRemoteKarLSID();
    }
    //System.out.println("=========== get kar lisd from the controller "+remoteKarLSID);
    return remoteKarLSID;
  }
  
  /*
   * Test if the kar lsid is already registered in the saving repository
   */
  private boolean isAlreadyRegistered(KeplerLSID lsid, Repository saveRepository) 
  {
    boolean registered = false;
    try
    {
    IdentifierServiceClient identificationClient = new IdentifierServiceClient(
        saveRepository.getLSIDServerURL());
    registered = identificationClient.isRegistered(lsid.toString());
    }
    catch(Exception e)
    {
      log.warn("Couldn't determine if the kar lsid has been registered in the remote repository - "+e.getMessage());
    }
    //System.out.println("=========== is already register for the lisd  "+lsid.toString()+ " "+registered);
    return registered;
  }
  
  /*
   * Get KARFile object from the karFilePath. null will be returned if kepler
   * can't create KARFile.
   */
  private KARFile getKarFile(String karFilePath)
  {   
    KARFile karFile = null; 
    try
    {
      karFile = new KARFile(new File(karFilePath));
    }
    catch(Exception e)
    {
      JOptionPane.showMessageDialog(parent,  
          "Kepler couldn't create kar file for path "+karFilePath+
          " - "+e.getMessage(),"Error" , JOptionPane.ERROR_MESSAGE);
      
    }
    return karFile;
  }
  
  /*
   * Upload the kar file and kar xml to remote repository. 
   * The lisd of kar file will be returned. If uploading failed, null will be returned.
   */
  private void uploadKarFile( KARFile karFile,String karFilePath, 
      String workflowName, String workflowLSID, String repositoryName)
  {
    UploadingKARFileSwingWorker worker = new UploadingKARFileSwingWorker(karFile,  karFilePath, 
        workflowName, workflowLSID, repositoryName, scheduleChangeController, parent);
    worker.execute();
  }
  
  /**
   * SearchSchedulesListenerInterface calls back this method.
   * It will update the gui.
   */
  public void complete()
  {
    this.repaint();
    this.validate();
    trackSelectRemoteWorkflow.pop();
    if(scheduleChangeController != null)
    {
      scheduleChangeController.stopProgressBar();
    }
    
    //System.out.println("search is done");
  }
  
  /**
   * Call back method when the uploading is done. 
   * It will put the kar file lsid into a map. Then select the remote copy of the kar file to
   * scheduler gui.
   * @param KARFileLSID the lisd of the uploaded kar file
   * @param KARFilePath the path of the local kar file
   * @param workflowName the name of the workflow 
   * @param workflowLSID the lsid of the workflow
   * @param repositoryName the name of the remote repository
   */
  public void completeUploading(String KARFileLSID, String KARFilePath, String workflowName, 
      String workflowLSID, String repositoryName)
  {
    if(scheduleChangeController != null)
    {
      scheduleChangeController.stopProgressBar();
    }
    if(KARFileLSID != null)
    {
      LocalRemoteWorkflowMap map = new LocalRemoteWorkflowMap(KARFilePath, 
          workflowLSID, workflowName, KARFileLSID, repositoryName);
      LocalRemoteWorkflowMappingController.add(map);
      boolean hasReportLayout = true;// we don't warn user again
      // success upload and we have the remote kar file at hand.
      selectRemoteWorkflow(workflowName, workflowLSID, 
          repositoryName, KARFileLSID, hasReportLayout);
    }
    else
    {
      JOptionPane.showMessageDialog(parent,  
          "Failed to upload kar file to the repository.","Error" , JOptionPane.ERROR_MESSAGE);
    }
   
    
  }
  
  /**
   * Method for ScheduleChangeListener. Do nothing.
   * Handle the event that a new schedule is added
   * @param schedule  the new schedule
   * @throws Exception
   */
  public void addSchedule(Schedule schedule) throws Exception
  {
    
  }
  
  /**
   * Method for ScheduleChangeListener. Do nothing.
   * Handle the event that a schedule is removed
   * @param schedule the schedule will be removed
   * @throws Exception
   */
  public void removeSchedule(Schedule schedule) throws Exception
  {
    
  }
  
  /**
   * Method for ScheduleChangeListener. Do nothing.
   * Handle the event that a schedule will be enabled
   * @param schedule the schedule will be enabled
   * @throws Exception
   */
  public void enableSchedule(Schedule schedule) throws Exception
  {
    
  }
  
  /**
   * Method for ScheduleChangeListener. Do nothing.
   * Handle the event that a schedule will be disabled
   * @param schedule the schedule will be disabled
   * @throws Exception
   */
  public void disableSchedule(Schedule schedule) throws Exception
  {
    
  }
  
  /**
   * Method for ScheduleChangeListener. Do nothing.
   * Handle the event that new schedules will replace the old ones
   * @param newSchedule new schedules
   * @throws Exception
   */
  public void update(Schedule[] newSchedules) throws Exception
  {
    
  }
  
  /**
   * Action for  selecting a non remote workflow on component search panel
   */
  public void selectNonSchedulalbeItem()
  {
    if(previousSelectionIsWorkflow.get() == true)
    {
      this.removeAll();
      initialize();
      this.repaint();
      this.validate();
      previousSelectionIsWorkflow.set(false);
    }
     
   
  }
  
  /**
   * Gets the status of selecting workflow being done 
   * @return true if the selecting is done
   */
  public boolean isSelectingRemoteWorkflowDone()
  {
    return trackSelectRemoteWorkflow.isEmpty();
  }

}