/*
    * Copyright (c) 2003-2008 by Cosylab d. d.
    *
    * This file is part of Java-Common.
    *
    * Java-Common is free software: you can redistribute it and/or modify
    * it under the terms of the GNU General Public License as published by
    * the Free Software Foundation, either version 3 of the License, or
    * (at your option) any later version.
   *
   * Java-Common is distributed in the hope that it will be useful,
   * but WITHOUT ANY WARRANTY; without even the implied warranty of
   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   * GNU General Public License for more details.
   *
   * You should have received a copy of the GNU General Public License
   * along with Java-Common.  If not, see <http://www.gnu.org/licenses/>.
   */
  
  package com.cosylab.application.state.impl;
  
  import java.awt.Component;
  import java.awt.Container;
  import java.awt.Frame;
  import java.awt.Rectangle;
  import java.io.IOException;
  import java.util.ArrayList;
  import java.util.HashMap;
  import java.util.List;
  import java.util.StringTokenizer;
  
  import com.cosylab.application.state.State;
  import com.cosylab.application.state.StateFactory;
  import com.cosylab.application.state.StateKeeper;
  import com.cosylab.application.state.StateOriginator;
  import com.cosylab.application.state.StateStorage;
  
  
  /**
   * This class is an implementation of the <code>StateKeeper</code> interface
   * and stores application state by traversing through its AWT tree.
   * Each component in the tree which implements <code>StateOriginator</code>
   * is called to create a <code>State</code> object in the process of the
   * aplication state saving. The created <code>State</code> will be marked
   * with the full path to the component so later it can be delivered to it. 
   * <br/>
   * If the AWT hierarchy of the components at the time of restoring the state
   * is different than at the time of saving, the state keeper might not be able  
   * to deliver data to the <code>StateOriginator</code> these cases should be
   * handled separately inside the application.
   *
   * @author dvitas
   */
  public class AWTStateKeeper implements StateKeeper
  {
  	protected static final char pathSeparator = '/';
  	protected static final char indexSeparator = '#';
  	protected static final String tokenizerDelimiter = "" + pathSeparator
  		+ indexSeparator;
  	protected Container rootContainer = null;
  
  	/**
  		 *
  		 */
  	public AWTStateKeeper(Container rootContainer)
  	{
  		super();
  		this.rootContainer = rootContainer;
  	}
  
  	protected void fillState(Container container, String path, HashMap paths,
  	    HashMap indexes, List states)
  	{
  		path = path + pathSeparator + container.getClass().getName();
  
  		Integer index = (Integer)paths.get(path);
  
  		if(index == null) {
  			index = new Integer(0);
  		} else {
  			index = new Integer(index.intValue() + 1);
  		}
  
  		paths.put(path, index);
  		path = path + indexSeparator + index.intValue();
  
  		//System.out.println(">>> Querying '"+container.getName()+"' '"+path+"' '"+container+"'");
  		Component[] components = container.getComponents();
  		//System.out.println(">>> Component returned "+components.length);
  
  		for(int i = 0; i < components.length; i++) {
  			if(components[i] instanceof StateOriginator) {
  				StateOriginator so = (StateOriginator)components[i];
  				State s = so.getState();
  
  				if(s != null) {
  					String id = path + pathSeparator
  						+ components[i].getClass().getName();
  					index = (Integer)indexes.get(id);
 
 					if(index == null) {
 						index = new Integer(0);
 					} else {
 						index = new Integer(index.intValue() + 1);
 					}
 
 					indexes.put(id, index);
 					id = id + indexSeparator + index.intValue();
 					s.setID(id);
 					states.add(s);
 				}
 			}
 
 			if(components[i] instanceof Container) {
 				fillState((Container)components[i], path, paths, indexes, states);
 			}
 		}
 	}
 
 	protected Object getObject(Container container, String name, int index)
 	{
 		int hitCount = -1;
 		Component[] components = container.getComponents();
 
 		for(int i = 0; i < components.length; i++) {
 			if(components[i].getClass().getName().equals(name)) {
 				hitCount++;
 			}
 
 			if(hitCount == index) {
 				return components[i];
 			}
 		}
 
 		return null;
 	}
 
 	protected StateOriginator getOriginator(Container root, String ID)
 	{
 		StateOriginator originator = null;
 		int index;
 
 		StringTokenizer st = new StringTokenizer(ID, tokenizerDelimiter);
 		Container container = root;
 
 		// check if this tree belongs to us
 		if(st.hasMoreTokens()) {
 			if(!root.getClass().getName().equals(st.nextToken())) {
 				return null;
 			}
 
 			st.nextToken(); // skip index
 		}
 
 		Object object = null;
 
 		// go through the path to the component
 		while(st.hasMoreTokens()) {
 			String name = st.nextToken();
 			index = Integer.parseInt(st.nextToken());
 			object = getObject(container, name, index);
 
 			if(object == null) {
 				return null;
 			}
 
 			if(object instanceof Container) {
 				container = (Container)object;
 			}
 		}
 
 		if(!(object instanceof StateOriginator)) {
 			return null;
 		}
 
 		return (StateOriginator)object;
 	}
 
 	/* (non-Javadoc)
 	 * @see com.cosylab.application.state.StateKeeper#restore()
 	 */
 	public void restore(final String filePath, final String applicationName)
 		throws IOException
 	{
 		if(rootContainer == null )
 			throw new IOException("Unable to restore state. The rootContainer is null!");
 
 		StateStorage ss = StateFactory.createStateStorage(filePath,
 			    applicationName);
 		ss.load(filePath, applicationName);
 		List states = ss.getStates();
 		setStates(states);
 	}
 
 	protected void setStates(List states) {
 		// Do root first so that others get the right treatment
 		int extSt=Frame.NORMAL;
 		
 		State curState;
 		String ID;
 		for(int i = 0; i < states.size(); i++) {
 			curState=(State)states.get(i);
 			ID = curState.getID();
 
 			if(ID.equals("RootContainer")) {
 				Rectangle bounds = curState.getRectangle("Bounds");
 				rootContainer.setBounds(bounds);
 				
 				// Handle maximized state
 				if (rootContainer instanceof Frame) {
 					extSt=curState.getInt("extendedState",Frame.NORMAL);
                     ((Frame)rootContainer).setExtendedState(extSt);
                     ((Frame)rootContainer).validate();
                     ((Frame)rootContainer).doLayout();
 				}
 				states.remove(i);
 				break;
 			}
 		}
 
 		for(int i = 0; i < states.size(); i++) {
 			curState=(State)states.get(i);
 			ID = curState.getID();
 
 			StateOriginator originator = getOriginator(rootContainer, ID);
 
 			if(originator != null) {
 				originator.setState(curState);
 			} else {
 				// The path has changed (probably Smart Toolkit) - these originators should be handled separately
 				/*System.err.println("Unable to get the originator for path "
 					+ ID);*/
 			}
 		}
 	}
 	
 	protected List getStates() {
 		List states = new ArrayList();
 		// add a state for the rootContainer no matter if it is StateOriginator or not
 		State state = StateFactory.createState();
 		state.setID("RootContainer");
 		state.putRectangle("Bounds", rootContainer.getBounds());
 
 		// in these maps we will keep track of components of the same class in a container 
 		HashMap indexes = new HashMap();
 		HashMap paths = new HashMap();
 		fillState(rootContainer, "", paths, indexes, states);
         
         // Check extended state
         // MUST COME IN THE END TO HANDLE LAYOUT PROPERLY!!!
         if (rootContainer instanceof Frame) {
             int extSt=((Frame)rootContainer).getExtendedState();
             state.putInt("extendedState",extSt);
             if (extSt!=Frame.NORMAL) { //Get normal bounds
                 ((Frame)rootContainer).setExtendedState(Frame.NORMAL);
                 ((Frame)rootContainer).validate();
                 ((Frame)rootContainer).doLayout();
                 state.putRectangle("Bounds", rootContainer.getBounds());
             }
         }
         
         states.add(state);
 		return states;
 	}
 
 	/* (non-Javadoc)
 	 * @see com.cosylab.application.state.StateKeeper#save()
 	 */
 	public void save(final String filePath, final String applicationName)
 		throws IOException
 	{
 		if(rootContainer == null )
 			throw new IOException("Unable to save state. The rootContainer is null!");
 
 		StateStorage ss = StateFactory.createStateStorage();
 		ss.getStates().addAll(getStates());
 		ss.store(filePath, applicationName);
 	}
 	
 }
 
 /* __oOo__ */