/**
 * 
 */
package org.gcube.accounting.aggregation.strategy;

import org.gcube.accounting.aggregation.strategy.ServiceUsageRecordAggregationStrategy;
import org.gcube.accounting.datamodel.basetypes.TestUsageRecord;
import org.gcube.accounting.datamodel.usagerecords.ServiceUsageRecord;
import org.gcube.accounting.exception.InvalidValueException;
import org.gcube.accounting.exception.NotAggregatableRecordsExceptions;
import org.junit.Assert;
import org.junit.Test;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * @author Luca Frosini (ISTI - CNR) http://www.lucafrosini.com/
 *
 */
public class ServiceUsageRecordAggregationStrategyTest {
	
	
	private static Logger logger = LoggerFactory.getLogger(ServiceUsageRecordAggregationStrategyTest.class);
	
	@Test
	public void secondAsNotAggregated() throws InvalidValueException, NotAggregatableRecordsExceptions {
		
		ServiceUsageRecord serviceUsageRecord = TestUsageRecord.createTestServiceUsageRecord();
		serviceUsageRecord.setResourceProperty(TestUsageRecord.TEST_PROPERTY_NAME, TestUsageRecord.TEST_PROPERTY_VALUE);
		serviceUsageRecord.validate();
		logger.debug("ServiceUsageRecord : {}", serviceUsageRecord);
		
		org.gcube.accounting.aggregation.ServiceUsageRecord aggregated = 
				new org.gcube.accounting.aggregation.ServiceUsageRecord(serviceUsageRecord);
		logger.debug("ServiceUsageRecord Converted to Aggregated: {}", aggregated);
		aggregated.validate();
		
		ServiceUsageRecord serviceUsageRecord2 = TestUsageRecord.createTestServiceUsageRecord();
		serviceUsageRecord2.validate();
		logger.debug("ServiceUsageRecord 2 : {}", serviceUsageRecord2);
		ServiceUsageRecordAggregationStrategy suras = new ServiceUsageRecordAggregationStrategy(aggregated);

		long firstDuration = serviceUsageRecord.getDuration();
		long secondDuration = serviceUsageRecord2.getDuration();
		
		suras.aggregate(serviceUsageRecord2);
		logger.debug("Resulting Aggregated ServiceUsageRecord: {}", aggregated);
		aggregated.validate();
		
		Assert.assertTrue(aggregated.getDuration() == ((firstDuration + secondDuration)/2));
		Assert.assertTrue(aggregated.getOperationCount() == 2);
		
		if(firstDuration >= secondDuration){
			Assert.assertTrue(aggregated.getMaxInvocationTime() == firstDuration);
			Assert.assertTrue(aggregated.getMinInvocationTime() == secondDuration);
		}else{
			Assert.assertTrue(aggregated.getMaxInvocationTime() == secondDuration);
			Assert.assertTrue(aggregated.getMinInvocationTime() == firstDuration);
		}
		
		Assert.assertFalse(aggregated.getResourceProperties().containsKey(TestUsageRecord.TEST_PROPERTY_NAME));
		
		
	}
	
	@Test
	public void secondAsAggregated() throws InvalidValueException, NotAggregatableRecordsExceptions {
		
		ServiceUsageRecord serviceUsageRecord = TestUsageRecord.createTestServiceUsageRecord();
		serviceUsageRecord.validate();
		logger.debug("ServiceUsageRecord : {}", serviceUsageRecord);
		
		org.gcube.accounting.aggregation.ServiceUsageRecord aggregated = 
				new org.gcube.accounting.aggregation.ServiceUsageRecord(serviceUsageRecord);
		logger.debug("ServiceUsageRecord Converted to Aggregated: {}", aggregated);
		aggregated.validate();
		
		ServiceUsageRecord serviceUsageRecord2 = TestUsageRecord.createTestServiceUsageRecord();
		serviceUsageRecord2.setResourceProperty(TestUsageRecord.TEST_PROPERTY_NAME, TestUsageRecord.TEST_PROPERTY_VALUE);
		serviceUsageRecord2.validate();
		logger.debug("ServiceUsageRecord 2 : {}", serviceUsageRecord2);
		org.gcube.accounting.aggregation.ServiceUsageRecord converted = 
				new org.gcube.accounting.aggregation.ServiceUsageRecord(serviceUsageRecord2);
		logger.debug("ServiceUsageRecord 2 Converted to Aggregated: {}", converted);
		converted.validate();
		
		ServiceUsageRecordAggregationStrategy suras = new ServiceUsageRecordAggregationStrategy(aggregated);
		
		long firstduration = aggregated.getDuration();
		long secondDuration = converted.getDuration();
		
		suras.aggregate(converted);
		logger.debug("Resulting Aggregated ServiceUsageRecord: {}", aggregated);
		aggregated.validate();
		
		Assert.assertTrue(aggregated.getDuration() == ((firstduration + secondDuration)/2));
		Assert.assertTrue(aggregated.getOperationCount() == 2);
		
		if(firstduration >= secondDuration){
			Assert.assertTrue(aggregated.getMaxInvocationTime() == firstduration);
			Assert.assertTrue(aggregated.getMinInvocationTime() == secondDuration);
		}else{
			Assert.assertTrue(aggregated.getMaxInvocationTime() == secondDuration);
			Assert.assertTrue(aggregated.getMinInvocationTime() == firstduration);
		}
		Assert.assertFalse(aggregated.getResourceProperties().containsKey(TestUsageRecord.TEST_PROPERTY_NAME));
	}
	
	@Test
	public void aggregationStressTest() throws InvalidValueException, NotAggregatableRecordsExceptions {
		
		ServiceUsageRecord serviceUsageRecord = TestUsageRecord.createTestServiceUsageRecord();
		serviceUsageRecord.setResourceProperty(TestUsageRecord.TEST_PROPERTY_NAME, TestUsageRecord.TEST_PROPERTY_VALUE);
		serviceUsageRecord.validate();
		logger.debug("ServiceUsageRecord : {}", serviceUsageRecord);
		
		org.gcube.accounting.aggregation.ServiceUsageRecord aggregated = 
				new org.gcube.accounting.aggregation.ServiceUsageRecord(serviceUsageRecord);
		logger.debug("ServiceUsageRecord Converted to Aggregated: {}", aggregated);
		aggregated.validate();
		
		ServiceUsageRecordAggregationStrategy suras = new ServiceUsageRecordAggregationStrategy(aggregated);
		
		for(int i=2; i<1002; i++){
			
			ServiceUsageRecord sur = TestUsageRecord.createTestServiceUsageRecord();
			sur.setResourceProperty(TestUsageRecord.TEST_PROPERTY_NAME, TestUsageRecord.TEST_PROPERTY_VALUE);
			sur.validate();
			logger.debug("Cycle ServiceUsageRecord {}: {}", i, sur);
			
			long minInvocationTime = aggregated.getMinInvocationTime();
			long maxInvocationTime = aggregated.getMaxInvocationTime();
			long oldDuration = aggregated.getDuration();
			long newDuration = sur.getDuration();
			
			suras.aggregate(sur);
			logger.debug("Resulting Aggregated ServiceUsageRecord: {}", aggregated);
			aggregated.validate();
			
			Assert.assertTrue(aggregated.getDuration() == ((oldDuration + newDuration)/2));
			Assert.assertTrue(aggregated.getOperationCount() == i);
			
			if(minInvocationTime >= newDuration){
				Assert.assertTrue(aggregated.getMinInvocationTime() == newDuration);
			}else{
				Assert.assertTrue(aggregated.getMinInvocationTime() == minInvocationTime);
			}
			
			if(maxInvocationTime >= newDuration){
				Assert.assertTrue(aggregated.getMaxInvocationTime() == maxInvocationTime);
			}else{
				Assert.assertTrue(aggregated.getMaxInvocationTime() == newDuration);
			}
			
			Assert.assertFalse(aggregated.getResourceProperties().containsKey(TestUsageRecord.TEST_PROPERTY_NAME));
		}
		
		logger.debug("Resulting Aggregated ServiceUsageRecord: {}", aggregated);
	}
	
}