/*                                                                                                       
 * GCalHelper                                                                                  
 *                                                                                                       
 * Version 1.0                                                                                           
 *                                                                                                       
 * 20070325                                                                                              
 *                                                                                                       
 * Author: Jenny Nordgren                                                                                
 */

/**                                                                                                      
 * GCalHelper is a small helper app for Google Calendar. It lets you add qucik-add events to a list 
 * when you are offline, and then batch upload them to your calendar once you are online again.                                                                                
 *                                                                                                       
 */

import javax.swing.*;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.net.*;
import java.io.*;
import com.google.gdata.client.*;
import com.google.gdata.client.calendar.*;
import com.google.gdata.data.*;
import com.google.gdata.data.calendar.*;
import com.google.gdata.data.extensions.*;
import com.google.gdata.util.*;
import java.net.URL;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.Date;
import java.util.Calendar;


public class GCalHelper extends JFrame implements ActionListener {
    
    private JTextField addEventField = new JTextField(15);
    private JLabel messageLabel = new JLabel("Example quick add: Breakfast at Tiffany's 21/4 12.00");
    private Container con;
    
    private ArrayListModel<CalendarEventEntry> events;
	private JList eventJList;
    private ArrayList<CalendarEventEntry> uploadedEvents = new ArrayList<CalendarEventEntry>();
    
    private String username = "";
	private String password = "";
	
/**
* This constructor creates a data model for calendar events, and a GUI to display and interact with this data and upload it to Google Calendar through the gdata API.
*For more information about Google API's and the client libraries avaliable, see     http://code.google.com/apis/gdata/client-java.html 
*/


    public GCalHelper() {
	
	//Data model
    events = new ArrayListModel<CalendarEventEntry>();

    //View of data model
    eventJList = new JList(events);
    eventJList.setCellRenderer(new EventCellRenderer());

	
	//Creating the GUI
	con = getContentPane();
	con.setLayout(new BorderLayout());
	
	this.setTitle("GCalHelper");

    //Bottom panel items		
	JButton addEventButton = new JButton("Add");
	JButton updateButton = new JButton("Update");

	updateButton.addActionListener(this);
	addEventButton.addActionListener(this);
	
	JLabel addEventFieldLabel = new JLabel("Quick Add: ");
	
	addEventField.addActionListener(this);
	addEventField.setEditable(true);

	JPanel bottomPanel = new JPanel(new FlowLayout());
	
	JButton clearButton = new JButton("Clear Selected");
	clearButton.addActionListener(this);
	
	bottomPanel.add(addEventFieldLabel);
	bottomPanel.add(addEventField);
	bottomPanel.add(addEventButton);
	bottomPanel.add(updateButton);
	bottomPanel.add(clearButton);

    //Center pane
	JScrollPane scroller2 = new JScrollPane(eventJList);

    //Message area
    messageLabel.setOpaque(true);
    messageLabel.setBackground(new Color(237, 243, 255));
	
	//Putting it all together	
	con.add(messageLabel, BorderLayout.NORTH);	
	con.add(scroller2, BorderLayout.CENTER);
	con.add(bottomPanel, BorderLayout.SOUTH);

	setDefaultCloseOperation(EXIT_ON_CLOSE);
	setSize(600, 300);
	setVisible(true);
    }
    
    /**
    * This is the implementation of the ActionListener interface. Based on the String on
    * the button pressed, it handles three events: Update - which uploads existing events
    * to a Google Calendar account, Clear Selected which removes selected events, and 
    *Quick Add that adds a new event to the list.   
    */
    
    
    public void actionPerformed(ActionEvent e) {
	
	if(e.getActionCommand().equalsIgnoreCase("Update")) {
	    try {
	       if(!events.isEmpty()) {
	           PasswordDialog p = new PasswordDialog(this);
	           if(!password.equals("")) {p.setPass(password);}
	           if(!username.equals("")) {p.setName(username);}
	           if(p.showDialog()) {
		          CalendarDataHandler uploadThread = new CalendarDataHandler(this, events, p.getName(), p.getPass());
		          password = p.getPass();
		          username = p.getName();		
	           }
	       }
	    }
	    catch (Exception e1) { setMessageLabel("There was a problem uploading your events. Try again!"); }
	}
	else if(e.getActionCommand().equalsIgnoreCase("Clear Selected")) {

            if(eventJList.getSelectedIndices().length > 0) {
                ArrayList<CalendarEventEntry> removelist = new ArrayList<CalendarEventEntry>();
                int[] indexarray = eventJList.getSelectedIndices();
                for(int i = 0; i < indexarray.length; i++) {
                    removelist.add(events.get(indexarray[i]));
                }
                int count = 0;
                for (CalendarEventEntry event: removelist) {
                    events.remove(event);
                    count++;
                    if(uploadedEvents.contains(event)) {
                        uploadedEvents.remove(event);
                    }
                }
                setMessageLabel("Removed " + count + " events.");
            }
     }
	    
	else if(!("").equals(addEventField.getText())) {

	    CalendarEventEntry newEvent = new CalendarEventEntry();
	    PlainTextConstruct contents = new PlainTextConstruct(addEventField.getText());
	    newEvent.setContent(contents);
	    newEvent.setTitle(contents);
	    newEvent.setQuickAdd(true);
	    events.add(newEvent);
	    addEventField.setText("");
	}
	
}

    /**
    * This is a custom cell renderer for the JList displaying the event items. It grabs the event content and
    * sets a green icon for uploaded events.     
    */


private class EventCellRenderer extends DefaultListCellRenderer {
  
  private ImageIcon uploaded = new ImageIcon("img/greenball.gif");
  private ImageIcon notUploaded = new ImageIcon("img/whitesquare.gif");
  
  public Component getListCellRendererComponent(JList list,
                                                Object value,
                                                int index,
                                                boolean isSelected,
                                                boolean hasFocus) {
    JLabel label =
      (JLabel)super.getListCellRendererComponent(list,
                                                 value,
                                                 index,
                                                 isSelected,
                                                 hasFocus);
       if(value instanceof CalendarEventEntry) {
            CalendarEventEntry event = (CalendarEventEntry)value;
            String str = event.getTitle().getPlainText();
            label.setText(str);
            if(uploadedEvents.contains(event)) {
                label.setIcon(uploaded);
            }
            else {
                label.setIcon(notUploaded);
            }
        }
        return(label);
  }
}
        
    /**
    *  Callback method for the CalendarDataHandler thread to tell the data model and user which
    * events have been uploaded.
    */

    public void recordUploadedEvents(ArrayList<CalendarEventEntry> events) {
        for(CalendarEventEntry event: events) {        
            uploadedEvents.add(event);
            eventJList.repaint();
        }
        setMessageLabel("Succesfully uploaded " + events.size() + " events!");
    }
    
    /**
    * Sends a copy of the events that have already been uploaded to the CalendarDataHandler thread, so 
    * that is doesn't upload duplicates'        
    */

    public ArrayList<CalendarEventEntry> getUploadedEvents() {
        ArrayList<CalendarEventEntry> uploadedCopy = (ArrayList<CalendarEventEntry>)uploadedEvents.clone();
        return uploadedCopy;
    }
    
    /**
    *  Sets the status message label    
    */

    public void setMessageLabel(String message) {
        messageLabel.setVisible(true);
        messageLabel.setText(message);
    }
    
    /**
    * Main method, initializes GUI     
    */

    public static void main(String args[]) {
	GCalHelper window = new GCalHelper();	
    }
}