package siouxsie.desktop.commands.impl;
   
   import java.net.MalformedURLException;
   import java.net.URL;
   import java.util.ArrayList;
   import java.util.Collection;
   import java.util.HashMap;
   import java.util.HashSet;
   import java.util.LinkedHashMap;
  import java.util.List;
  import java.util.Map;
  import java.util.Set;
  
  import javax.swing.Icon;
  import javax.swing.ImageIcon;
  import javax.swing.JMenuBar;
  import javax.swing.JToolBar;
  import javax.swing.KeyStroke;
  
  import org.apache.commons.logging.Log;
  import org.apache.commons.logging.LogFactory;
  import org.pietschy.command.ActionCommand;
  import org.pietschy.command.Command;
  import org.pietschy.command.CommandGroup;
  import org.pietschy.command.CommandManager;
  
  import siouxsie.desktop.commands.CommandDescription;
  import siouxsie.desktop.commands.Face;
  import siouxsie.desktop.commands.Group;
  import siouxsie.desktop.commands.ICommand;
  import siouxsie.desktop.commands.ICommandInitializer;
  import siouxsie.desktop.commands.IExceptionHandler;
  import siouxsie.desktop.commands.IToggleCommand;
  
  /**
   * Commands handler. Creates menu bar and tool bar for
   * applications.
   * @author Arnaud Cogoluegnes
   * @version $Id$
   * @todo reimplement this basic implementation
   * @todo handle exclusive toggle command (not very important)
   * @todo handle sub menu (done, not good without ordering and presentation)
   */
  public class CommandsHandler {
  	
  	/** name for default menu and tool bar */
  	private static final String DEFAULT_APP = "_siouxsie_default_app";
  
  	/** faces configuration */
  	private List<Face> faces;
  	/** groups configuration */
  	private List<Group> groups;
  	/** commands configuration */
  	private List<CommandDescription> commandDescriptions;
  	
  	/** gui command manager listener */
  	private List<CommandManagerListenerContribution> commandManagerListeners = new ArrayList<CommandManagerListenerContribution>();
  	
  	private Map<String, ActionCommand> idToCommand = new LinkedHashMap<String, ActionCommand>();
  	
  	/** the apps (from the app command) */
  	private Set<String> apps = new HashSet<String>();
  	
  	private IExceptionHandler exceptionHandler;
  	
  	private CommandManager commandManager;
  	
  	private Map<String, JMenuBar> appsMenuBars = new HashMap<String, JMenuBar>();
  	
  	private Map<String, JToolBar> appsToolBars = new HashMap<String, JToolBar>();
  	
  	private Map<String, ICommand> siouxsieCommands = new HashMap<String, ICommand>();
  	
  	private static final Log LOG = LogFactory.getLog(CommandsHandler.class);
  	
  	private ICommandInitializer commandInitializerService;
  	
  	private static final String FACE_SEP_BEFORE_KEY = CommandsHandler.class.getName()+"_face_sep_before";
  	private static final String FACE_SEP_AFTER_KEY = CommandsHandler.class.getName()+"_face_sep_after";
  	
  	public ICommandInitializer getCommandInitializerService() {
  		return commandInitializerService;
  	}
  
  	public void setCommandInitializerService(
  			ICommandInitializer commandInitializerService) {
  		this.commandInitializerService = commandInitializerService;
  	}
  
  	public List<Face> getFaces() {
  		return faces;
  	}
  
  	public void setFaces(List<Face> faces) {
  		this.faces = faces;
  	}
  
  	public void init() {
  		
 		// gui command manager init
 		commandManager = new CommandManager();		
 		// add the listeners
 		for(CommandManagerListenerContribution contrib : commandManagerListeners) {
 			if(contrib.getHoverListener() != null) {
 				commandManager.addHoverListener(contrib.getHoverListener());
 			}
 			if(contrib.getManagerListener() != null) {
 				commandManager.addCommandManagerListener(contrib.getManagerListener());
 			}
 		}
 		
 		CommandFactory commandFactory = new CommandFactory();
 		for(CommandDescription desc : commandDescriptions) {
 			// command initialisation and wrapping
 			ISiouxsieCommand command = commandFactory.createCommand(desc);
 			
 			// the exception handler for the wrapper
 			command.setExceptionHandler(getExceptionHandler());					
 			// initializes the command
 			getCommandInitializerService().initialize(command.getCommand());			
 			
 			if(desc.getAppId() != null) {
 				apps.add(desc.getAppId());
 			}			
 			siouxsieCommands.put(desc.getId(),command.getCommand());			
 		}		
 		
 		Map<String, String> commandIdToGroup = new HashMap<String, String>();
 		
 		for(Face face : faces) {
 			
 			// retrieve the command
 			ActionCommand command = getCommand(face.getCommandId());
 			if(command == null) {
 				LOG.warn("Cannot retrieve command "+face.getCommandId()+" from one of its faces.");
 			}
 			org.pietschy.command.Face faceImpl = null;
 			if(face.getName() != null) {
 				faceImpl = command.getFace(face.getName(), true);
 			} else {
 				faceImpl = command.getDefaultFace(true);
 			}
 			
 			faceImpl.setText(face.getText());
 			faceImpl.setDescription(face.getDescription());
 			faceImpl.setLongDescription(face.getLongDescription());
 			if(face.getIconPath() != null) {
 				faceImpl.setIcon(createIcon(face.getIconType(),face.getIconPath()));
 			}	
 			
 			if(face.getGroupId() != null) {
 				commandIdToGroup.put(face.getCommandId(), face.getGroupId());
 			}		
 			if(face.getAccelerator() != null) {
 				faceImpl.setAccelerator(KeyStroke.getKeyStroke(face.getAccelerator()));
 			}
 			// handling separators
 			if(face.getSeparator() != null) {
 				if(face.isSeparatorOk()) {
 					if(face.separatorBefore()) {
 						faceImpl.putClientProperty(FACE_SEP_BEFORE_KEY, Boolean.TRUE.toString());
 					}
 					if(face.separatorAfter()) {
 						faceImpl.putClientProperty(FACE_SEP_AFTER_KEY, Boolean.TRUE.toString());
 					}
 				} else {
 					LOG.warn("incorrect separator syntax '"+face.getSeparator()+"' for face "
 							+face.getName()+" of action "+face.getCommandId()+
 							". Separator ignored.");
 					
 				}
 			}
 			
 		}		
 		
 		Map<String,ApplicationMenuBarContainer> appsMenuBar = new LinkedHashMap<String, ApplicationMenuBarContainer>();
 		Map<String, CommandGroup> appIdToToolBar = new LinkedHashMap<String,CommandGroup>();
 		// creates the group for each application
 		// add the default application
 		apps.add(DEFAULT_APP);
 		for(String app : apps) {
 			// menus for this application
 			ApplicationMenuBarContainer menuBarContainer = new ApplicationMenuBarContainer();
 			//appIdToMenuBar.put(app, menuBarContainer);
 			appsMenuBar.put(app, menuBarContainer);
 			
 			// 2 iterations, one for gathering all groups and another one for subgroups
 			// once the parents are initialized for sure			
 			for(Group group : groups) {					
 				LOG.info("processing group "+group.getId()+" for app "+app);
 				if(menuBarContainer.isMainMenu(group)) {	
 					LOG.info("group is a main group");	
 					menuBarContainer.addMainMenu(group, app+"."+group.getId());
 				} else {
 					menuBarContainer.addMenu(group, app+"."+group.getId());
 				}
 			}
 			
 			for(Group group : groups) {
 				boolean isMainMenu = menuBarContainer.isMainMenu(group.getId());
 				LOG.info("is "+group.getId()+" main menu? "+isMainMenu);
 				if(!isMainMenu) {
 					// not a root/main group
 					CommandGroup parent = menuBarContainer.getMenu(group.getGroupId());
 					if(parent == null) {
 						LOG.warn("cannot retrieve parent group "+group.getGroupId()+" for group "+group.getId());
 						LOG.warn("subgroup ignored");
 					} else {
 						parent.add(menuBarContainer.getMenu(group.getId()));
 					}
 				}				
 			}	
 			// creates app  toolbar
 			CommandGroup groupToolBar = new CommandGroup(commandManager,app+"."+org.pietschy.command.Face.TOOLBAR);
 			// GUI commands bug? indeed, need to create the "toolbar" face
 			groupToolBar.getFace(org.pietschy.command.Face.TOOLBAR,true);
 			appIdToToolBar.put(app, groupToolBar);			
 		}		
 		
 		// adding the command to each app menu bar and toolbar
 		for(CommandDescription desc : commandDescriptions) {			
 			
 			//Collection<Map<String,CommandGroup>> commandGroupList;
 			Collection<CommandGroup> toolBarList;
 			
 			Map<String,ApplicationMenuBarContainer> commandGroupList;
 			
 			// get the menu bars and tool bars we need the command to be added to
 			if(desc.getAppId() == null) {
 				// command for all applications
 				commandGroupList = appsMenuBar;
 				toolBarList = appIdToToolBar.values();
 			} else {
 				// application specific command
 				// menu bar
 				commandGroupList = new HashMap<String, ApplicationMenuBarContainer>();
 				commandGroupList.put(desc.getAppId(), appsMenuBar.get(desc.getAppId()));
 				// toolbar list
 				CommandGroup appToolBar = appIdToToolBar.get(desc.getAppId());
 				toolBarList = new ArrayList<CommandGroup>();
 				toolBarList.add(appToolBar);
 			}
 			
 			Command command = idToCommand.get(desc.getId());
 			
 			// menu bar
 			for(ApplicationMenuBarContainer container : commandGroupList.values()) {
 				String groupId = commandIdToGroup.get(desc.getId());
 				if(groupId != null) {
 					CommandGroup group = container.getMenu(groupId);
 					if(command.getDefaultFace().getClientProperty(FACE_SEP_BEFORE_KEY) != null) {
 						group.addSeparator();
 					}
 					group.add(command);
 					if(command.getDefaultFace().getClientProperty(FACE_SEP_AFTER_KEY) != null) {
 						group.addSeparator();
 					}
 				}
 			}
 			
 			// in the toolbar?			
 			if(command.faceExists(org.pietschy.command.Face.TOOLBAR)) {
 				for(CommandGroup group : toolBarList) {		
 					if(command.getFace(org.pietschy.command.Face.TOOLBAR).getClientProperty(FACE_SEP_BEFORE_KEY) != null) {
 						group.addSeparator();
 					}
 					group.add(command);
 					if(command.getFace(org.pietschy.command.Face.TOOLBAR).getClientProperty(FACE_SEP_AFTER_KEY) != null) {
 						group.addSeparator();
 					}
 				}
 			}		
 		}
 		
 		// construct the menu bar
 		for(String appId : appsMenuBar.keySet()) {
 			ApplicationMenuBarContainer container = appsMenuBar.get(appId);
 			CommandGroup menuBarGroup = new CommandGroup(commandManager,appId+".menubar");
 			for(CommandGroup group : container.mainMenus.values()) {
 				if(group.getMemberCount() > 0) {
 					menuBarGroup.add(group);
 				}
 			}
 			// sub group can be in parent but without action in it, must check that
 			// and remove the sub menu
 			for(Group group : container.groups.values()) {
 				if(!container.isMainMenu(group)) {
 					CommandGroup gImpl = container.getMenu(group.getId());
 					if(gImpl.getMemberCount() == 0) {
 						// retrieve the parent
 						CommandGroup parent = container.getMenu(group.getGroupId());
 						parent.remove(gImpl);
 					}
 				}
 			}
 			appsMenuBars.put(appId, menuBarGroup.createMenuBar());
 		}	
 		
 		for(String appId : appIdToToolBar.keySet()) {			
 			CommandGroup toolBarGroup = appIdToToolBar.get(appId);
 			appsToolBars.put(appId, toolBarGroup.createToolBar());			
 		}
 		
 		
 	}
 
 	public List<CommandDescription> getCommandDescriptions() {
 		return commandDescriptions;
 	}
 
 	public void setCommandDescriptions(List<CommandDescription> commandDescriptions) {
 		this.commandDescriptions = commandDescriptions;
 	}
 
 	public List<Group> getGroups() {
 		return groups;
 	}
 
 	public void setGroups(List<Group> groups) {
 		this.groups = groups;
 	}
 	
 	private Icon createIcon(String type,String path) {
 		Icon icon = null;
 		if("url".equals(type)) {
 			try {
 				icon = new ImageIcon(new URL(path));
 			} catch (MalformedURLException e) {
 				LOG.error("Could not load icon.",e);
 			}
 		} else if("classpath".equals(type)) {
 			icon = new ImageIcon(commandManager.getClassLoader().getResource(path));
 		} else if("file".equals(type)) {
 			icon = new ImageIcon(path);
 		}
 		return icon;
 	}
 	
 	/**
 	 * Return a command from its id.
 	 * @param commandId
 	 * @return
 	 */
 	public ActionCommand getCommand(String commandId) {
 		return idToCommand.get(commandId);
 	}
 	
 	public JMenuBar getAppMenuBar(String appId) {
 		JMenuBar bar = appsMenuBars.get(appId);
 		if(bar == null) {
 			bar = appsMenuBars.get(DEFAULT_APP);
 		}
 		return bar;
 	}
 	
 	public JToolBar getAppToolBar(String appId) {
 		JToolBar bar = appsToolBars.get(appId);
 		if(bar == null) {
 			bar = appsToolBars.get(DEFAULT_APP);
 		}
 		return bar;
 	}
 	
 	public ICommand getSiouxsieCommand(String id) {
 		return siouxsieCommands.get(id);
 	}
 
 	public List<CommandManagerListenerContribution> getCommandManagerListeners() {
 		return commandManagerListeners;
 	}
 
 	public void setCommandManagerListeners(
 			List<CommandManagerListenerContribution> commandManagerListeners) {
 		this.commandManagerListeners = commandManagerListeners;
 	}
 
 	public IExceptionHandler getExceptionHandler() {
 		return exceptionHandler;
 	}
 
 	public void setExceptionHandler(IExceptionHandler exceptionHandler) {
 		this.exceptionHandler = exceptionHandler;
 	}
 	
 	/**
 	 * Helper class for dealing with groups and sub groups.
 	 * @author Arnaud Cogoluegnes
 	 * @version $Id$
 	 */
 	class ApplicationMenuBarContainer {
 		
 		private Map<String,CommandGroup> mainMenus = new LinkedHashMap<String, CommandGroup>();
 		
 		private Map<String,CommandGroup> allMenus = new LinkedHashMap<String, CommandGroup>();
 		
 		private Map<String, Group> groups = new LinkedHashMap<String, Group>();
 		
 		public void addMainMenu(Group group, String guiCommandId) {
 			CommandGroup gImpl = constructCommandGroup(group, guiCommandId);			
 			mainMenus.put(group.getId(), gImpl);
 			groups.put(group.getId(), group);
 			allMenus.put(group.getId(), gImpl);
 		}
 		
 		public void addMenu(Group group, String guiCommandId) {
 			CommandGroup gImpl = constructCommandGroup(group, guiCommandId);
 			groups.put(group.getId(), group);
 			allMenus.put(group.getId(), gImpl);
 		}
 		
 		private CommandGroup constructCommandGroup(Group group, String guiCommandId ) {
 			CommandGroup groupImpl = new CommandGroup(commandManager,guiCommandId);			
 			org.pietschy.command.Face face = groupImpl.getDefaultFace(true);			
 			face.setText(group.getText());
 			face.setDescription(group.getDescription());
 			face.setLongDescription(group.getLongDescription());
 			if(group.getIconPath() != null) {
 				face.setIcon(createIcon(group.getIconType(),group.getIconPath()));
 			}			
 			return groupImpl;
 		}
 		
 		public CommandGroup getMenu(String id) {
 			return allMenus.get(id);
 		}
 		
 		public boolean isMainMenu(String id) {
 			Group group = groups.get(id);
 			return group != null && isMainMenu(group);
 		}
 		
 		public boolean isMainMenu(Group group) {
 			return group.getGroupId() == null || group.getGroupId().trim().length() == 0;
 		}
 		
 	}
 	
 	class CommandFactory {
 		
 		public ISiouxsieCommand createCommand(CommandDescription desc) {
 			// the command
 			ICommand command = null;
 			if(desc.getCommand() != null) {
 				command = desc.getCommand();
 			} else {
 				try {
 					command = desc.getCommandClass().newInstance();
 				} catch (InstantiationException e) {
 					LOG.error("Could not create command "+desc.getId(),e);
 				} catch (IllegalAccessException e) {
 					LOG.error("Could not create command "+desc.getId(),e);
 				}
 			}				
 			// wrap the command around
 			
 			// action or toggle command?
 			ISiouxsieCommand res = null;
 			if(command instanceof IToggleCommand) {
 				// toggle 
 				res = new SiouxsieToggleCommand(commandManager,desc.getId());
 				// stock the command
 				idToCommand.put(desc.getId(), (SiouxsieToggleCommand) res);	
 				((SiouxsieToggleCommand)res).setCommand((IToggleCommand)command);
 				if(desc.getAccelerator() != null) {
 					((SiouxsieToggleCommand)res).getDefaultFace(true).setAccelerator(
 							KeyStroke.getKeyStroke(desc.getAccelerator())
 					);
 				}
 			} else {
 				// action
 				res = new SiouxsieActionCommand(commandManager,desc.getId());	
 				// stock the command
 				idToCommand.put(desc.getId(), (SiouxsieActionCommand) res);	
 				((SiouxsieActionCommand)res).setCommand(command);	
 				if(desc.getAccelerator() != null) {
 					((SiouxsieActionCommand)res).getDefaultFace(true).setAccelerator(
 							KeyStroke.getKeyStroke(desc.getAccelerator())
 					);
 				}
 			}				
 			return res;
 		}
 		
 	}
 	
 }