/*******************************************************************************
 * Copyright (c) 2000, 2005 IBM Corporation 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:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
package org.eclipse.compare.internal.patch;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.PrintStream;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;

import org.eclipse.compare.internal.Utilities;
import org.eclipse.compare.structuremergeviewer.Differencer;
import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IMarker;
import org.eclipse.core.resources.IProject;
import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IAdaptable;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.Path;
import org.eclipse.core.runtime.SubProgressMonitor;
import org.eclipse.core.runtime.jobs.ISchedulingRule;
import org.eclipse.jface.resource.ImageDescriptor;
import org.eclipse.swt.SWT;
import org.eclipse.swt.widgets.Shell;
import org.eclipse.ui.model.IWorkbenchAdapter;

/**
 * A Patcher 
 * - knows how to parse various patch file formats into some in-memory structure,
 * - holds onto the parsed data and the options to use when applying the patches,
 * - knows how to apply the patches to files and folders.
 */
public class WorkspacePatcher extends Patcher implements IAdaptable, IWorkbenchAdapter {

	private DiffProject[] fDiffProjects;

	private boolean fIsWorkspacePatch = false;

	//API for writing new multi-project patch format
	public static final String MULTIPROJECTPATCH_HEADER= "### Eclipse Workspace Patch"; //$NON-NLS-1$
	public static final String MULTIPROJECTPATCH_VERSION= "1.0"; //$NON-NLS-1$
	public static final String MULTIPROJECTPATCH_PROJECT= "#P"; //$NON-NLS-1$

	/**
	 * Appends the multiproject header and version number to the passed in stream. Users
	 * should call this first during the patch creation process if they want their patches
	 * to be applied across the workspace.  
	 *  
	 * @param stream
	 */
	public static void writeMultiProjectPatchHeader(PrintStream stream) {
		stream.println(MULTIPROJECTPATCH_HEADER+" "+MULTIPROJECTPATCH_VERSION); //$NON-NLS-1$
	}

	/**
	 * Appends the header for a multiproject patch project to the passed in stream. This should
	 * be called before adding any additional patch content for the passed in project in order to 
	 * allow the patch to be properly rooted across the workspace.  
	 * @param stream
	 * @param project
	 */
	public static void addMultiProjectPatchProject(PrintStream stream, IProject project) {
		stream.println(MULTIPROJECTPATCH_PROJECT+" "+project.getName()); //$NON-NLS-1$
	}
	
	public WorkspacePatcher() {
		// nothing to do
	}

	public DiffProject[] getDiffProjects() {
		return fDiffProjects;
	}

	boolean isWorkspacePatch() {
		return fIsWorkspacePatch;
	}

	//---- parsing patch files

	public void parse(BufferedReader reader) throws IOException {
		List diffs = new ArrayList();
		HashMap diffProjects = new HashMap(4);
		String line = null;
		boolean reread = false;
		String diffArgs = null;
		String fileName = null;
		//no project means this is a single patch,create a placeholder project for now
		//which will be replaced by the target selected by the user in the preview pane
		String project = ""; //$NON-NLS-1$
		fIsWorkspacePatch = false;

		LineReader lr = new LineReader(reader);
		if (!"carbon".equals(SWT.getPlatform())) //$NON-NLS-1$
			lr.ignoreSingleCR();

		// Test for our format
		line = lr.readLine();
		if (line.startsWith(MULTIPROJECTPATCH_HEADER)) {
			fIsWorkspacePatch = true;
		} else {
			parse(lr, line);
			return;
		}

		// read leading garbage
		while (true) {
			if (!reread)
				line = lr.readLine();
			reread = false;
			if (line == null)
				break;
			if (line.length() < 4)
				continue; // too short

			if (line.startsWith(MULTIPROJECTPATCH_PROJECT)) {
				project = line.substring(2).trim();
				continue;
			}

			if (line.startsWith("Index: ")) { //$NON-NLS-1$
				fileName = line.substring(7).trim();
				continue;
			}
			if (line.startsWith("diff")) { //$NON-NLS-1$
				diffArgs = line.substring(4).trim();
				continue;
			}

			if (line.startsWith("--- ")) { //$NON-NLS-1$
				//if there is no current project or
				//the current project doesn't equal the newly parsed project
				//reset the current project to the newly parsed one, create a new DiffProject
				//and add it to the array
				DiffProject diffProject;
				if (!diffProjects.containsKey(project)) {
					IProject iproject = ResourcesPlugin.getWorkspace().getRoot().getProject(project);
					diffProject = new DiffProject(iproject);
					diffProjects.put(project, diffProject);
				} else {
					diffProject = (DiffProject) diffProjects.get(project);
				}

				line = readUnifiedDiff(diffs, lr, line, diffArgs, fileName, diffProject);
				diffArgs = fileName = null;
				reread = true;
			}
		}

		lr.close();

		fDiffs = (Diff[]) diffs.toArray(new Diff[diffs.size()]);
		fDiffProjects = (DiffProject[]) diffProjects.values().toArray(new DiffProject[diffProjects.size()]);
	}

	private String readUnifiedDiff(List diffs, LineReader lr, String line, String diffArgs, String fileName, DiffProject diffProject) throws IOException {
		List newDiffs = new ArrayList();
		String nextLine = readUnifiedDiff(newDiffs, lr, line, diffArgs, fileName);
		for (Iterator iter = newDiffs.iterator(); iter.hasNext();) {
			Diff diff = (Diff) iter.next();
			diff.setProject(diffProject);
			diffs.add(diff);
		}
		return nextLine;
	}

	public void applyAll(IProgressMonitor pm, Shell shell, String title) throws CoreException {
		if (!fIsWorkspacePatch) {
			super.applyAll(pm, shell, title);
		} else {
			final int WORK_UNIT = 10;

			// get all files to be modified in order to call validateEdit
			List list = new ArrayList();
			for (int j = 0; j < fDiffProjects.length; j++) {
				DiffProject diffProject = fDiffProjects[j];
				list.addAll(Arrays.asList(diffProject.getTargetFiles()));
			}
			//validate the files for editing
			if (!Utilities.validateResources(list, shell, title))
				return;

			if (pm != null) {
				String message = PatchMessages.Patcher_Task_message;
				pm.beginTask(message, fDiffs.length * WORK_UNIT);
			}

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

				int workTicks = WORK_UNIT;

				Diff diff = fDiffs[i];
				if (diff.isEnabled()) {
					IFile file = diff.getTargetFile();
					IPath path = file.getProjectRelativePath();
					if (pm != null)
						pm.subTask(path.toString());
					createPath(file.getProject(), path);

					List failed = new ArrayList();
					List result = null;

					int type = diff.getType();
					switch (type) {
						case Differencer.ADDITION :
							// patch it and collect rejected hunks
							result = apply(diff, file, true, failed);
							store(createString(result), file, new SubProgressMonitor(pm, workTicks));
							workTicks -= WORK_UNIT;
							break;
						case Differencer.DELETION :
							file.delete(true, true, new SubProgressMonitor(pm, workTicks));
							workTicks -= WORK_UNIT;
							break;
						case Differencer.CHANGE :
							// patch it and collect rejected hunks
							result = apply(diff, file, false, failed);
							store(createString(result), file, new SubProgressMonitor(pm, workTicks));
							workTicks -= WORK_UNIT;
							break;
					}

					if (failed.size() > 0) {
						IPath pp = null;
						if (path.segmentCount() > 1) {
							pp = path.removeLastSegments(1);
							pp = pp.append(path.lastSegment() + REJECT_FILE_EXTENSION);
						} else
							pp = new Path(path.lastSegment() + REJECT_FILE_EXTENSION);
						file = createPath(file.getProject(), pp);
						if (file != null) {
							store(getRejected(failed), file, pm);
							try {
								IMarker marker = file.createMarker(MARKER_TYPE);
								marker.setAttribute(IMarker.MESSAGE, PatchMessages.Patcher_Marker_message);
								marker.setAttribute(IMarker.PRIORITY, IMarker.PRIORITY_HIGH);
							} catch (CoreException ex) {
								// NeedWork
							}
						}
					}
				}

				if (pm != null) {
					if (pm.isCanceled())
						break;
					if (workTicks > 0)
						pm.worked(workTicks);
				}
			}
		}
	}

	public ISchedulingRule[] getTargetProjects() {
		List projects = new ArrayList();
		for (int i = 0; i < fDiffProjects.length; i++) {
			DiffProject diffProject = fDiffProjects[i];
			projects.add(diffProject.getProject());
		}
		return (ISchedulingRule[]) projects.toArray(new ISchedulingRule[projects.size()]);
	}

	public Object getAdapter(Class adapter) {
		if (adapter == IWorkbenchAdapter.class) {
			return this;
		}
		return null;
	}

	public Object[] getChildren(Object o) {
		if (fIsWorkspacePatch) {
			return fDiffProjects;
		}
		if (fDiffs != null)
			return fDiffs;
		return new Object[0];
	}

	public ImageDescriptor getImageDescriptor(Object object) {
		return null;
	}

	public String getLabel(Object o) {
		return null;
	}

	public Object getParent(Object o) {
		return null;
	}
}