package org.gcube.dataharvest.harvester.sobigdata;

import java.text.ParseException;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Date;
import java.util.List;
import java.util.SortedSet;

import org.gcube.accounting.accounting.summary.access.model.ScopeDescriptor;
import org.gcube.accounting.accounting.summary.access.model.update.AccountingRecord;
import org.gcube.common.storagehub.client.dsl.ContainerType;
import org.gcube.common.storagehub.client.dsl.FolderContainer;
import org.gcube.common.storagehub.client.dsl.ItemContainer;
import org.gcube.common.storagehub.client.dsl.ListResolverTyped;
import org.gcube.common.storagehub.client.dsl.StorageHubClient;
import org.gcube.common.storagehub.model.items.FolderItem;
import org.gcube.common.storagehub.model.items.Item;
import org.gcube.common.storagehub.model.items.nodes.Accounting;
import org.gcube.common.storagehub.model.items.nodes.accounting.AccountEntry;
import org.gcube.dataharvest.AccountingDashboardHarvesterPlugin;
import org.gcube.dataharvest.datamodel.HarvestedDataKey;
import org.gcube.dataharvest.utils.DateUtils;
import org.gcube.dataharvest.utils.Utils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * The Class DataMethodDownloadHarvester.
 *
 * @author Eric Perrone (ISTI - CNR)
 * @author Luca Frosini (ISTI - CNR)
 * @author Francesco Mangiacrapa (ISTI - CNR)
 */
public class DataMethodDownloadHarvester extends SoBigDataHarvester {
	
	private static Logger logger = LoggerFactory.getLogger(DataMethodDownloadHarvester.class);
	
	private int count = 0;
	
	/**
	 * Instantiates a new data method download harvester.
	 *
	 * @param start the start
	 * @param end the end
	 * @param contexts the contexts
	 * @throws ParseException the parse exception
	 */
	public DataMethodDownloadHarvester(Date start, Date end, SortedSet<String> contexts) throws Exception {
		super(start, end, contexts);
	}
	
	/* (non-Javadoc)
	 * @see org.gcube.dataharvest.harvester.BasicHarvester#getData()
	 */
	@Override
	public List<AccountingRecord> getAccountingRecords() throws Exception {
		String defaultContext = Utils.getCurrentContext();
		logger.debug("The context is {}", defaultContext);
		
		try {
			/*
			String vreName = getVRENameToHL(defaultContext);
			logger.debug("Getting VRE Name to HL from context/scope returns {} ", vreName);
			
			String user = vreName + "-Manager";
			logger.debug("Using user '{}' to getHome from HL", user);
			
			//Getting HL instance and home for VRE MANAGER
			HomeManager manager = HomeLibrary.getHomeManagerFactory().getHomeManager();
			@SuppressWarnings("deprecation")
			Home home = manager.getHome(user);
			JCRWorkspace ws = (JCRWorkspace) home.getWorkspace();
			
			String path = "/Workspace/MySpecialFolders/" + vreName;
			logger.debug("Getting item by Path {}", path);
			JCRWorkspaceItem item = (JCRWorkspaceItem) ws.getItemByPath(path);
			*/
			
			StorageHubClient storageHubClient = new StorageHubClient();
			FolderContainer vreFolderContainer = storageHubClient.openVREFolder();
			
			FolderItem vreFolderItem = vreFolderContainer.get();
			
			logger.debug("Analyzing {} in the period [{} to {}] starting from root {}", defaultContext,
					DateUtils.format(start), DateUtils.format(end), vreFolderItem.getName());
			
			
			ScopeDescriptor defaultScopeDescriptor = AccountingDashboardHarvesterPlugin.getScopeDescriptor();
			
			
			AccountingRecord defaultHarvesteData = new AccountingRecord(defaultScopeDescriptor, instant, getDimension(HarvestedDataKey.DATA_METHOD_DOWNLOAD), (long) count);
			logger.debug("{} : {}", defaultHarvesteData.getDimension().getId(), defaultHarvesteData.getMeasure());
						
			ArrayList<AccountingRecord> accountingRecords = new ArrayList<AccountingRecord>();
			
			ListResolverTyped listResolverTyped = vreFolderContainer.list();
			List<ItemContainer<? extends Item>> containers = listResolverTyped.includeHidden().getContainers();
			for(ItemContainer<? extends Item> itemContainer : containers) {
			
			
				count = 0; //resettings the counter
				
				//HarvestedData harvestedData;
				
				//Getting statistics for folder
				if(itemContainer.getType() == ContainerType.FOLDER) {
					Item item = itemContainer.get();
					logger.debug("Getting statistics for folder {}", item.getName());
					getStats(itemContainer, start, end);
					
					String normalizedName = item.getName().replaceAll("[^A-Za-z0-9]", "");
					String context = mapWsFolderNameToVRE.get(normalizedName);
					//Checking if it is a VRE name to right accounting...
					if(context != null && !context.isEmpty()) {
						logger.debug("Found context '{}' matching with normalized VRE name {} ", context, normalizedName);
						
						ScopeDescriptor scopeDescriptor = AccountingDashboardHarvesterPlugin.getScopeDescriptor(context);
						AccountingRecord ar = new AccountingRecord(scopeDescriptor, instant, getDimension(HarvestedDataKey.DATA_METHOD_DOWNLOAD), (long) count);
						logger.debug("{} : {}", ar.getDimension().getId(), ar.getMeasure());
						accountingRecords.add(ar);
						
					} else {
						logger.debug(
								"No scope found matching the folder name {}, accounting its stats in the default context {}",
								normalizedName, defaultContext);
						//INCREASING THE DEFAULT CONTEXT COUNTER...
						defaultHarvesteData.setMeasure(defaultHarvesteData.getMeasure() + count);
						logger.trace("Increased default context stats {}", defaultHarvesteData);
					}
					
				}
			}
			
			//ADDING DEFAULT ACCOUNTING
			accountingRecords.add(defaultHarvesteData);
			
			
			logger.debug("In the period [from {} to {} ] returning workspace accouting data {}", DateUtils.format(start),
					DateUtils.format(end), accountingRecords);
			
			return accountingRecords;
			
		} catch(Exception e) {
			throw e;
		}
		
	}
	
	/**
	 * Gets the stats.
	 *
	 * @param baseItem the base item
	 * @param start the start
	 * @param end the end
	 * @return the stats
	 * @throws InternalErrorException the internal error exception
	 */
	private void getStats(ItemContainer<? extends Item> itemContainer, Date start, Date end) throws Exception {
		if(itemContainer.getType() == ContainerType.FOLDER) {
			
			ListResolverTyped listResolverTyped = ((FolderContainer)itemContainer).list();
			List<ItemContainer<? extends Item>> containers = listResolverTyped.includeHidden().getContainers();
			for(ItemContainer<? extends Item> itemCont : containers) {
				getStats(itemCont , start, end);
			}
			
		} else {
			try {
				Accounting accounting = itemContainer.get().getAccounting();
				for(AccountEntry entry : accounting.getEntries()) {
					
					switch(entry.getType()) {
						case CREATE:
						case UPDATE:
						case READ:
							Calendar calendar = entry.getDate();
							if(calendar.after(DateUtils.dateToCalendar(start))
									&& calendar.before(DateUtils.dateToCalendar(end))) {
								count++;
							}
							
							break;
						
						default:
							break;
					}
					
				}
			} catch(Exception e) {
				throw e;
			}
		}
	}
	
}