/*

* Copyright (c) 2007 Nokia Corporation and/or its subsidiary(-ies). 

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of "Eclipse Public License v1.0"

* which accompanies this distribution, and is available

* at the URL "http://www.eclipse.org/legal/epl-v10.html".

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description:

*

*/ 

package com.nokia.s60tools.apiquery.cache.configuration;

import java.io.BufferedOutputStream;

import java.io.File;

import java.io.FileOutputStream;

import java.io.IOException;

import java.util.ArrayList;

import java.util.Collection;

import java.util.Iterator;

import java.util.LinkedHashMap;

import java.util.LinkedHashSet;

import java.util.Map;

import java.util.Set;

import java.util.Vector;

import org.eclipse.core.runtime.IProgressMonitor;

import com.nokia.s60tools.apiquery.cache.plugin.CachePlugin;

import com.nokia.s60tools.apiquery.cache.resources.Messages;

import com.nokia.s60tools.apiquery.shared.datatypes.APIDetailField;

import com.nokia.s60tools.apiquery.shared.datatypes.APIDetails;

import com.nokia.s60tools.apiquery.shared.datatypes.config.AbstractEntry;

import com.nokia.s60tools.apiquery.shared.datatypes.config.AbstractEntryStorage;

import com.nokia.s60tools.apiquery.shared.datatypes.config.DuplicateEntryException;

import com.nokia.s60tools.apiquery.shared.datatypes.config.EntryNotFoundException;

import com.nokia.s60tools.apiquery.shared.datatypes.config.IConfigurationChangedListener;

import com.nokia.s60tools.apiquery.shared.exceptions.XMLNotValidException;

import com.nokia.s60tools.apiquery.shared.job.JobCancelledByUserException;

import com.nokia.s60tools.apiquery.shared.util.console.APIQueryConsole;

import com.nokia.s60tools.apiquery.shared.util.xml.XMLElementData;

import com.nokia.s60tools.apiquery.shared.util.xml.XMLUtils;

import com.nokia.s60tools.sdk.SdkInformation;

import com.nokia.s60tools.util.debug.DbgUtility;

import com.nokia.s60tools.util.resource.FileUtils;

/**

 * Singleton class that is created on plugin startup, and is kept active as long

 * as plugin is active.

 * 

 * The purpose of this class is to store If Sheet entries configured by user.

 * 

 * The format of used XML:

 * 

 * <?xml version="1.0" encoding="UTF-8" ?> <entries> <metadata id="<drive>:\<path>\my_api.metaxml"

 * selected="true" sdkid="<DEVICE ID>" size="665" last_modified="1228305614126" />

 * <metadata id="<drive2>:\<path>\my_api2.metaxml" selected="false" sdkid="<DEVICE2

 * ID>" size="802" last_modified="1228305614126" /> </entries>

 * 

 */

public class CacheEntryStorage extends AbstractEntryStorage {

	/**

	 * Singleton instance.

	 */

	static private CacheEntryStorage instance = null;

	/**

	 * Public Singleton instance accessor.

	 * 

	 * @return Returns instance of this singleton class-

	 */

	public static CacheEntryStorage getInstance() {

		if (instance == null) {

			instance = new CacheEntryStorage();

		}

		return instance;

	}

	//

	// Variables for creating XML file from server entry data.

	//

	private static final String XML_HEADER = "<?xml version=\"1.0\" encoding=\"UTF-8\" ?>";//$NON-NLS-1$

	private static final String XML_ROOT_START_ELEMENT = "<entries>";//$NON-NLS-1$

	private static final String XML_ROOT_END_ELEMENT = "</entries>";//$NON-NLS-1$

	private static final String XML_ATTRIBUTE_ASSIGNMENT_WITH_QUOTE_START = "=\"";//$NON-NLS-1$

	private static final String CARRIAGE_RETURN_AND_NEWLINE = "\r\n";//$NON-NLS-1$

	private static final String SINGLE_SPACE = " ";//$NON-NLS-1$

	private static final String QUOTE_AND_SINGLE_SPACE = "\" ";//$NON-NLS-1$

	private static final String ELEMENT_START_STR = "<";//$NON-NLS-1$

	private static final String ELEMENT_END_STR = "/>"; //$NON-NLS-1$

	//

	// XML element and attribute names used for storing configuration

	//	

	private static final String METADATA_ELEMENT = "metadata";//$NON-NLS-1$

	private static final String ID_ATTRIBUTE = "id";//$NON-NLS-1$

	private static final String SDK_ID_ATTRIBUTE = "sdkid";//$NON-NLS-1$

	private static final String SIZE_ATTRIBUTE = "size";//$NON-NLS-1$

	private static final String SELECTION_ATTRIBUTE = "selected";//$NON-NLS-1$	

	private static final String DATE_ATTRIBUTE = "last_modified";//$NON-NLS-1$

	private static final String API_NAME = "api_name";//$NON-NLS-1$

	private Vector<XMLNotValidException> loadErrors = null;

	private boolean isLoaded = false;

	/**

	 * Private default constructor.

	 */

	private CacheEntryStorage() {

		super();

		DbgUtility.println(DbgUtility.PRIORITY_CLASS,

				"-- <<create>> --> " + getClass().getName()); //$NON-NLS-1$

	}

	/*

	 * (non-Javadoc)

	 * 

	 * @see com.nokia.s60tools.apiquery.shared.datatypes.config.AbstractEntryStorage#save(java.lang.String)

	 */

	public void save(String destinationFileAbsolutePathName) throws IOException {

		// System.out.println("save" + destinationFileAbsolutePathName);

		StringBuffer xmlDataBuf = new StringBuffer();

		File f = new File(destinationFileAbsolutePathName);

		// Deleting possibly old

		if (f.exists()) {

			if (!f.canWrite()) {

				String cannotWriteToFileErrMsg = Messages

						.getString("CacheEntry.Destination_File_Is_Write_Protected_ErrMsg") //$NON-NLS-1$

						+ destinationFileAbsolutePathName;

				APIQueryConsole.getInstance().println(cannotWriteToFileErrMsg,

						APIQueryConsole.MSG_ERROR);

				throw new RuntimeException(cannotWriteToFileErrMsg);

			}

			if (!f.delete()) {

				String cannotWriteToFileErrMsg = Messages

						.getString("CacheEntry.Destination_File_Is_In_Use_ErrMsg") //$NON-NLS-1$

						+ destinationFileAbsolutePathName;

				APIQueryConsole.getInstance().println(cannotWriteToFileErrMsg,

						APIQueryConsole.MSG_ERROR);

				throw new RuntimeException(cannotWriteToFileErrMsg);

			}

		}

		FileOutputStream fos = new FileOutputStream(f);

		BufferedOutputStream bos = new BufferedOutputStream(fos);

		xmlDataBuf.append(XML_HEADER);

		xmlDataBuf.append(CARRIAGE_RETURN_AND_NEWLINE);

		xmlDataBuf.append(XML_ROOT_START_ELEMENT);

		xmlDataBuf.append(CARRIAGE_RETURN_AND_NEWLINE);

		Collection<AbstractEntry> entriesColl = getEntries();

		// Create <ifheet>...</ifheet> XML -elements from entries

		for (AbstractEntry entryBeforeCast : entriesColl) {

			CacheEntry entry = (CacheEntry) entryBeforeCast;

			xmlDataBuf.append(ELEMENT_START_STR + METADATA_ELEMENT

					+ SINGLE_SPACE);

			xmlDataBuf.append(ID_ATTRIBUTE

					+ XML_ATTRIBUTE_ASSIGNMENT_WITH_QUOTE_START + entry.getId()

					+ QUOTE_AND_SINGLE_SPACE);

			xmlDataBuf.append(SELECTION_ATTRIBUTE

					+ XML_ATTRIBUTE_ASSIGNMENT_WITH_QUOTE_START

					+ Boolean.toString(entry.isSelected())

					+ QUOTE_AND_SINGLE_SPACE);

			xmlDataBuf.append(SDK_ID_ATTRIBUTE

					+ XML_ATTRIBUTE_ASSIGNMENT_WITH_QUOTE_START

					+ entry.getSDKID() + QUOTE_AND_SINGLE_SPACE);

			xmlDataBuf.append(SIZE_ATTRIBUTE

					+ XML_ATTRIBUTE_ASSIGNMENT_WITH_QUOTE_START

					+ entry.getSize() + QUOTE_AND_SINGLE_SPACE);

			xmlDataBuf.append(DATE_ATTRIBUTE

					+ XML_ATTRIBUTE_ASSIGNMENT_WITH_QUOTE_START

					+ entry.getDate() + QUOTE_AND_SINGLE_SPACE);

			xmlDataBuf.append(API_NAME

					+ XML_ATTRIBUTE_ASSIGNMENT_WITH_QUOTE_START

					+ entry.getAPIName() + QUOTE_AND_SINGLE_SPACE);

			//System.out.println("apiname" +entry.getAPIName());

			xmlDataBuf.append(ELEMENT_END_STR);

			xmlDataBuf.append(CARRIAGE_RETURN_AND_NEWLINE);

		}

		xmlDataBuf.append(XML_ROOT_END_ELEMENT);

		xmlDataBuf.append(CARRIAGE_RETURN_AND_NEWLINE);

		// Writing data to file

		byte[] writeData = xmlDataBuf.toString().getBytes();

		bos.write(writeData, 0, writeData.length);

		bos.flush();

		bos.close();

		fos.close();

	}

	/*

	 * (non-Javadoc)

	 * 

	 * @see com.nokia.s60tools.apiquery.shared.datatypes.config.AbstractEntryStorage#load(java.lang.String)

	 */

	public void load(String storageFilePathName) throws IOException {

		//System.out.println("storage file path" + storageFilePathName);

		// Setting elements to be parsed

		Set<String> elemNameSet = new LinkedHashSet<String>();

		elemNameSet.add(METADATA_ELEMENT); // server element

		// Setting attributes to be parsed for server element

		Map<String, String> attrNameSet = new LinkedHashMap<String, String>();

		attrNameSet.put(ID_ATTRIBUTE, ID_ATTRIBUTE);

		attrNameSet.put(SELECTION_ATTRIBUTE, SELECTION_ATTRIBUTE);

		attrNameSet.put(SDK_ID_ATTRIBUTE, SDK_ID_ATTRIBUTE);

		attrNameSet.put(SIZE_ATTRIBUTE, SIZE_ATTRIBUTE);

		attrNameSet.put(DATE_ATTRIBUTE, DATE_ATTRIBUTE);

		attrNameSet.put(API_NAME, API_NAME);

		Map<String, Map<String, String>> attributeMap = new LinkedHashMap<String, Map<String, String>>();

		attributeMap.put(METADATA_ELEMENT, attrNameSet);

		try {

			// Loading XML data into memory

			StringBuffer xmlData = FileUtils

					.loadDataFromFile(storageFilePathName);

			// Parsing elements from the XML data and adding found server

			// entries to storage

			XMLElementData[] elementArr = XMLUtils.parseXML(xmlData.toString(),

					elemNameSet, attributeMap);

			ArrayList<CacheEntry> foundEntries = convertElementDataToEntryList(elementArr);

			// Removing the old server entries and adding new ones

			// When we are really sure that the whole load opearation was

			// successful.

			entriesMap.clear();

			for (AbstractEntry entry : foundEntries) {

				// CacheEntry ent = (CacheEntry) entry;

				entriesMap.put(entry.getId(), entry);

			}

		} catch (Exception e) {

			e.printStackTrace();

			String msg = Messages

					.getString("CacheEntry.LoadFailed_Part_1_ErrMsg") + e.getMessage() //$NON-NLS-1$

					+ ". " + Messages.getString("CacheEntry.LoadFailed_Part_2_ErrMsg"); //$NON-NLS-1$ //$NON-NLS-2$

			APIQueryConsole.getInstance().println(msg,

					APIQueryConsole.MSG_ERROR);

			File f = new File(storageFilePathName);

			if (f.exists()) {

				f.delete();

			}

		}

	}

	/**

	 * Converts element data into server entry list.

	 * 

	 * @param elementArr

	 *            XML Element data to be converted.

	 * @return Server entry list.

	 */

	private ArrayList<CacheEntry> convertElementDataToEntryList(

			XMLElementData[] elementArr) {

		ArrayList<CacheEntry> foundEntries = new ArrayList<CacheEntry>();

		// Temporary data used during attribute fetching

		String id = null;

		String sdkid = null;

		boolean isSelected = false;

		String apiName = null;

		long size = -1;

		long date = -1;

		for (int i = 0; i < elementArr.length; i++) {

			XMLElementData data = elementArr[i];

			Map<String, String> params = data.getAttributes();

			try {

				id = params.get(ID_ATTRIBUTE);

				isSelected = Boolean.parseBoolean(params

						.get(SELECTION_ATTRIBUTE));

				sdkid = params.get(SDK_ID_ATTRIBUTE);

				size = Long.parseLong(params.get(SIZE_ATTRIBUTE));

				date = Long.parseLong(params.get(DATE_ATTRIBUTE));

				apiName = params.get(API_NAME);

				//System.out.println("api name" + apiName);

			} catch (Exception e) {

				throw new RuntimeException(

						Messages

								.getString("CacheEntry.Unexpected_Attribute_ErrMsg") + data.getElementName()); //$NON-NLS-1$

			}

			File file = new File(id);

			if (file.exists()) {

				String fileName = file.getName();

				// Adding an entry

				foundEntries.add(new CacheEntry(id, fileName, sdkid,

						isSelected, size, date, apiName));

			}

		}

		return foundEntries;

	}

	/**

	 * Get currentry selected SDK ID

	 * 

	 * @return SDK ID or <code>null</code> if not found.

	 */

	public String getCurrentlySelectedSDKID() {

		for (AbstractEntry entry : getEntries()) {

			CacheEntry cacheEntry = (CacheEntry) entry;

			if (cacheEntry.getSDKID() != null && cacheEntry.isSelected()) {

				return cacheEntry.getSDKID();

			}

		}

		return null;

	}

	/**

	 * Updates an entry to the storage. Additional not recommended possibility

	 * to update entry without notifying listeners. It's not recommended to use

	 * this, but if used, make sure that listeners is notified afterwards by

	 * using

	 * {@link AbstractEntryStorage#notifyConfigurationChangeListeners(int)}.

	 * 

	 * @param entryWithNewData

	 *            Entry object containing new data.

	 * @throws EntryNotFoundException

	 * @param dontNotifyListeners

	 *            if <code>true</code> listeners will not be notified.

	 */

	public void updateEntry(AbstractEntry entryWithNewData,

			boolean dontNotifyListeners) throws EntryNotFoundException {

		if (dontNotifyListeners) {

			AbstractEntry entryWithOldData = (AbstractEntry) entriesMap

					.get(entryWithNewData.getId());

			if (entryWithOldData == null) {

				String nonExistingEntryMsg = Messages

						.getString("AbstractEntryStorage.NonExistingEntry_ErrMsg") + entryWithNewData.getId(); //$NON-NLS-1$

				throw new EntryNotFoundException(nonExistingEntryMsg);

			}

			// Updating data fields (which triggers notification to

			// configuration change listeners)

			entryWithOldData

					.updateEntryTypeSpecificDataFields(entryWithNewData);

		} else {

			updateEntry(entryWithNewData);

		}

		this.isLoaded = false;

	}

	/*

	 * (non-Javadoc)

	 * 

	 * @see com.nokia.s60tools.apiquery.shared.datatypes.config.AbstractEntryStorage#updateEntry(com.nokia.s60tools.apiquery.shared.datatypes.config.AbstractEntry)

	 */

	public void updateEntry(AbstractEntry entryWithNewData)

			throws EntryNotFoundException {

		super.updateEntry(entryWithNewData);

		this.isLoaded = false;

	}

	/**

	 * Adds an entry to the storage. Additional not recommended possibility to

	 * add entry without notifying listeners. It's not recommended to use this,

	 * but if used, make sure that listeners is notified afterwards by using

	 * {@link AbstractEntryStorage#notifyConfigurationChangeListeners(int)}.

	 * 

	 * @param entry

	 *            Entry to be added.

	 * @param dontNotifyListeners

	 *            if <code>true</code> listeners will not be notified.

	 * @throws DuplicateEntryException

	 */

	public void addEntry(AbstractEntry entry, boolean dontNotifyListeners)

			throws DuplicateEntryException {

		if (!dontNotifyListeners) {

			super.addEntry(entry);

		} else {

			if (entriesMap.get(entry.getId()) != null) {

				String duplicateEntriesErrMsg = Messages

						.getString("AbstractEntryStorage.Duplicate_ErrMsg"); //$NON-NLS-1$

				throw new DuplicateEntryException(duplicateEntriesErrMsg);

			}

			entriesMap.put(entry.getId(), entry);

		}

		this.isLoaded = false;

	}

	/*

	 * (non-Javadoc)

	 * 

	 * @see com.nokia.s60tools.apiquery.shared.datatypes.config.AbstractEntryStorage#addEntry(com.nokia.s60tools.apiquery.shared.datatypes.config.AbstractEntry)

	 */

	public void addEntry(AbstractEntry entry) throws DuplicateEntryException {

		super.addEntry(entry);

		this.isLoaded = false;

	}

	/**

	 * Load all selected entrys to storage. Parsing XML:s for all items, by

	 * calling {@link CacheEntry#load()}.

	 * 

	 * Also {@link CacheEntry#unload()} for entry if not selected.

	 * 

	 * If want to know if there was some errors, ask it by

	 * {@link CacheEntryStorage#isLoadErros()}. If there was errors, ask them

	 * by {@link CacheEntryStorage#getLoadErrors()}.

	 * 

	 * @param monitor

	 *            to check for cancellations

	 * @param newSelectedSDKInfo

	 *            SDK info to be selected

	 * @throws JobCancelledByUserException

	 *             if canceled by user

	 * 

	 */

	public void selectSDKAndLoadAllSelectedDatasToMemory(

			IProgressMonitor monitor, SdkInformation newSelectedSDKInfo)

			throws JobCancelledByUserException {

		selectSDKAndLoadAllSelectedDatasToMemory(monitor, newSelectedSDKInfo,

				true);

	}

	/**

	 * Load all selected entrys to storage. Parsing XML:s for all items, by

	 * calling {@link CacheEntry#load()}.

	 * 

	 * Also {@link CacheEntry#unload()} for entry if not selected.

	 * 

	 * If want to know if there was some errors, ask it by

	 * {@link CacheEntryStorage#isLoadErros()}. If there was errors, ask them

	 * by {@link CacheEntryStorage#getLoadErrors()}.

	 * 

	 * @param monitor

	 *            to check for cancellations

	 * @param newSelectedSDKInfo

	 *            SDK info to be selected

	 * @param selectSDK

	 *            if newSelectedSDKInfo is to be selected as new selected SDK

	 * @throws JobCancelledByUserException

	 *             if canceled by user

	 * 

	 */

	private void selectSDKAndLoadAllSelectedDatasToMemory(

			IProgressMonitor monitor, SdkInformation newSelectedSDKInfo,

			boolean selectSDK) throws JobCancelledByUserException {

		// set to data store that all are deselected

		Collection<AbstractEntry> entrys = getEntries();

		// Store current situation for restoring it in cases of cancel

		Set<String> keys = entriesMap.keySet();

		Map<String, AbstractEntry> storedEntriesMap = new LinkedHashMap<String, AbstractEntry>(

				entriesMap.size());

		for (String key : keys) {

			CacheEntry ent = (CacheEntry) entriesMap.get(key);

			APIDetails det = ent.getAPIDetails();// If details is null, it

			// must not be loaded now,

			// because of lot of time

			// taken

			CacheEntry ent_ = new CacheEntry(ent.getId(), ent.getName(), ent

					.getSDKID(), ent.isSelected(), ent.getSize(),

					ent.getDate(), ent.getAPIName());

			ent_.setAPIDetails(det);

			storedEntriesMap.put(new String(key), ent_);

		}

		try {

			// select new SDK

			if (selectSDK) {

				selectNewSDK(monitor, newSelectedSDKInfo, entrys);

			}

			// For XML validity errors

			loadErrors = null;

			Vector<CacheEntry> entrysToBeUnloaded = new Vector<CacheEntry>();

			// Loading all selected entrys to to memory by using entry.load()

			for (AbstractEntry entry : entrys) {

				// If canceled, throwing exception and catch will handle data

				// restore

				if (monitor.isCanceled()) {

					throw new JobCancelledByUserException(

							Messages

									.getString("CacheEntryStorage.JobCanceledByUserMsg"));

				}

				CacheEntry ce = (CacheEntry) entry;

				if (ce.isSelected()) {

					try {

						ce.load();

					} catch (XMLNotValidException e) {

						addLoadError(e);

					}

				}

				// If entry is not selected, unloading it from memory.

				else {

					entrysToBeUnloaded.add(ce);

				}

			}

			// If canceled during operation, we unload entrys just when all is

			// loaded, unload does not really take any time.

			// So for here cancel wont occur anymore

			for (CacheEntry ce : entrysToBeUnloaded) {

				ce.unload();

			}