/*
    *   Magic-Project is a turn based strategy simulator
    *   Copyright (C) 2003-2007 Fabrice Daugan
    *
    *   This program 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 2 of the License, or (at your option) any
    * later version.
    *
   *   This program 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 this program; if not, write to the Free Software Foundation, Inc., 
   * 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
   */
  package net.sf.magicproject;
  
  import java.awt.BorderLayout;
  import java.awt.Color;
  import java.awt.Component;
  import java.awt.Dimension;
  import java.awt.Paint;
  import java.awt.event.ActionEvent;
  import java.awt.event.InputEvent;
  import java.awt.event.KeyEvent;
  import java.awt.event.MouseEvent;
  import java.awt.event.WindowEvent;
  import java.io.FileInputStream;
  import java.io.IOException;
  import java.util.ArrayList;
  import java.util.Collection;
  import java.util.Collections;
  import java.util.HashMap;
  import java.util.List;
  import java.util.Map;
  import java.util.TreeMap;
  
  import javax.swing.BoxLayout;
  import javax.swing.JButton;
  import javax.swing.JDialog;
  import javax.swing.JFileChooser;
  import javax.swing.JFrame;
  import javax.swing.JLabel;
  import javax.swing.JList;
  import javax.swing.JMenu;
  import javax.swing.JMenuBar;
  import javax.swing.JMenuItem;
  import javax.swing.JOptionPane;
  import javax.swing.JPanel;
  import javax.swing.JScrollPane;
  import javax.swing.JSeparator;
  import javax.swing.JTabbedPane;
  import javax.swing.JTable;
  import javax.swing.JTextField;
  import javax.swing.JToggleButton;
  import javax.swing.JToolBar;
  import javax.swing.KeyStroke;
  import javax.swing.ListSelectionModel;
  import javax.swing.SwingConstants;
  import javax.swing.border.EtchedBorder;
  import javax.swing.event.ListSelectionEvent;
  import javax.swing.event.ListSelectionListener;
  import javax.swing.event.TableModelEvent;
  import javax.swing.event.TableModelListener;
  
  import net.sf.magicproject.chart.CardColor;
  import net.sf.magicproject.chart.CardManaCost;
  import net.sf.magicproject.chart.CardTypes;
  import net.sf.magicproject.chart.ChartFilter;
  import net.sf.magicproject.chart.ChartSets;
  import net.sf.magicproject.chart.IChartKey;
  import net.sf.magicproject.chart.IDataProvider;
  import net.sf.magicproject.chart.datasets.Dataset;
  import net.sf.magicproject.clickable.targetable.card.CardFactory;
  import net.sf.magicproject.clickable.targetable.card.CardModel;
  import net.sf.magicproject.clickable.targetable.card.MCard;
  import net.sf.magicproject.deckbuilder.CardView;
  import net.sf.magicproject.deckbuilder.ConstraintsChecker;
  import net.sf.magicproject.deckbuilder.Deck;
  import net.sf.magicproject.deckbuilder.DeckReader;
  import net.sf.magicproject.deckbuilder.DeckRules;
  import net.sf.magicproject.deckbuilder.MdbLoader;
  import net.sf.magicproject.token.IdCardColors;
  import net.sf.magicproject.token.IdCommonToken;
  import net.sf.magicproject.token.IdConst;
  import net.sf.magicproject.tools.Configuration;
  import net.sf.magicproject.tools.Converter;
  import net.sf.magicproject.tools.FileFilterPlus;
  import net.sf.magicproject.tools.MCardCompare;
  import net.sf.magicproject.tools.MSaveDeck;
  import net.sf.magicproject.tools.MToolKit;
  import net.sf.magicproject.tools.Picture;
  import net.sf.magicproject.ui.HireListener;
  import net.sf.magicproject.ui.MCardTableModel;
  import net.sf.magicproject.ui.MListModel;
  import net.sf.magicproject.ui.RefreshableAdd;
 import net.sf.magicproject.ui.UIHelper;
 import net.sf.magicproject.ui.i18n.LanguageManager;
 import net.sf.magicproject.ui.i18n.LanguageManagerMDB;
 import net.sf.magicproject.ui.wizard.About;
 
 import org.jfree.chart.ChartPanel;
 import org.jfree.chart.JFreeChart;
 
 /***
  * This class is a deck builder compatible with Magic-project deck format. Can
  * also export/import other formats.
  * 
  * @author <a href="mailto:fabdouglas@users.sourceforge.net">Fabrice Daugan </a>
  * @author <a href="mailto:goldeneyemdk@users.sourceforge.net">Sebastien Genete
  *         </a>
  * @author Jan Blaha for deck loader and statistics
  * @since 0.2 2003/12/06, settings are loaded.
  * @since 0.2 you can load a deck file.
  * @since 0.2 you can load a specified mdb file (is MagicProject card list
  *        file).
  * @since 0.3 2003/12/12, you can save a deck file.
  * @since 0.3 new deck feature.
  * @since 0.4 sort mdb file feature for optimized load.
  * @since 0.4 deck are saved with alphabitacally sort.
  * @since 0.5 statistics feature added.
  * @since 0.81 deck converter added.
  * @since 0.83 cleaned code, deck constraints form added.
  * @since 0.93 pie chart added, color filtering
  * @since 0.94 use of JTable instead of JList
  */
 public final class DeckBuilder extends AbstractMainForm implements
 		ListSelectionListener, RefreshableAdd, IDataProvider, TableModelListener {
 
 	/***
 	 * Creates new form DeckBuilder
 	 */
 	private DeckBuilder() {
 		super("DeckBuilder");
 		try {
 			setIconImage(Picture.loadImage(IdConst.IMAGES_DIR + "deckbuilder.gif"));
 		} catch (Exception e) {
 			// IGNORING
 		}
 
 		// Load settings
 		loadSettings();
 
 		// Init components
 		constraintsChecker = new ConstraintsChecker();
 		constraintsChecker.setBorder(new EtchedBorder());
 		final JScrollPane constraintsCheckerScroll = new JScrollPane(
 				constraintsChecker);
 		MToolKit.addOverlay(constraintsCheckerScroll);
 		constraintsCheckerScroll.setMinimumSize(new Dimension(200, 270));
 
 		final JMenuItem newItem = UIHelper.buildMenu("menu_db_new", 'n', this);
 		newItem.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_N,
 				InputEvent.CTRL_MASK));
 
 		final JMenuItem loadItem = UIHelper.buildMenu("menu_db_load", 'o', this);
 		loadItem.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_O,
 				InputEvent.CTRL_MASK));
 
 		final JMenuItem saveAsItem = UIHelper
 				.buildMenu("menu_db_saveas", 'a', this);
 		saveAsItem.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_F12, 0));
 
 		final JMenuItem saveItem = UIHelper.buildMenu("menu_db_save", 's', this);
 		saveItem.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_S,
 				InputEvent.CTRL_MASK));
 
 		final JMenuItem quitItem = UIHelper.buildMenu("menu_db_exit", this);
 		quitItem.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_F4,
 				InputEvent.ALT_MASK));
 
 		final JMenuItem deckConstraintsItem = UIHelper.buildMenu(
 				"menu_db_constraints", 'c', this);
 		deckConstraintsItem.setAccelerator(KeyStroke
 				.getKeyStroke(KeyEvent.VK_F3, 0));
 
 		final JMenuItem aboutItem = UIHelper
 				.buildMenu("menu_help_about", 'a', this);
 		aboutItem.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_F1,
 				InputEvent.SHIFT_MASK));
 
 		final JMenuItem convertDCK = UIHelper
 				.buildMenu("menu_convert_DCK_MP", this);
 
 		final JMenu mainMenu = UIHelper.buildMenu("menu_file");
 		mainMenu.add(newItem);
 		mainMenu.add(loadItem);
 		mainMenu.add(saveAsItem);
 		mainMenu.add(saveItem);
 		mainMenu.add(new JSeparator());
 		mainMenu.add(quitItem);
 
 		super.optionMenu = new JMenu("Options");
 
 		final JMenu convertMenu = UIHelper.buildMenu("menu_convert");
 		convertMenu.add(convertDCK);
 
 		final JMenuItem helpItem = UIHelper.buildMenu("menu_help_help", 'h', this);
 		helpItem.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_F1, 0));
 
 		final JMenu helpMenu = new JMenu("?");
 		helpMenu.add(helpItem);
 		helpMenu.add(deckConstraintsItem);
 		helpMenu.add(aboutItem);
 
 		final JMenuBar menuBar = new JMenuBar();
 		menuBar.add(mainMenu);
 		initAbstractMenu();
 		menuBar.add(optionMenu);
 		menuBar.add(convertMenu);
 		menuBar.add(helpMenu);
 		setJMenuBar(menuBar);
 		addWindowListener(this);
 
 		// Build the panel containing amount of available cards
 		JLabel amountLeft = new JLabel("<html>0/?", SwingConstants.RIGHT);
 
 		// Build the left list
 		allListModel = new MListModel<MCardCompare>(amountLeft, false);
 		leftList = new JList(allListModel);
 		leftList.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
 		leftList.setLayoutOrientation(JList.VERTICAL);
 		leftList.getSelectionModel().addListSelectionListener(this);
 		leftList.addMouseListener(this);
 		leftList.setVisibleRowCount(10);
 
 		// Init the texfield containing the amount to add
 		qtyTxt = new JTextField("1");
 		qtyTxt.setMaximumSize(new Dimension(20, 32010));
 		qtyTxt.setPreferredSize(new Dimension(20, 16));
 
 		// Build the "Add" button
 		addButton = new JButton(LanguageManager.getString("db_add"));
 		addButton.setMnemonic('a');
 
 		// Build the panel containing the selected card name
 		cardNameTxt = new JTextField();
 		new HireListener(cardNameTxt, addButton, this, leftList);
 
 		// Build the panel containing : "Add" amount, name and "Add" button
 		final JPanel addPanel = new JPanel(null);
 		addPanel.setLayout(new BoxLayout(addPanel, BoxLayout.X_AXIS));
 		addPanel.add(cardNameTxt);
 		addPanel.add(addButton);
 		addPanel.add(qtyTxt);
 		addPanel.setMaximumSize(new Dimension(32010, 26));
 
 		final JScrollPane listScrollerLeft = new JScrollPane(leftList);
 		MToolKit.addOverlay(listScrollerLeft);
 
 		// Build the left panel containing : list, available amount, "Add" panel
 		final JPanel srcPanel = new JPanel(null);
 		srcPanel.setLayout(new BoxLayout(srcPanel, BoxLayout.Y_AXIS));
 		srcPanel.add(listScrollerLeft);
 		srcPanel.add(amountLeft);
 		srcPanel.add(addPanel);
 		srcPanel.setMinimumSize(new Dimension(200, 0));
 
 		// Populate available cards and fill them into the left list
 		DeckReader.readAvailableCards(allListModel);
 
 		// build some Pie Charts and a panel to display it
 		initSets();
 		datasets = new ChartSets();
 		final int PREFERED_WIDTH = CardView.instance.getPreferredSize().width;
 		final JTabbedPane tabbedPane = new JTabbedPane();
 		tabbedPane.setPreferredSize(new Dimension(PREFERED_WIDTH, 300));
 		tabbedPane.setMinimumSize(tabbedPane.getPreferredSize());
 		tabbedPane.setMaximumSize(new Dimension(PREFERED_WIDTH, 32010));
 		for (ChartFilter filter : ChartFilter.values()) {
 			Dataset dataSet = filter.createDataSet(this);
 			final JFreeChart chart = new JFreeChart(null, null, filter.createPlot(
 					dataSet, painterMapper.get(filter)), false);
 			datasets.addDataSet(filter, dataSet);
 			ChartPanel pieChartPanel = new ChartPanel(chart, true);
 			tabbedPane.add(pieChartPanel, filter.getTitle());
 		}
 
 		cardPictureName = new JLabel("(no selected card)", SwingConstants.LEFT);
 
 		// The tollbar for color filtering
 		toolBar = new JToolBar();
 		final JButton clearButton = UIHelper.buildButton("clear");
 		clearButton.addActionListener(this);
 		toolBar.add(clearButton);
 		final JToggleButton toggleColorlessButton = new JToggleButton(UIHelper
 				.getTbsIcon("mana/colorless/small/" + MdbLoader.unknownSmlMana), true);
 		toggleColorlessButton.setActionCommand("0");
 		toggleColorlessButton.addActionListener(this);
 		toolBar.add(toggleColorlessButton);
 		for (int index = 1; index < IdCardColors.CARD_COLOR_NAMES.length; index++) {
 			final JToggleButton toggleButton = new JToggleButton(
 					UIHelper.getTbsIcon("mana/colored/small/"
 							+ MdbLoader.coloredSmlManas[index]), true);
 			toggleButton.setActionCommand(String.valueOf(index));
 			toggleButton.addActionListener(this);
 			toolBar.add(toggleButton);
 		}
 		getContentPane().add(toolBar, BorderLayout.NORTH);
 
 		// Build the panel containing amount of available cards
 		JLabel rightAmount = new JLabel("0/?", SwingConstants.RIGHT);
 
 		// Build the right list
 		rightListModel = new MCardTableModel(new MListModel<MCardCompare>(
 				rightAmount, true));
 		rightListModel.addTableModelListener(this);
 		rightList = new JTable(rightListModel);
 		rightList.setShowGrid(false);
 		rightList.setTableHeader(null);
 		rightList.getSelectionModel().addListSelectionListener(this);
 		rightList.getColumnModel().getColumn(1).setMaxWidth(25);
 		rightList.setSelectionMode(ListSelectionModel.SINGLE_INTERVAL_SELECTION);
 		rightList.setMinimumSize(new Dimension(200, 0));
 
 		// Build the right panel containing : list, available amount, constraints
 		final JScrollPane listScrollerRight = new JScrollPane(rightList);
 		MToolKit.addOverlay(listScrollerRight);
 		final JPanel destPanel = new JPanel();
 		destPanel.setLayout(new BoxLayout(destPanel, BoxLayout.Y_AXIS));
 		destPanel.add(listScrollerRight);
 		destPanel.add(constraintsCheckerScroll);
 		destPanel.add(rightAmount);
 
 		// Group the panels
 		final JPanel viewCard = new JPanel(null);
 		viewCard.add(cardPictureName);
 		viewCard.add(CardView.instance);
 		viewCard.add(tabbedPane);
 		viewCard.setLayout(new BoxLayout(viewCard, BoxLayout.Y_AXIS));
 
 		final JPanel mainPanel = new JPanel(null);
 		mainPanel.add(srcPanel);
 		mainPanel.add(viewCard);
 		mainPanel.add(destPanel);
 		mainPanel.setLayout(new BoxLayout(mainPanel, BoxLayout.X_AXIS));
 
 		// Add the main panel
 		getContentPane().add(mainPanel, BorderLayout.CENTER);
 
 		// Load the last deck file
 		if (Configuration.getString("decks.deck(0)", "").length() > 0) {
 			loadDeck(Configuration.getString("decks.deck(0)"), rightListModel
 					.getCards());
 		} else {
 			isNew = true;
 		}
 
 		// Size this frame
 		getRootPane().setPreferredSize(new Dimension(650, 700));
 		getRootPane().setMinimumSize(new Dimension(650, 700));
 		pack();
 	}
 
 	/***
 	 * @param string
 	 * @param deckListModel2
 	 * @param qtyListModel2
 	 * @param builder
 	 */
 	private void loadDeck(String fileName, MListModel<MCardCompare> names) {
 		// empty file name or deck?
 		if (fileName == null || fileName.length() == 0) {
 			return;
 		}
 
 		// Append the deck name
 		setTitle("DeckBuilder".concat(" : "
 				+ fileName.substring(fileName.lastIndexOf("/") + 1)));
 
 		names.clear();
 		datasets.removeAll();
 		try {
 			currentDeck = DeckReader.getDeck(this, fileName);
 			if (currentDeck == null) {
 				// Deck loading failure
 				return;
 			}
 
 			// Validate this deck
 			DeckReader.validateDeck(this, currentDeck, (String) null);
 
 			// Update the card models of resolved cards
 			final FileInputStream dbStream = MdbLoader.resetMdb();
 			for (MCardCompare cardCompare : currentDeck.getCards()) {
 				names.add(cardCompare);
 				dbStream.getChannel().position(cardCompare.getMdbOffset());
 				datasets.addCard(CardFactory.getCardModel(cardCompare.getName(),
 						dbStream), cardCompare.getAmount());
 			}
 			constraintsChecker.setDeck(currentDeck);
 			updateChecker();
 		} catch (IOException e) {
 			e.printStackTrace();
 		}
 	}
 
 	private void setCard(MCardCompare card) {
 		CardView.instance.setCard(card);
 		cardPictureName.setText(card.getName());
 	}
 
 	public void valueChanged(ListSelectionEvent e) {
 		if (!e.getValueIsAdjusting()) {
 			if (e.getSource() == leftList.getSelectionModel()) {
 				if (leftList.getSelectedIndex() == -1) {
 					// No selection, disable fire button.
 					addButton.setEnabled(false);
 				} else {
 					// Selection, enable the fire button.
 					addButton.setEnabled(true);
 					setCard((MCardCompare) leftList.getSelectedValue());
 					cardNameTxt.setText(cardPictureName.getText());
 				}
 			} else if (e.getSource() == rightList.getSelectionModel()) {
 				setCard(((MCardTableModel) rightList.getModel()).getCards()
 						.getElementAt(rightList.getSelectedRow()));
 			}
 		}
 	}
 
 	/***
 	 * Exit the Application
 	 */
 	private void exitForm() {
 		if (consoleMode) {
 			System.exit(0);
 		} else {
 			setVisible(false);
 		}
 	}
 
 	/***
 	 * Load the deckbuilder from the command line.
 	 * 
 	 * @param args
 	 *          the command line arguments
 	 */
 	public static void main(String[] args) {
 		consoleMode = true;
 		JFrame.setDefaultLookAndFeelDecorated(true);
 		JDialog.setDefaultLookAndFeelDecorated(true);
 		autoLoad();
 	}
 
 	/***
 	 * Load the deckbuilder from Magic class.
 	 */
 	public static void loadFromMagic() {
 		consoleMode = false;
 		autoLoad();
 	}
 
 	/***
 	 * Load the deckbuilder
 	 */
 	private static void autoLoad() {
 		if (deckbuilderForm != null) {
 			// previous instance is running
 			deckbuilderForm.setVisible(true);
 			return;
 		}
 		deckbuilderForm = new DeckBuilder();
 		deckbuilderForm.setLocation(
 				(deckbuilderForm.getToolkit().getScreenSize().width - 650) / 2,
 				(deckbuilderForm.getToolkit().getScreenSize().height - 700) / 2);
 
 		deckbuilderForm.setVisible(true);
 	}
 
 	public void refreshAddComponent(boolean unitary) {
 		String name = leftList.getSelectedValue().toString();
 		int qty = 1;
 		if (!unitary) {
 			try {
 				qty = Integer.parseInt(qtyTxt.getText());
 			} catch (Exception e1) {
 				JOptionPane.showMessageDialog(deckbuilderForm,
 						"Malformed integer for quantity", "Internal Error",
 						JOptionPane.ERROR_MESSAGE);
 				return;
 			}
 		}
 		// User didn't type in a unique name...
 		if (name.length() == 0) {
 			cardNameTxt.requestFocusInWindow();
 			return;
 		}
 
 		int index = rightListModel.getCards().indexOf(name);
 		final MCardCompare card;
 		if (index == -1) {
 			// no selection, so insert at beginning
 			int allIndex = allListModel.indexOf(name);
 			assert allIndex != -1;
 			card = allListModel.get(allIndex).clone();
 			card.add(qty);
 			currentDeck.addCard(card);
 			rightListModel.getCards().insertElementAt(card, 0);
 			rightListModel.fireTableRowsInserted(rightListModel.getCards().getSize(),
 					rightListModel.getCards().getSize());
 
 			// Reset the text field.
 			cardNameTxt.requestFocusInWindow();
 			cardNameTxt.setText("");
 		} else { // add after the selected item
 			card = rightListModel.getCards().elementAt(index);
 			card.add(qty);
 			rightListModel.fireTableCellUpdated(index, 1);
 		}
 
 		// Update the card models of resolved cards
 		final FileInputStream dbStream = MdbLoader.resetMdb();
 		datasets.addCard(getCardModel(name, dbStream), qty);
 
 		// deck list has been modifed
 		modifiedSinceSave = true;
 	}
 
 	/***
 	 * Update the checker and repaint the right list.
 	 */
 	private void updateChecker() {
 		constraintsChecker.updateCheckers();
 		rightList.repaint();
 	}
 
 	/***
 	 * Return the associated cardModel to the given real card name. The card is
 	 * searched in the inputstream starting from a given offset.
 	 * 
 	 * @param realCardName
 	 *          the card name as written in the mdb stream.
 	 * @param dbFile
 	 *          the fileinput stream of current mdb.
 	 * @return the corresponding CardModel instance, or null if the card has not
 	 *         been matched.
 	 */
 	private CardModel getCardModel(String realCardName, FileInputStream dbFile) {
 		try {
 			int index = allListModel.indexOf(realCardName);
 			MCardCompare card = allListModel.get(index);
 			dbFile.getChannel().position(card.getMdbOffset());
 			return CardFactory.getCardModel(realCardName, dbFile);
 		} catch (IOException e) {
 			return null;
 		}
 	}
 
 	/***
 	 * check if the current deck has been modified since it has been saved. If the
 	 * current deck has been modified, we ask to the user if he want to save it
 	 * before loading another.
 	 * 
 	 * @return true if the user has choosen to save the deck before contuning and
 	 *         if the save has success. False otherwise
 	 */
 	private boolean verifyModification() {
 		if (!modifiedSinceSave) {
 			// no modification since the last save
 			return true;
 		}
 
 		// ask to the user if we save the current deck before loading another
 		Object[] options = { "Ok", "No", "Cancel" };
 		switch (JOptionPane.showOptionDialog(deckbuilderForm,
 				"Current deck has been modified, save it before loading another?",
 				"Save changes", JOptionPane.YES_NO_CANCEL_OPTION,
 				JOptionPane.WARNING_MESSAGE, null, options, null)) {
 		case 0:
 			// YES part
 			return saveCurrentDeck();
 		case 1:
 			// NO part
 			return true;
 		default:
 			// CANCEL part
 			return false;
 		}
 	}
 
 	/***
 	 * Save the current deck. If the current deck has not been saved once, user
 	 * have to specify the file's name of this new deck
 	 * 
 	 * @return true if the current deck has been correctly saved. false otherwise.
 	 */
 	private boolean saveCurrentDeck() {
 		if (isNew || Configuration.getString("decks.deck(0)", "").length() == 0) {
 			if (MToolKit.getDeckFile(this, JFileChooser.SAVE_DIALOG) == null)
 				return false;
 		}
 		return MSaveDeck.saveDeck(Configuration.getString("decks.deck(0)"),
 				rightListModel.getCards(), deckbuilderForm);
 	}
 
 	/***
 	 * load the settings of jDecBuilder First byte is the Version Then :
 	 * 
 	 * @since 0.2 the mdb file
 	 * @since 0.2 the last deck file used
 	 * @since 0.7 the settings are read from .properties file
 	 */
 	private void loadSettings() {
 		// read the mdb file
 		if (consoleMode || MToolKit.tbsName == null) {
 			/*
 			 * The jDeckbuilder has not been launched from Magic form, or no TBS is
 			 * currently defined, we load the last used TBS.
 			 */
 			LanguageManager.initLanguageManager(Configuration.getString("language",
 					"auto"));
 			optionMenu = new JMenu(LanguageManager.getString("options"));
 			optionMenu.setMnemonic('o');
 			initAbstractMenu();
 			final String tbsName = Configuration.getString("lastTBS");
 			if (tbsName != null && tbsName.length() != 0) {
 				setMdb(tbsName);
 			}
 		}
 		// read the last used deck file
 	}
 
 	/***
 	 * Invoked when an action occurs.
 	 * 
 	 * @param e
 	 *          attached event
 	 */
 	public void actionPerformed(ActionEvent e) {
 		String command = e.getActionCommand();
 		if ("menu_help_about".equals(command)) {
 			new About(deckbuilderForm).setVisible(true);
 		} else if ("menu_db_exit".equals(command)) {
 			exitForm();
 		} else if ("menu_db_new".equals(command)) {
 			if (!verifyModification()) {
 				return;
 			}
 			setTitle("DeckBuilder");
 			rightListModel.getCards().clear();
 			datasets.removeAll();
 			modifiedSinceSave = false;
 			currentDeck.getCards().clear();
 			updateChecker();
 			isNew = true;
 		} else if ("menu_convert_DCK_MP".equals(command)) {
 			/*
 			 * Convert an entire directory from a format to MP one
 			 */
 			try {
 				Converter.convertDCK(MToolKit.showDialogFile(
 						"Choose a directory of DCK to convert", null, null, 'o', null,
 						FILTER_DECK, this, JFileChooser.OPEN_DIALOG,
 						JFileChooser.DIRECTORIES_ONLY).getCanonicalPath());
 			} catch (IOException e1) {
 				JOptionPane.showMessageDialog(this,
 						"Error occured reading the specified directory", "File problem",
 						JOptionPane.ERROR_MESSAGE);
 			} catch (Exception e1) {
 				// cancel of user;
 			}
 		} else if ("menu_db_constraints".equals(command)) {
 			// Show the deck constraints applied on the current TBS
 			new DeckRules(this).setVisible(true);
 		} else if ("menu_help_help".equals(command)) {
 			/*
 			 * This method is invoked when user has chosen to see the help file. <br>
 			 * TODO documentation is not yet done for this form
 			 */
 			JOptionPane.showMessageDialog(deckbuilderForm,
 					"Sorry, no documentation available for deck builder",
 					"Negative yet implemented", JOptionPane.INFORMATION_MESSAGE);
 		} else if ("menu_db_load".equals(command)) {
 			if (verifyModification()) {
 				String deckFile = MToolKit.getDeckFile(this, JFileChooser.OPEN_DIALOG);
 				if (deckFile != null) {
 					loadDeck(deckFile, rightListModel.getCards());
 					modifiedSinceSave = false;
 					isNew = false;
 				}
 			}
 		} else if ("menu_db_saveas".equals(command)) {
 			String deckFile = MToolKit.getDeckFile(this, JFileChooser.SAVE_DIALOG);
 			if (deckFile != null) {
 				MSaveDeck
 						.saveDeck(deckFile, rightListModel.getCards(), deckbuilderForm);
 				isNew = false;
 				modifiedSinceSave = false;
 			}
 		} else if ("menu_db_save".equals(command)) {
 			saveCurrentDeck();
 			isNew = false;
 			modifiedSinceSave = false;
 		} else {
 			final MListModel<MCardCompare> model = ((MListModel<MCardCompare>) leftList
 					.getModel());
 			if ("clear".equals(command)) {
 				// Reset the filters
 				for (Component component : toolBar.getComponents()) {
 					if (component instanceof JToggleButton) {
 						((JToggleButton) component).setSelected(true);
 					}
 				}
 				model.addAll(model.removedDelegate);
 			} else {
 				// Filter selection
 				final int colorIndex = Integer.valueOf(command);
 				if (colorIndex >= 0) {
 					// The filter color has been found, update the available cards
 					final FileInputStream dbStream = MdbLoader.resetMdb();
 					final JToggleButton colorButton = (JToggleButton) toolBar
 							.getComponent(colorIndex + 1);
 					if (colorButton.isSelected()) {
 						// "Add" mode
 						final List<MCardCompare> toAdd = new ArrayList<MCardCompare>();
 						for (MCardCompare cardCompare : model.removedDelegate) {
 							try {
 								dbStream.getChannel().position(cardCompare.getMdbOffset());
 								final CardModel cardModel = CardFactory.getCardModel(
 										cardCompare.getName(), dbStream);
 								if (colorIndex == 0) {
 									if (cardModel.getIdColor() == 0) {
 										toAdd.add(cardCompare);
 									}
 								} else if ((cardModel.getIdColor() & IdCardColors.CARD_COLOR_VALUES[colorIndex]) == IdCardColors.CARD_COLOR_VALUES[colorIndex]) {
 									toAdd.add(cardCompare);
 								}
 							} catch (IOException e1) {
 								e1.printStackTrace();
 							}
 						}
 						model.addAll(toAdd);
 					} else {
 						// "Remove" mode
 						final List<MCardCompare> toRemove = new ArrayList<MCardCompare>();
 						for (MCardCompare cardCompare : model.delegate) {
 							try {
 								dbStream.getChannel().position(cardCompare.getMdbOffset());
 								final CardModel cardModel = CardFactory.getCardModel(
 										cardCompare.getName(), dbStream);
 								if (colorIndex == 0) {
 									if (cardModel.getIdColor() == 0) {
 										toRemove.add(cardCompare);
 									}
 								} else if ((cardModel.getIdColor() & IdCardColors.CARD_COLOR_VALUES[colorIndex]) == IdCardColors.CARD_COLOR_VALUES[colorIndex]) {
 									toRemove.add(cardCompare);
 								}
 							} catch (IOException e1) {
 								e1.printStackTrace();
 							}
 						}
 						model.removeAll(toRemove);
 					}
 				}
 				leftList.repaint();
 			}
 		}
 	}
 
 	@Override
 	protected void setToolKitMdb(String tbsName) {
 		super.setToolKitMdb(tbsName);
 		DeckReader.readAvailableCards(allListModel);
 	}
 
 	public void mouseClicked(MouseEvent e) {
 		if (e.getSource() == leftList && e.getClickCount() == 2) {
 			refreshAddComponent(true);
 		} else if (e.getSource() == cardNameTxt) {
 			cardNameTxt.selectAll();
 		}
 	}
 
 	private static final FileFilterPlus FILTER_DECK = new FileFilterPlus("dck",
 			"DCK : Shandalar deck file");
 
 	private final MListModel<MCardCompare> allListModel;
 
 	private final MCardTableModel rightListModel;
 
 	private static boolean modifiedSinceSave = false;
 
 	private static DeckBuilder deckbuilderForm = null;
 
 	private final JButton addButton;
 
 	/***
 	 * The right list : cards in the deck.
 	 */
 	private final JTable rightList;
 
 	/***
 	 * The left list : available cards.
 	 */
 	private final JList leftList;
 
 	private final JTextField qtyTxt;
 
 	private final JTextField cardNameTxt;
 
 	/***
 	 * The label displayed above the card picture
 	 */
 	private final JLabel cardPictureName;
 
 	/***
 	 * indicates if jdeckbuilder was launched from console
 	 */
 	public static boolean consoleMode = false;
 
 	@Override
 	public void windowClosing(WindowEvent e) {
 		exitForm();
 	}
 
 	/***
 	 * Are we working with a new deck?
 	 */
 	private boolean isNew = false;
 
 	private final ChartSets datasets;
 
 	private Map<ChartFilter, Map<Integer, IChartKey>> keyMapper;
 
 	private Map<ChartFilter, Map<Integer, Paint>> painterMapper;
 
 	private void initSets() {
 		final Map<Integer, Paint> painterColorMapper = new TreeMap<Integer, Paint>();
 		for (int index = IdCardColors.CARD_COLOR_VALUES.length; index-- > 0;) {
 			painterColorMapper.put(IdCardColors.CARD_COLOR_VALUES[index],
 					IdCardColors.CARD_COLOR[index]);
 		}
 		painterColorMapper.put(ChartFilter.DEFAULT_KEY, Color.YELLOW.darker()
 				.darker());
 		painterMapper = new HashMap<ChartFilter, Map<Integer, Paint>>();
 		painterMapper.put(ChartFilter.color, painterColorMapper);
 
 		final Map<Integer, IChartKey> keyColorMapper = new TreeMap<Integer, IChartKey>();
 		for (int index = 0; index < IdCardColors.CARD_COLOR_VALUES.length; index++) {
 			keyColorMapper.put(IdCardColors.CARD_COLOR_VALUES[index], new CardColor(
 					LanguageManager.getString(IdCardColors.CARD_COLOR_NAMES[index]),
 					IdCardColors.CARD_COLOR_VALUES[index]));
 		}
 		keyColorMapper.put(ChartFilter.DEFAULT_KEY, CardColor.UNKNOW_COLOR);
 
 		final Map<Integer, IChartKey> keyTypeMapper = new TreeMap<Integer, IChartKey>();
 		for (int index = 0; index < CardFactory.exportedTypeNames.length; index++) {
 			keyTypeMapper.put(CardFactory.exportedTypeValues[index], new CardTypes(
 					LanguageManagerMDB.getString(CardFactory.exportedTypeNames[index]),
 					CardFactory.exportedTypeValues[index]));
 		}
 		keyTypeMapper.put(ChartFilter.DEFAULT_KEY, CardTypes.UNKNOW_TYPE);
 
 		keyMapper = new HashMap<ChartFilter, Map<Integer, IChartKey>>();
 		keyMapper.put(ChartFilter.color, keyColorMapper);
 		keyMapper.put(ChartFilter.type, keyTypeMapper);
 		keyMapper.put(ChartFilter.property, new TreeMap<Integer, IChartKey>());
 		keyMapper.put(ChartFilter.manacost, new TreeMap<Integer, IChartKey>());
 	}
 
 	private Map<Integer, IChartKey> getMapper(ChartFilter filter) {
 		return keyMapper.get(filter);
 	}
 
 	public List<IChartKey> getKeys(ChartFilter filter) {
 		List<IChartKey> list = new ArrayList<IChartKey>(getMapper(filter).values());
 		Collections.sort(list);
 		return list;
 	}
 
 	public Collection<IChartKey> getKeys(CardModel cardModel, ChartFilter filter) {
 		Collection<IChartKey> result = new ArrayList<IChartKey>();
 		switch (filter) {
 		case color:
 			int idColor = cardModel.getIdColor();
 			if (idColor == 0)
 				result.add(getMapper(filter).get(IdCardColors.CARD_COLOR_VALUES[0]));
 			else {
 				for (IChartKey value : getMapper(filter).values()) {
 					if (value.getIntegerKey() != 0
 							&& MCard.hasIdColor(idColor, value.getIntegerKey())) {
 						result.add(value);
 					}
 				}
 			}
 			break;
 		case type:
 			int idCard = cardModel.getIdCard();
 			for (IChartKey value : getMapper(filter).values()) {
 				if (MCard.hasIdCard(idCard, value.getIntegerKey()))
 					result.add(value);
 			}
 			break;
 		case manacost:
 			int total = 0;
 			for (int index = IdCommonToken.WHITE_MANA + 1; index-- > 0;) {
 				total += cardModel.getStaticRegisters()[index];
 			}
 			result.add(new CardManaCost(total));
 			break;
 		default:
 			// TODO add the the other filters
 		}
 		if (result.isEmpty()) {
 			IChartKey defaultKey = getMapper(filter).get(ChartFilter.DEFAULT_KEY);
 			if (defaultKey != null)
 				result.add(getMapper(filter).get(ChartFilter.DEFAULT_KEY));
 		}
 		return result;
 	}
 
 	public void tableChanged(TableModelEvent e) {
 		try {
 			MCardCompare card = rightListModel.getCards().get(e.getFirstRow());
 			if (card.getAmount() == 0) {
 				currentDeck.removeCard(card);
 			}
 		} catch (Throwable t) {
 			// IGNORE
 		}
 		updateChecker();
 	}
 
 	/***
 	 * The toolbar containg some filters.
 	 */
 	private final JToolBar toolBar;
 
 	private Deck currentDeck;
 
 	private final ConstraintsChecker constraintsChecker;
 
 }