/*******************************************************************************
 * Licensed Materials - Property of IBM
 * (c) Copyright IBM Corporation 2007, 2008. All Rights Reserved.
 * 
 * Note to U.S. Government Users Restricted Rights:  Use,
 * duplication or disclosure restricted by GSA ADP Schedule
 * Contract with IBM Corp.
 *******************************************************************************/

import java.io.BufferedInputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.Reader;
import java.io.StringWriter;
import java.io.Writer;
import java.net.URI;

import org.eclipse.core.runtime.IProgressMonitor;

import com.ibm.team.repository.client.ITeamRepository;
import com.ibm.team.repository.client.TeamPlatform;
import com.ibm.team.repository.client.ITeamRepository.ILoginHandler;
import com.ibm.team.repository.client.ITeamRepository.ILoginHandler.ILoginInfo;
import com.ibm.team.repository.common.ItemNotFoundException;
import com.ibm.team.repository.common.TeamRepositoryException;
import com.ibm.team.repository.common.transport.ConnectionException;
import com.ibm.team.repository.common.util.NLS;

import com.ibm.team.process.client.IProcessClientService;
import com.ibm.team.process.common.IProjectArea;
import com.ibm.team.process.common.IProjectAreaHandle;

import com.ibm.team.workitem.client.IAuditableClient;
import com.ibm.team.workitem.client.IQueryClient;
import com.ibm.team.workitem.common.IAuditableCommon;
import com.ibm.team.workitem.common.expression.AttributeExpression;
import com.ibm.team.workitem.common.expression.IQueryableAttribute;
import com.ibm.team.workitem.common.expression.IQueryableAttributeFactory;
import com.ibm.team.workitem.common.expression.QueryableAttributes;
import com.ibm.team.workitem.common.expression.SimilarityExpression;
import com.ibm.team.workitem.common.expression.Term;
import com.ibm.team.workitem.common.expression.Term.Operator;
import com.ibm.team.workitem.common.model.AttributeOperation;
import com.ibm.team.workitem.common.model.IWorkItem;
import com.ibm.team.workitem.common.query.IQueryResult;
import com.ibm.team.workitem.common.query.IResolvedResult;
import com.ibm.team.workitem.common.text.WorkItemTextUtilities;

public class DupeFinder {
	
	private static class LoginHandler implements ILoginHandler, ILoginInfo {
		
		private String fUserId;
		private String fPassword;
		
		private LoginHandler(String userId, String password) {
			fUserId= userId;
			fPassword= password;
		}
		
		public String getUserId() {
			return fUserId;
		}
		
		public String getPassword() {
			return fPassword;
		}
		
		public ILoginInfo challenge(ITeamRepository repository) {
			return this;
		}
	}

	public static void main(String[] args) {
		
		if (args.length < 4) {
			System.out.println("Usage: DupeFinder <repositoryURI> <user> <password> <project area name> [<file>]");
			System.exit(1);
		}
		
		String repositoryURI= args[0];
		String userId= args[1];
		String password= args[2];
		String projectAreaName= args[3];
		String fileName= args.length > 4 ? args[4] : null;

		InputStream fileInputStream= null;
		
		try {
			TeamPlatform.startup();
			ITeamRepository repository= login(repositoryURI, userId, password);
			
			if (fileName != null)
				fileInputStream= new FileInputStream(fileName);
			InputStream inputStream= fileInputStream != null ? fileInputStream : System.in;
		
			IQueryResult<IResolvedResult<IWorkItem>> result= getResult(repository, projectAreaName, inputStream);
			printResult(result);
			
		} catch (FileNotFoundException e) {
			System.err.println(NLS.bind("File not found: {0}", fileName));
		} catch (ItemNotFoundException e) {
			System.err.println(e.getMessage());
		} catch (ConnectionException e) {
			System.err.println(e.getMessage());
		} catch (TeamRepositoryException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			TeamPlatform.shutdown();
			if (fileInputStream != null) {
				try { fileInputStream.close(); } catch (IOException e) {}
			}
		}
	}

	private static void printResult(IQueryResult<IResolvedResult<IWorkItem>> result) throws TeamRepositoryException {
		
		System.out.println();
		System.out.println("-------------------------------------------------------------------------------");
		System.out.println(NLS.bind("Potential Duplicates: {0}", result.getResultSize(null).getTotal()));
		System.out.println("-------------------------------------------------------------------------------");
		
		while (result.hasNext(null)) {
			IResolvedResult<IWorkItem> resolved= result.next(null);
			double score= resolved.getScore();
			String label= WorkItemTextUtilities.getWorkItemText(resolved.getItem());
			String formatted= String.format("%.2f %s", score, label);
			System.out.println(formatted);
		}
	}

	private static IQueryResult<IResolvedResult<IWorkItem>> getResult(ITeamRepository repository, String projectAreaName, InputStream inputStream) throws IOException, TeamRepositoryException {
		
		IProcessClientService processClient= (IProcessClientService) repository.getClientLibrary(IProcessClientService.class);
		IQueryClient queryClient= (IQueryClient) repository.getClientLibrary(IQueryClient.class);
		IAuditableClient auditableClient= (IAuditableClient) repository.getClientLibrary(IAuditableClient.class);
		
		URI uri= URI.create(projectAreaName.replaceAll(" ", "%20"));
		IProjectArea projectArea= (IProjectArea) processClient.findProcessArea(uri, null, null);
		if (projectArea == null) {
			throw new ItemNotFoundException(NLS.bind("Project area {0} not found", projectAreaName));
		}
		
		String content= toString(inputStream);
		SimilarityExpression similarityExpression= new SimilarityExpression("", content, null);
		
		IQueryableAttribute projectAreaAttribute= findAttribute(projectArea, auditableClient, IWorkItem.PROJECT_AREA_PROPERTY, null);
		AttributeExpression projectAreaExpression= new AttributeExpression(projectAreaAttribute, AttributeOperation.EQUALS, projectArea);
		
		Term term= new Term(Operator.AND);
		term.add(projectAreaExpression);
		term.add(similarityExpression);
		
		return queryClient.getResolvedExpressionResults(projectArea, term, IWorkItem.SMALL_PROFILE);
	}

	private static ITeamRepository login(String repositoryURI, String userId, String password) throws TeamRepositoryException {
		ITeamRepository teamRepository= TeamPlatform.getTeamRepositoryService().getTeamRepository(repositoryURI);
		teamRepository.registerLoginHandler(new LoginHandler(userId, password));
		teamRepository.login(null);
		return teamRepository;
	}

	private static String toString(InputStream inputStream) throws IOException {
		InputStreamReader reader= new InputStreamReader(new BufferedInputStream(inputStream));
		StringWriter writer= new StringWriter();
		copyStream(reader, writer);
		return writer.toString();
	}
	
	private static void copyStream(Reader reader, Writer writer) throws IOException {
		char[] buffer= new char[1024];
		int readBytes= 0;
		while ((readBytes= reader.read(buffer)) != -1) {
			writer.write(buffer, 0, readBytes);
		}
	}
	
	private static IQueryableAttribute findAttribute(IProjectAreaHandle projectArea, IAuditableCommon auditableCommon, String attributeId, IProgressMonitor monitor) throws TeamRepositoryException {
		IQueryableAttributeFactory factory= QueryableAttributes.getFactory(IWorkItem.ITEM_TYPE);
		return factory.findAttribute(projectArea, attributeId, auditableCommon, monitor);
	}
}