package net.stff.ical.beans;
   
   import java.util.Calendar;
   import java.util.Date;
   import java.util.Iterator;
   import java.util.LinkedList;
   import java.util.List;
   import java.util.TreeSet;
   import java.util.Vector;
  
  /***
   *  Stores calendar data for templating
   *
   *@author     buntekuh
   *@created    9. Juni 2003
   */
  public class CalendarDay{
  	public static String TODAY = "calToday";
  	public static String ANOTHERMONTH = "calanothermonth";
  	public static String THISMONTH = "calthismonth";
  	String type;
  	int day;
  	int countingDays;
  	List events;
  	List alldayEvents;
  	Calendar today;
  	protected Object[][] timetable;	//two dimensional array of int
  	protected int[] dimensions= new int[2];	//dimensions of timetable
  
  	public CalendarDay(){
  	}
  
  	public CalendarDay(String type, int day, int countingDays, Calendar today){
  		this.type = type;
  		this.day = day;
  		this.countingDays = countingDays;
  		this.today= IEvent.getStartOfDay(today.getTime());
  	}
  
      /***
       * @return Returns the today.
       */
      public Calendar getToday() {
          return today;
      }
      /***
       * @param today The today to set.
       */
      public void setToday(Calendar today) {
          this.today = today;
      }
  	public void setType(String type){
  		this.type = type;
  	}
  
  	public void setDay(int day){
  		this.day = day;
  	}
  
  	public void setEvents(List events){
  		this.events = events;
  	}
  	
      /***
       * @return Returns the alldayEvents.
       */
      public List getAlldayEvents() {
          return alldayEvents;
      }
      /***
       * @param alldayEvents The alldayEvents to set.
       */
      public void setAlldayEvents(List alldayEvents) {
          this.alldayEvents = alldayEvents;
      }
  	/***
  	 * Sorts the given events into a timetable.<br>
  	 * Please @see setSortedEvents() and @see scheduleEvents() for further information
  	 * @param events
  	 * @param start
  	 * @param iterations
  	 * @param resolution
  	 */
  	public void schedule(List events, Calendar start, int iterations, int resolution){
  	    setSortedEvents(events);
  	    scheduleEvents(start, iterations, resolution);
  	}
  	/***
  	 * This methods adds and sorts the supplied events into a list which in turn contains other lists.<br> 
  	 * A single list will contain events sorted chronologically. If two or more events collide, the additional events are moved to second or nth list.
  	 * @param events The events to add and sort
  	 */
  	private void setSortedEvents(List events){
  		this.events= new Vector(); 
  	    TreeSet set= new TreeSet(events);
  	    
  	    Calendar cal= IEvent.getStartOfDay(new Date());
  	    Calendar thisCal= (Calendar)cal.clone();
  	    
 	    Iterator i= set.iterator();
 	    while (i.hasNext()){
 	        IEvent e= (IEvent)i.next();
 	        cal.set(Calendar.HOUR_OF_DAY, e.getStartHour());
 	        cal.set(Calendar.MINUTE, e.getStartMinute());
 	        
 	        Iterator ei= this.events.iterator();
 	        boolean added= false;
 	        while (ei.hasNext()){
 	            LinkedList l= (LinkedList)ei.next();
 	            IEvent thisEvent= (IEvent)l.getLast();
 	            thisCal.set(Calendar.HOUR_OF_DAY, thisEvent.getEndHour());
 	            thisCal.set(Calendar.MINUTE, thisEvent.getEndMinute());
 	            
 	            //System.out.println(thisEvent.getDtend()+"...."+e.getDtstart());
 	            if (thisCal.getTime().before(cal.getTime())){
 	                l.add(e);
 	                added= true;
 	                break;
 	            }
 	        }
 	        if (!added){
 	            List l= new LinkedList();
 	            l.add(e);
 	            this.events.add(l);
 	        }
 	        
 	    }
 	    /*
 	    Iterator ii= this.events.iterator();
 	    while (ii.hasNext()){
 	        LinkedList l= (LinkedList)ii.next();
 		    Iterator iii= l.iterator();
 		    while (iii.hasNext()){
 		        IEvent e= (IEvent)iii.next();
 		        System.out.println(e.getSummary()+" start: "+e.getDtstartString()+" end: "+e.getDtendString());
 		    }
 		    System.out.println("next list");
 	    }
 		*/
 	}
 	
 	/***
 	 * This method will sort the events into a 2 dimensional integer array. Each row represents a time period. 
 	 * If an Event takes place at that time it will be added anywhere on this row. 
 	 * only valid after calling setSortedEvents(). 
 	 * @param start The Hour and Minute the first period shall start.
 	 * @param iterations The number of periods to iterate over.
 	 * @param resolution the time in Minutes the period should last.
 	 */
 	private void scheduleEvents(Calendar s, int iterations, int resolution){
 	    
 	    if ((events == null) || (events.size() == 0)) return;
 	    dimensions[0]= iterations;
 	    dimensions[1]= events.size();
 	    timetable= new Object[iterations][events.size()];
 
 	    Calendar es= Calendar.getInstance();
 	    Calendar ee= Calendar.getInstance();
 	    s.setLenient(true);
 
 	    //s.add(Calendar.MILLISECOND, -1);
 	    Calendar e= (Calendar)s.clone();
 	    e.add(Calendar.MINUTE, resolution);
 	    
 	    for(int n=0;n<iterations;n++){
 	        
 	        for(int m=0;m<events.size();m++){
 	            LinkedList column= (LinkedList)events.get(m);
 	            if (column.size() == 0) continue;
 	            IEvent ev= (IEvent)column.getFirst();
 	            es.setTime(ev.getDtstart());
 	            es.set(Calendar.DATE, s.get(Calendar.DATE));
 	            es.set(Calendar.MONTH, s.get(Calendar.MONTH));
 	            es.set(Calendar.YEAR, s.get(Calendar.YEAR));
 	            es.add(Calendar.MILLISECOND, 1); //to prevent an equal, the event starts a millisecond later
 
 	            ee.setTime(ev.getDtend());
 	            ee.set(Calendar.DATE, s.get(Calendar.DATE));
 	            ee.set(Calendar.MONTH, s.get(Calendar.MONTH));
 	            ee.set(Calendar.YEAR, s.get(Calendar.YEAR));
 	            ee.add(Calendar.MILLISECOND, -1);
 	            
 	            //System.out.println("Event start:"+es.getTime()+"; end:"+ee.getTime());
 	            //System.out.println("      start:"+s.getTime()+"; end:"+e.getTime());
 	            
 	            if (ev.getDuration() == 0){
 	                //not yet started
 	                if ((es.getTime().after(s.getTime())) && (es.getTime().before(e.getTime()))){
 		                //start now
 		                //System.out.println("start now...");
 		                timetable[n][m]= ev;
 		                ev.endure();
 		                if (ee.getTime().before(e.getTime())){
 		                    //event might start and end at the same time;
 		                    column.removeFirst();
 		                }
 	                }
 	                else{
 	                    timetable[n][m]= null;
 	                    //System.out.println("null");
 	                }
 	            }
 	            else {
 	                //started already
 	                if (ee.getTime().after(e.getTime())){
 		        		//persist
 		                //System.out.println("...persist...");
 		        	    timetable[n][m]= "persist";
 		        	    ev.endure();
 	                }
 	                else{
 		        		//end now
 		                //System.out.println("...end now");
 		        	    timetable[n][m]= "persist";
 	        	        ev.endure();
 		        		column.removeFirst();
 	                }
 	            }	            	            
 	        }
 		    s.add(Calendar.MINUTE, resolution);
 		    e.add(Calendar.MINUTE, resolution);	        
 	    }
 	}
 	
 	public void addEvent(VEvent event){
 	    events.add(event);
 	}
 
 	public String getType(){
 		return type;
 	}
 
 	public int getDay(){
 		return day;
 	}
 
 	public void setCountingDays(int countingDays){
 		this.countingDays = countingDays;
 	}
 	
 	public int getSize(){
 	    if (events == null) return -1;
 	    return events.size();
 	}
 
 	public int getAlldaySize(){
 	    if (alldayEvents == null) return -1;
 	    return alldayEvents.size();
 	}
 	public int getCountingDays(){
 		return countingDays;
 	}
 
 	public List getEvents(){
 		return events;
 	}
 	
 	
 	private class Persist extends Vector{
 		
 		public boolean persists(Date d){
 			IEvent ev= (IEvent)this.get(this.size()-1);
 			if ((ev.dtstart.before(d)) && (ev.dtend.after(d))) return true;
 			return false;
 		}
 	}
     /***
      * @return Returns the timetable.
      */
     public Object[][] getTimetable() {
         return timetable;
     }
     /***
      * @return Returns the dimensions.
      */
     public int[] getDimensions() {
         return dimensions;
     }
 }