package eu.smartlm.abs.portal.data.query.ws;

import java.util.Calendar;
import java.util.Date;
import java.util.HashSet;
import java.util.Set;

import org.apache.axis2.AxisFault;
import org.gridforum.x2003.urWg.HostDocument.Host;
import org.gridforum.x2003.urWg.ProjectNameDocument.ProjectName;
import org.gridforum.x2003.urWg.SubmitHostDocument.SubmitHost;
import org.gridforum.x2003.urWg.UserIdentityDocument.UserIdentity;

import eu.smartlm.abs.portal.data.query.QueryConstructor;
import eu.smartlm.ebs.client.EBServiceClient;
import eu.smartlm.ebs.ws.ListOfAccountingGroupsInputDocument;
import eu.smartlm.ebs.ws.ListOfAccountingGroupsOutputDocument;
import eu.smartlm.ebs.ws.ListOfHostsInputDocument;
import eu.smartlm.ebs.ws.ListOfHostsOutputDocument;
import eu.smartlm.ebs.ws.ListOfInputType;
import eu.smartlm.ebs.ws.ListOfProductsInputDocument;
import eu.smartlm.ebs.ws.ListOfProductsOutputDocument;
import eu.smartlm.ebs.ws.ListOfProjectsInputDocument;
import eu.smartlm.ebs.ws.ListOfProjectsOutputDocument;
import eu.smartlm.ebs.ws.ListOfSmartLMUsageRecordsInputDocument;
import eu.smartlm.ebs.ws.ListOfSmartLMUsageRecordsOutputDocument;
import eu.smartlm.ebs.ws.ListOfSubmitFeaturesInputDocument;
import eu.smartlm.ebs.ws.ListOfSubmitFeaturesOutputDocument;
import eu.smartlm.ebs.ws.ListOfSubmitHostsInputDocument;
import eu.smartlm.ebs.ws.ListOfSubmitHostsOutputDocument;
import eu.smartlm.ebs.ws.ListOfUsersInputDocument;
import eu.smartlm.ebs.ws.ListOfUsersOutputDocument;
import eu.smartlm.ebs.ws.SetType;
import eu.smartlm.schemas.x2009.x06.urec.FeatureType;
import eu.smartlm.schemas.x2009.x06.urec.ProductType;
import eu.smartlm.schemas.x2009.x06.urec.SmartLMUsageRecordType;


/**
 * Web-service client to retrieve the accounting and billing data from the Accounting and Billing server
 * @author David Garcia Perez - CESGA
 */
public class EBSServiceClient implements QueryConstructor {
	private EBServiceClient stub;
	
	public void setUpConnection(String url, String rampartRepo, String clientProperties) {
		try {
			stub = EBServiceClient.getInstance(rampartRepo, clientProperties, url);
		} catch (Exception e) {
			System.out.println("Exception creating stub: " + e);
		}
	}

	public Set<String> getListOfAccountingGroups(Date startDate, Date endDate,
			Set<String> filterByUsers, Set<String> filterByProduct,
			Set<String> filterByProject, Set<String> filterByHost,
			Set<String> filterBySubmitHost, Set<String> filterByFeature,
			Set<String> filterByAccountingGroups) {

		ListOfAccountingGroupsInputDocument inputDocument = ListOfAccountingGroupsInputDocument.Factory.newInstance();
		ListOfInputType input = inputDocument.addNewListOfAccountingGroupsInput();
		setInput(input, 
				 startDate, 
				 endDate, 
				 filterByUsers, 
				 filterByProduct, 
				 filterByProject, 
				 filterByHost,
				 filterBySubmitHost, 
				 filterByFeature,
				 filterByAccountingGroups);

		ListOfAccountingGroupsOutputDocument outputDocument = ListOfAccountingGroupsOutputDocument.Factory.newInstance();;
		
		try {
			 outputDocument = stub.getListOfAccountingGroups(inputDocument);
		} catch (AxisFault e) {
			System.out.println("Exception getting the list of accounting groups " + e);
			return new HashSet<String>();
		} catch (Exception e) {
			System.out.println("Error getting the list of Users: " + e);
		}
		
		Set<String> output = new HashSet<String>();
		
		if(outputDocument != null) {
			SetType[] sets = outputDocument.getListOfAccountingGroupsOutput().getSetArray();
			for(int i = 0; i < sets.length; i++) {
				output.add(sets[i].getStringValue1Array(0));
			}
		}
			
		return output;
	}

	public Set<Host> getListOfHosts(Date startDate, Date endDate,
			Set<String> filterByUsers, Set<String> filterByProduct,
			Set<String> filterByProject, Set<String> filterByHost,
			Set<String> filterBySubmitHost, Set<String> filterByFeature,
			Set<String> filterByAccountingGroups) {
		
		ListOfHostsInputDocument inputDocument = ListOfHostsInputDocument.Factory.newInstance();
		ListOfInputType input = inputDocument.addNewListOfHostsInput();
		setInput(input, 
				 startDate, 
				 endDate, 
				 filterByUsers, 
				 filterByProduct, 
				 filterByProject, 
				 filterByHost,
				 filterBySubmitHost, 
				 filterByFeature,
				 filterByAccountingGroups);

		ListOfHostsOutputDocument outputDocument = ListOfHostsOutputDocument.Factory.newInstance();
		
		try {
			 outputDocument = stub.getListOfHosts(inputDocument);
		} catch (AxisFault e) {
			return new HashSet<Host>();
		} catch (Exception e) {
			System.out.println("Error getting the list of Users: " + e);
		}
		
		Set<Host> output = new HashSet<Host>();
		
		if(outputDocument != null) {
			Host[] hosts = outputDocument.getListOfHostsOutput().getHostArray();
			
			for(int i = 0; i < hosts.length; i++) {
				Host host = (Host) hosts[i];
				output.add(host);
			}
		}
		
		return output; 
	}

	public Set<ProductType> getListOfProducts(Date startDate, Date endDate,
			Set<String> filterByUsers, Set<String> filterByProduct,
			Set<String> filterByProject, Set<String> filterByHost,
			Set<String> filterBySubmitHost, Set<String> filterByFeature,
			Set<String> filterByAccountingGroups) {
		
		ListOfProductsInputDocument inputDocument = ListOfProductsInputDocument.Factory.newInstance();
		ListOfInputType input = inputDocument.addNewListOfProductsInput();
		setInput(input, 
				 startDate, 
				 endDate, 
				 filterByUsers, 
				 filterByProduct, 
				 filterByProject, 
				 filterByHost,
				 filterBySubmitHost, 
				 filterByFeature,
				 filterByAccountingGroups);

		ListOfProductsOutputDocument outputDocument = ListOfProductsOutputDocument.Factory.newInstance();
		
		try {
			 outputDocument = stub.getListOfProducts(inputDocument);
		} catch (AxisFault e) {
			System.out.println("Exception getting the list of Products " + e);
			return new HashSet<ProductType>();
		} catch (Exception e) {
			System.out.println("Error getting the list of Users: " + e);
		}
		
		Set<ProductType> output = new HashSet<ProductType>();
		
		if(outputDocument != null) {
			ProductType[] products = outputDocument.getListOfProductsOutput().getProductTypeArray();
			for(int i = 0; i < products.length; i++) {
				output.add((ProductType) products[i]);
			}
		}
		
		return output; 
	}

	public Set<ProjectName> getListOfProjects(Date startDate, Date endDate,
			Set<String> filterByUsers, Set<String> filterByProduct,
			Set<String> filterByProject, Set<String> filterByHost,
			Set<String> filterBySubmitHost, Set<String> filterByFeature,
			Set<String> filterByAccountingGroups) {
		
		ListOfProjectsInputDocument inputDocument = ListOfProjectsInputDocument.Factory.newInstance();
		ListOfInputType input = inputDocument.addNewListOfProjectsInput();
		setInput(input, 
				 startDate, 
				 endDate, 
				 filterByUsers, 
				 filterByProduct, 
				 filterByProject, 
				 filterByHost,
				 filterBySubmitHost, 
				 filterByFeature,
				 filterByAccountingGroups);

		ListOfProjectsOutputDocument outputDocument = ListOfProjectsOutputDocument.Factory.newInstance();
		
		try {
			 outputDocument = stub.getListOfProjects(inputDocument);
		} catch (AxisFault e) {
			System.out.println("Exception getting the list of Projects " + e);
			return new HashSet<ProjectName>();
		} catch (Exception e) {
			System.out.println("Error getting the list of Projects: " + e);
		}
		
		Set<ProjectName> output = new HashSet<ProjectName>();
		
		if(outputDocument != null) {
			ProjectName[] projects = outputDocument.getListOfProjectsOutput().getProjectNameArray();
			for(int i = 0; i < projects.length; i++) {
				output.add( (ProjectName) projects[i]);
			}
		}
		
		return output; 
	}

	public Set<SmartLMUsageRecordType> getListOfSmartLMUsageRecords(
			Date startDate, Date endDate, Set<String> filterByUsers,
			Set<String> filterByProduct, Set<String> filterByProject,
			Set<String> filterByHost, Set<String> filterBySubmitHost,
			Set<String> filterByFeature, Set<String> filterByAccountingGroups) {
		
		ListOfSmartLMUsageRecordsInputDocument inputDocument = ListOfSmartLMUsageRecordsInputDocument.Factory.newInstance();
		ListOfInputType input = inputDocument.addNewListOfSmartLMUsageRecordsInput();
		setInput(input, 
				 startDate, 
				 endDate, 
				 filterByUsers, 
				 filterByProduct, 
				 filterByProject, 
				 filterByHost,
				 filterBySubmitHost, 
				 filterByFeature,
				 filterByAccountingGroups);

		ListOfSmartLMUsageRecordsOutputDocument outputDocument = ListOfSmartLMUsageRecordsOutputDocument.Factory.newInstance();
		
		try {
			 outputDocument = stub.getListOfSmartLMUsageRecords(inputDocument);
		} catch (AxisFault e) {
			System.out.println("Exception getting the list of usage records " + e);
			return new HashSet<SmartLMUsageRecordType>();
		} catch (Exception e) {
			System.out.println("Error getting the list of SmartLM Usage Records: " + e);
		}
		
		Set<SmartLMUsageRecordType> output = new HashSet<SmartLMUsageRecordType>();
		
		if(outputDocument != null) {
			SmartLMUsageRecordType[] smartLMUsageRecords = outputDocument.getListOfSmartLMUsageRecordsOutput().getSmartLMUsageRecordArray();
			for(int i = 0; i < smartLMUsageRecords.length; i++) {
				output.add( (SmartLMUsageRecordType) smartLMUsageRecords[i]);
			}
		}
		
		return output; 
	}

	public Set<FeatureType> getListOfSubmitFeatures(Date startDate,
			Date endDate, Set<String> filterByUsers,
			Set<String> filterByProduct, Set<String> filterByProject,
			Set<String> filterByHost, Set<String> filterBySubmitHost,
			Set<String> filterByFeature, Set<String> filterByAccountingGroups) {
		
		ListOfSubmitFeaturesInputDocument inputDocument = ListOfSubmitFeaturesInputDocument.Factory.newInstance();
		ListOfInputType input = inputDocument.addNewListOfSubmitFeaturesInput();
		setInput(input, 
				 startDate, 
				 endDate, 
				 filterByUsers, 
				 filterByProduct, 
				 filterByProject, 
				 filterByHost,
				 filterBySubmitHost, 
				 filterByFeature,
				 filterByAccountingGroups);

		ListOfSubmitFeaturesOutputDocument outputDocument = ListOfSubmitFeaturesOutputDocument.Factory.newInstance();
		
		try {
			 outputDocument = stub.getListOfSubmitFeatures(inputDocument);
		} catch (AxisFault e) {
			System.out.println("Exception getting the list of features" + e);
			return new HashSet<FeatureType>();
		} catch (Exception e) {
			System.out.println("Error getting the list of Features: " + e);
		}
		
		Set<FeatureType> output = new HashSet<FeatureType>();
		
		if(outputDocument != null) {
			FeatureType[] features = outputDocument.getListOfSubmitFeaturesOutput().getFeatureTypeArray();
			for(int i = 0; i < features.length; i++) {
				output.add((FeatureType) features[i]);
			}
		}
		
		return output; 
	}

	public Set<SubmitHost> getListOfSubmitHosts(Date startDate, Date endDate,
			Set<String> filterByUsers, Set<String> filterByProduct,
			Set<String> filterByProject, Set<String> filterByHost,
			Set<String> filterBySubmitHost, Set<String> filterByFeature,
			Set<String> filterByAccountingGroups) {
		
		ListOfSubmitHostsInputDocument inputDocument = ListOfSubmitHostsInputDocument.Factory.newInstance();
		ListOfInputType input = inputDocument.addNewListOfSubmitHostsInput();
		setInput(input, 
				 startDate, 
				 endDate, 
				 filterByUsers, 
				 filterByProduct, 
				 filterByProject, 
				 filterByHost,
				 filterBySubmitHost, 
				 filterByFeature,
				 filterByAccountingGroups);

		ListOfSubmitHostsOutputDocument outputDocument = ListOfSubmitHostsOutputDocument.Factory.newInstance();
		
		try {
			 outputDocument = stub.getListOfSubmitHosts(inputDocument);
		}catch (AxisFault e) {
			return new HashSet<SubmitHost>();
		} catch (Exception e) {
			System.out.println("Error getting the list of SubmitHosts: " + e);
		}
		
		Set<SubmitHost> output = new HashSet<SubmitHost>();
		
		if(outputDocument != null) {
			SubmitHost[] submitHosts = outputDocument.getListOfSubmitHostsOutput().getSubmitHostArray();
			for(int i = 0; i < submitHosts.length; i++) {
				output.add((SubmitHost) submitHosts[i]);
			}
		}
		
		return output; 
	}

	public Set<UserIdentity> getListOfUsers(Date startDate, Date endDate,
			Set<String> filterByUsers, Set<String> filterByProduct,
			Set<String> filterByProject, Set<String> filterByHost,
			Set<String> filterBySubmitHost, Set<String> filterByFeature,
			Set<String> filterByAccountingGroups) {
		
		ListOfUsersInputDocument inputDocument = ListOfUsersInputDocument.Factory.newInstance();
		ListOfInputType input = inputDocument.addNewListOfUsersInput();
		setInput(input, 
				 startDate, 
				 endDate, 
				 filterByUsers, 
				 filterByProduct, 
				 filterByProject, 
				 filterByHost,
				 filterBySubmitHost, 
				 filterByFeature,
				 filterByAccountingGroups);

		ListOfUsersOutputDocument outputDocument = ListOfUsersOutputDocument.Factory.newInstance();
		
		try {
			 outputDocument = stub.getListOfUsers(inputDocument);
		} catch (AxisFault e) {
			System.out.println("Exception getting the list of users: " + e);
			return new HashSet<UserIdentity>();
		} catch (Exception e) {
			System.out.println("Error getting the list of Users: " + e);
		}

		Set<UserIdentity> output = new HashSet<UserIdentity>();

		if(outputDocument != null) {
			UserIdentity[] users = outputDocument.getListOfUsersOutput().getUserIdentityArray();
			for(int i = 0; i < users.length; i++) {
				output.add((UserIdentity) users[i]);
			}
		}
		
		return output; 
	}
	
	private Calendar getCalendar(Date date) {
		Calendar calendar = Calendar.getInstance();
		calendar.setTime(date);
		
		return calendar;
	}
	
	private void setInput(ListOfInputType input,
						  Date startDate, Date endDate,
						  Set<String> filterByUsers, 
						  Set<String> filterByProduct,
						  Set<String> filterByProject, 
						  Set<String> filterByHost,
						  Set<String> filterBySubmitHost, 
						  Set<String> filterByFeature,
						  Set<String> filterByAccountingGroups) {
		
		input.setStartDate(getCalendar(startDate));
		input.setEndDate(getCalendar(endDate));
		
		String[] filterByUsersArray = new String[filterByUsers.size()];
		String[] filterByProductArray = new String[filterByProduct.size()];
		String[] filterByProjectArray = new String[filterByProject.size()];
		String[] filterByHostArray = new String[filterByProject.size()];
		String[] filterBySubmitHostArray = new String[filterBySubmitHost.size()];
		String[] filterByFeatureArray = new String[filterByFeature.size()];
		String[] filterByAccountingGroupsArray = new String[filterByAccountingGroups.size()];
		
		// Users
		int i = 0;
		for(String user : filterByUsers) {
			filterByUsersArray[i] = user;
			i++;
		}
		SetType setofUsers = input.addNewFilterByUser();
		setofUsers.setStringValue1Array(filterByUsersArray);
		input.setFilterByUser(setofUsers);
		
		// Product
		i = 0;
		for(String product : filterByProduct) {
			filterByProductArray[i] = product;
			i++;
		}
		SetType setOfProducts = input.addNewFilterByProduct();
		setOfProducts.setStringValue1Array(filterByProductArray);
		input.setFilterByProduct(setOfProducts);
		
		//Project
		i = 0;
		for(String project : filterByProject) {
			filterByProjectArray[i] = project;
			i++;
		}
		SetType setOfProjects = input.addNewFilterByProject();
		setOfProjects.setStringValue1Array(filterByProjectArray);
		input.setFilterByProject(setOfProjects);
			
		// Host
		i = 0;
		for(String host : filterByHost) {
			filterByHostArray[i] = host;
			i++;
		}
		SetType setOfHosts = input.addNewFilterByHost();
		setOfHosts.setStringValue1Array(filterByHostArray);
		input.setFilterByHost(setOfHosts);
		
		//SubmitHost
		i = 0;
		for(String submitHost : filterBySubmitHost) {
			filterBySubmitHostArray[i] = submitHost;
			i++;
		}
		SetType setOfSubmitHosts = input.addNewFilterBySubmitHost();
		setOfSubmitHosts.setStringValue1Array(filterBySubmitHostArray);
		input.setFilterBySubmitHost(setOfSubmitHosts);
		
		// Feature
		i = 0;
		for(String feature : filterByFeature) {
			filterByFeatureArray[i] = feature;
			i++;
		}
		SetType setOfFeatures = input.addNewFilterByFeature();
		setOfFeatures.setStringValue1Array(filterByFeatureArray);
		input.setFilterByFeature(setOfFeatures);
		
		// Accounting Groups
		i = 0;
		for(String accountingGroup : filterByAccountingGroups) {
			filterByAccountingGroupsArray[i] = accountingGroup;
			i++;
		}
		SetType setOfAccountingGroups = input.addNewFilterByAccountingGroups();
		setOfAccountingGroups.setStringValue1Array(filterByAccountingGroupsArray);
		input.setFilterByAccountingGroups(setOfAccountingGroups);		
	}
}