/*******************************************************************************
 * Copyright (c) 2009, 2010 Nokia and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 * Nokia - Initial API and implementation
 *******************************************************************************/
package org.eclipse.cdt.debug.edc.internal.services.dsf;

import java.nio.ByteOrder;
import java.util.Collection;
import java.util.Collections;
import java.util.List;

import org.eclipse.cdt.core.IAddress;
import org.eclipse.cdt.debug.edc.internal.EDCDebugger;
import org.eclipse.cdt.debug.edc.internal.symbols.ISection;
import org.eclipse.cdt.debug.edc.internal.symbols.ModuleLineEntryProvider;
import org.eclipse.cdt.debug.edc.internal.symbols.files.BaseExecutableSymbolicsReader;
import org.eclipse.cdt.debug.edc.services.IFrameRegisterProvider;
import org.eclipse.cdt.debug.edc.symbols.ICompileUnitScope;
import org.eclipse.cdt.debug.edc.symbols.IDebugInfoProvider;
import org.eclipse.cdt.debug.edc.symbols.IEDCSymbolReader;
import org.eclipse.cdt.debug.edc.symbols.IEnumerator;
import org.eclipse.cdt.debug.edc.symbols.IExecutableSection;
import org.eclipse.cdt.debug.edc.symbols.IExecutableSymbolicsReader;
import org.eclipse.cdt.debug.edc.symbols.IFunctionScope;
import org.eclipse.cdt.debug.edc.symbols.IModuleLineEntryProvider;
import org.eclipse.cdt.debug.edc.symbols.IModuleScope;
import org.eclipse.cdt.debug.edc.symbols.IRangeList;
import org.eclipse.cdt.debug.edc.symbols.IScope;
import org.eclipse.cdt.debug.edc.symbols.ISymbol;
import org.eclipse.cdt.debug.edc.symbols.IType;
import org.eclipse.cdt.debug.edc.symbols.IUnmangler;
import org.eclipse.cdt.debug.edc.symbols.IVariable;
import org.eclipse.cdt.utils.Addr32;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Status;
import org.eclipse.core.runtime.jobs.Job;

/**
 * This class handles the high-level retrieval of symbolic information, using 
 * {@link IDebugInfoProvider} and {@link IExecutableSymbolicsReader}.
 */
public class EDCSymbolReader implements IEDCSymbolReader {

	private static final String[] NO_SOURCE_FILES = new String[0];

	public static final IModuleScope EMPTY_MODULE_SCOPE = new IModuleScope() {
		ModuleLineEntryProvider lineEntryMapper = new ModuleLineEntryProvider();

		public int compareTo(Object arg0) {	return 0; }
		public boolean hasEmptyRange() { return true; }
		public IScope getScopeAtAddress(IAddress linkAddress) { return null; }
		public IRangeList getRangeList() { return null; }
		public IScope getParent() { return null; }
		public String getName() { return ""; }
		public IAddress getLowAddress() { return Addr32.ZERO; }
		public IAddress getHighAddress() { return Addr32.ZERO;	}
		public IPath getSymbolFile() { return null; }
		public IModuleLineEntryProvider getModuleLineEntryProvider() { return lineEntryMapper; }
		public IFrameRegisterProvider getFrameRegisterProvider() { return null; }
		public ICompileUnitScope getCompileUnitForAddress(IAddress linkAddress) { return null; }
		public IFunctionScope getFunctionByName(String name) { return null; }
		public Collection<IScope> getChildren() {
			return Collections.emptyList();
		}
		public Collection<IEnumerator> getEnumerators() {
			return Collections.emptyList();
		}
		public Collection<IFunctionScope> getFunctionsByName(String name) {
			return Collections.emptyList();
		}
		public Collection<IType> getTypes() {
			return Collections.emptyList();
		}
		public Collection<IVariable> getVariables() {
			return Collections.emptyList();
		}
		public Collection<IVariable> getVariablesByName(String name, boolean globalsOnly) {
			return Collections.emptyList();
		}
		public List<ICompileUnitScope> getCompileUnitsForFile(IPath filePath) {
			return Collections.emptyList();
		}
		public void dispose() { }
	};
	
	private IDebugInfoProvider debugInfoProvider;
	private IExecutableSymbolicsReader exeSymReader;

	public EDCSymbolReader(IExecutableSymbolicsReader exeSymReader, IDebugInfoProvider debugInfoProvider) {
		if (exeSymReader == null)
			throw new IllegalArgumentException();
		
		this.exeSymReader = exeSymReader;
		this.debugInfoProvider = debugInfoProvider;
		
		// we expect these two files to be the same
		if (debugInfoProvider != null)
			if (!debugInfoProvider.getSymbolFile().equals(exeSymReader.getSymbolFile()))
				throw new IllegalArgumentException();
	}

	public void shutDown() {
		if (exeSymReader != null) {
			exeSymReader.dispose();
			exeSymReader = null;
		}
		if (debugInfoProvider != null) {
			debugInfoProvider.dispose();
			debugInfoProvider = null;
		}
	}

	/* (non-Javadoc)
	 * @see org.eclipse.cdt.debug.edc.internal.symbols.exe.IExecutableSymbolicsReader#dispose()
	 */
	public void dispose() {
		exeSymReader.dispose();
	}
	
	public Collection<IExecutableSection> getExecutableSections() {
		return exeSymReader.getExecutableSections();
	}
	
	public IExecutableSection findExecutableSection(String sectionName) {
		return exeSymReader.findExecutableSection(sectionName);
	}
	
	public Collection<ISection> getSections() {
		return exeSymReader.getSections();
	}

	public IAddress getBaseLinkAddress() {
		return exeSymReader.getBaseLinkAddress();
	}

	public long getModificationDate() {
		return exeSymReader.getModificationDate();
	}
	
	public Collection<ISymbol> findSymbols(String name) {
		return exeSymReader.findSymbols(name);
	}

	public Collection<ISymbol> findUnmangledSymbols(String name) {
		return exeSymReader.findUnmangledSymbols(name);
	}
	
	public Collection<ISymbol> getSymbols() {
		return exeSymReader.getSymbols();
	}

	public ISymbol getSymbolAtAddress(IAddress linkAddress) {
		return exeSymReader.getSymbolAtAddress(linkAddress);
	}

	public Collection<ISymbol> getSymbolsAtAddress(IAddress linkAddress) {
		return exeSymReader.getSymbolsAtAddress(linkAddress);
	}

	public IPath getSymbolFile() {
		return debugInfoProvider != null ? debugInfoProvider.getSymbolFile() :
			(exeSymReader != null ? exeSymReader.getSymbolFile() : null);
	}

	public ByteOrder getByteOrder() {
		return exeSymReader.getByteOrder();
	}
	
	public IModuleScope getModuleScope() {
		if (debugInfoProvider != null)
			return debugInfoProvider.getModuleScope();
		else
			return EMPTY_MODULE_SCOPE;
	}

	public String[] getSourceFiles() {
		if (debugInfoProvider != null)
		{
			final String[][] resultHolder = new String[1][];
			Job quickParseJob = new Job("Reading Debug Symbol Information: " + debugInfoProvider.getSymbolFile().toOSString()) {

				@Override
				protected IStatus run(IProgressMonitor monitor) {
					String[] sourceFiles = getSourceFiles(monitor);
					resultHolder[0] = sourceFiles;
					return Status.OK_STATUS;
				}
			};
			
			try {
				quickParseJob.schedule();
				quickParseJob.join();
			} catch (InterruptedException e) {
				EDCDebugger.getMessageLogger().logError(null, e);
			}
			return resultHolder[0];
		}
		else
			return NO_SOURCE_FILES;
	}

	public String[] getSourceFiles(IProgressMonitor monitor) {
		if (debugInfoProvider != null)
			return debugInfoProvider.getSourceFiles(monitor);
		else
			return NO_SOURCE_FILES;
	}

	public boolean hasRecognizedDebugInformation() {
		return debugInfoProvider != null;
	}
	
	public IDebugInfoProvider getDebugInfoProvider() {
		return debugInfoProvider;
	}
	
	public IUnmangler getUnmangler() {
		if (exeSymReader instanceof BaseExecutableSymbolicsReader)
			return ((BaseExecutableSymbolicsReader) exeSymReader).getUnmangler();
		return null;
	}

	public IExecutableSymbolicsReader getSymbolicsReader() {
		return exeSymReader;
	}
}