package eu.dnetlib.goldoa.service;

import com.sun.org.apache.xpath.internal.operations.Bool;
import eu.dnetlib.goldoa.domain.*;
import eu.dnetlib.goldoa.service.dao.RequestDAO;
import eu.dnetlib.goldoa.service.utils.EmailUtils;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.jboss.logging.annotations.Pos;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.dao.EmptyResultDataAccessException;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;

import javax.annotation.PostConstruct;
import javax.mail.MessagingException;
import java.io.IOException;
import java.io.InputStream;
import java.math.BigInteger;
import java.sql.Timestamp;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Date;
import java.util.List;
import java.util.concurrent.ExecutorService;

/*
 * Created by antleb on 3/10/15.
*/


@Transactional
@Service("requestManager")
public class RequestManagerImpl implements RequestManager {

	@Autowired
	private RequestDAO requestDAO;
	@Autowired
	private UserManager userManager;
	@Autowired
	private OrganizationManager organizationManager;
	@Autowired
	private ProjectManager projectManager;
	@Autowired
	private PublicationManager publicationManager;
	@Autowired
	private InvoiceManager invoiceManager;
	@Autowired
	private BudgetManager budgetManager;
	@Autowired
	private EligibilityManager eligibilityManager;
	@Autowired
	private EmailUtils emailUtils;
	@Autowired
	private ExecutorService executorService;
	@Autowired
	private SearchManager searchManager;
	@Autowired
	private PublisherManager publisherManager;


	@Value("${goldoa.sendCoordinatorEmails}")
	private String sendCoordinatorEmails ;//= false;
	@Value("${goldoa.sendEvaEmail}")
	private String sendEvaEmail ;//= false;
	@Value("${goldoa.evaEmail}")
	private String evaEmail;// = null;

	@Value("${goldoa.pendingemails}")
	private String pendingemails;

	private Log LOGGER = LogFactory.getLog(RequestManagerImpl.class);

	@PostConstruct
	public void init(){
		LOGGER.debug("Pending emails: " + pendingemails);
	}

	@Override
	public Request saveRequest(final Request request) {

		if (request.getId() == null) {
			request.setId(new SimpleDateFormat("yyyyMMdd-").format(new Date()) + requestDAO.getRequestId());
			Budget budget = null;
			/*if(request.getPublisher() != null)
				budget = budgetManager.getForRequest(request.getOrganization().getId(),
						request.getPublisher().getEmail());

			if (budget != null) {
				request.setBudget(budget);
				// TODO fix amounts
				budget.setRemaining(budget.getRemaining() - request.getFundingRequested());
				budgetManager.saveBudget(budget);
			}*/
		}
		request.setEligibility(eligibilityManager.validate(request));
		requestDAO.saveRequest(request);
		return request;
	}

	@Override
	public Request getById(String requestId) {
		return 	requestDAO.getRequest(requestId);
	}

	@Override
	public RequestPage getForUser(String email, Date fromDate, Date toDate, RequestSort requestSortBy, RequestSortOrder order, RequestFilter requestFilter, String term, Request.RequestStatus[] statusFilter, int from, int to) {
		RequestPage requests = requestDAO.getForUser(email, fromDate, toDate, requestSortBy, order, requestFilter, term, statusFilter, from, to);
		return requests;
	}

	@Override
	public RequestPage getForPublisher(String publisherId, Date fromDate, Date toDate, RequestSort requestSortBy, RequestSortOrder order, RequestFilter requestFilter, String term, Request.RequestStatus[] statusFilter, int from, int to) {
		RequestPage requests = requestDAO.getForPublisher(publisherId, fromDate, toDate, requestSortBy, order, requestFilter, term, statusFilter, from, to);
		return requests;
	}

	@Override
	public RequestPage getForOrganization(List<String> organizationIds, Date fromDate, Date toDate, RequestSort requestSortBy, RequestSortOrder order, RequestFilter requestFilter, String term, Request.RequestStatus[] statusFilter, int from, int to) {
		RequestPage requests = requestDAO.getForOrganization(organizationIds, fromDate, toDate, requestSortBy, order, requestFilter, term, statusFilter, from, to);
		return requests;
	}

	@Override
	public List<Request> getForProject(String projectId) {
		return requestDAO.getForProject(projectId);
	}

	@Override
	public String getCSV(String mode, RequestSort requestSortBy, RequestSortOrder order, RequestFilter requestFilter, String term, Request.RequestStatus[] statusFilter) {
		Integer[] statuses = null;

		if ("moderator".equals(mode)) {
			if (statusFilter == null || statusFilter.length == 0) {

			} else {
				statuses = new Integer[statusFilter.length];

				for (int i = 0; i < statusFilter.length; i++) {
					statuses[i] = statusFilter[i].getCode();
				}
			}
		} else if ("accounting".equals(mode)) {
			if (statusFilter == null || statusFilter.length == 0)
				statuses = new Integer[] {
						Request.RequestStatus.APPROVED.getCode(),
						Request.RequestStatus.ACCOUNTING_PROCESSING.getCode(),
						Request.RequestStatus.ACCOUNTING_ON_HOLD.getCode(),
						Request.RequestStatus.ACCOUNTING_DENIED.getCode(),
						Request.RequestStatus.ACCOUNTING_PAID.getCode()};

			else {
				statuses = new Integer[statusFilter.length];

				for (int i = 0; i < statusFilter.length; i++) {
					Request.RequestStatus s = statusFilter[i];

					statuses[i] = s.getCode();
				}
			}
		}

		try {
			return requestDAO.getCSV(requestSortBy, order, requestFilter, term, statuses);
		} catch (IOException e) {
			e.printStackTrace();

			return e.getMessage();
		}
	}

	@Override
	public RequestPage getRequests(Date fromDate, Date toDate, RequestSort requestSortBy, RequestSortOrder order, RequestFilter requestFilter, String term, Request.RequestStatus[] statusFilter, int from, int to) {
		RequestPage requestPage = requestDAO.getRequests(fromDate, toDate, requestSortBy, order, requestFilter, term, statusFilter, from, to);
		return requestPage;
	}

	@Override
	public RequestPage getForAccounting(Date fromDate, Date toDate, RequestSort requestSortBy, RequestSortOrder order, RequestFilter requestFilter, String term, Request.RequestStatus[] statusFilter, int from, int to) {
		Integer[] statuses;

		if (statusFilter == null || statusFilter.length == 0)
			statuses = new Integer[] {Request.RequestStatus.APPROVED.getCode(), Request.RequestStatus.ACCOUNTING_PROCESSING.getCode(), Request.RequestStatus.ACCOUNTING_ON_HOLD.getCode()
			, Request.RequestStatus.ACCOUNTING_DENIED.getCode(), Request.RequestStatus.ACCOUNTING_PAID.getCode()};

		else {
			statuses = new Integer[statusFilter.length];

			for (int i = 0; i < statusFilter.length; i++) {
				Request.RequestStatus s = statusFilter[i];

				statuses[i] = s.getCode();
			}
		}

		RequestPage requests = requestDAO.getRequests(fromDate, toDate, requestSortBy, order, requestFilter, term, statuses, from, to);
		return requests;
	}

	@Override
	public Request submitRequest(final Request request) {

		if (request.getBudget() != null) {
            Budget budget = request.getBudget();

			/*Organization organization = budget.getOrganizations().get(0);
			if (organization != null)
				request.setStatus(Request.RequestStatus.LIBRARY_FUND_SUBMITTED);
			else if (budget.getPublisher() != null)
				request.setStatus(Request.RequestStatus.PUBLISHER_FUND_SUBMITTED);*/
		} else {
			request.setStatus(Request.RequestStatus.SUBMITTED);
		}
		request.setSubmissiondate(new Timestamp(new Date().getTime()));
		request.setEligibility(eligibilityManager.validate(request));
		requestDAO.submitRequest(request);


		final List<User> moderators = userManager.getModerators();
		executorService.submit(new Runnable() {
			@Override
			public void run() {
				try {
					switch (request.getEligibility().getStatus()) {
						case OK:
							emailUtils.sendRequesterOKEmail(request);
							for (User user : moderators)
								emailUtils.sendModeratorOKEmail(request, user);
							break;
						case IFFY:
							emailUtils.sendRequesterIFFYEmail(request);
							for (User user : moderators)
								emailUtils.sendModeratorIFFYEmail(request, user);
							break;
						case NONO:
							break;
					}

					if (Boolean.parseBoolean(sendCoordinatorEmails)) {
						for (User  coordinator : request.getProject().getCoordinators())
							emailUtils.sendCoordinatorRequestSubmittedEmail(coordinator, request);
					}
				} catch (MessagingException e) {
					e.printStackTrace();
				} catch (Exception e) {
					e.printStackTrace();
				}
			}
		});

		return request;
	}

	@Override
	public Request submitLibraryRequest(final Request request) throws PersonManagerException {
		request.setStatus(Request.RequestStatus.LIBRARY_FUND_SUBMITTED);
		request.setSubmissiondate(new Timestamp(new Date().getTime()));

//		requestDAO.submitRequest(request.getId());

		saveRequest(request);

//		executorService.submit(new Runnable() {
//			@Override
//			public void run() {
//				RequestInfo requestInfo = null;
//				try {
//					requestInfo = getRequestInfo(request);
//
//					switch (requestInfo.getEligibility().getStatus()) {
//						case OK:
//							emailUtils.sendRequesterOKEmail(requestInfo);
//
//							for (Person person : personManager.getModerators())
//								emailUtils.sendModeratorOKEmail(requestInfo, person);
//							break;
//						case IFFY:
//							emailUtils.sendRequesterIFFYEmail(requestInfo);
//
//							for (Person person : personManager.getModerators())
//								emailUtils.sendModeratorIFFYEmail(requestInfo, person);
//							break;
//						case NONO:
//							break;
//					}
//
//					if (sendCoordinatorEmails) {
//						for (Person coordinator : requestInfo.getProject().getCoordinators())
//							emailUtils.sendCoordinatorRequestSubmittedEmail(coordinator, requestInfo);
//					}
//				} catch (MessagingException e) {
//					e.printStackTrace();
//				} catch (PersonManagerException e) {
//					e.printStackTrace();
//				} catch (Exception e) {
//					e.printStackTrace();
//				}
//			}
//		});

		return request;
	}

	@Override
	public Request submitPublisherRequest(Request request) throws PersonManagerException {
        request.setStatus(Request.RequestStatus.PUBLISHER_FUND_SUBMITTED);
        request.setSubmissiondate(new Timestamp(new Date().getTime()));

//		requestDAO.submitRequest(request.getId());

		saveRequest(request);

//		executorService.submit(new Runnable() {
//			@Override
//			public void run() {
//				RequestInfo requestInfo = null;
//				try {
//					requestInfo = getRequestInfo(request);
//
//					switch (requestInfo.getEligibility().getStatus()) {
//						case OK:
//							emailUtils.sendRequesterOKEmail(requestInfo);
//
//							for (Person person : personManager.getModerators())
//								emailUtils.sendModeratorOKEmail(requestInfo, person);
//							break;
//						case IFFY:
//							emailUtils.sendRequesterIFFYEmail(requestInfo);
//
//							for (Person person : personManager.getModerators())
//								emailUtils.sendModeratorIFFYEmail(requestInfo, person);
//							break;
//						case NONO:
//							break;
//					}
//
//					if (sendCoordinatorEmails) {
//						for (Person coordinator : requestInfo.getProject().getCoordinators())
//							emailUtils.sendCoordinatorRequestSubmittedEmail(coordinator, requestInfo);
//					}
//				} catch (MessagingException e) {
//					e.printStackTrace();
//				} catch (PersonManagerException e) {
//					e.printStackTrace();
//				} catch (Exception e) {
//					e.printStackTrace();
//				}
//			}
//		});

		return request;
	}

	@Override
	public void conditionallyApproveRequest(final String requestId, final String email, final String comment, String template) {
		User user = null;
		try {
			user = userManager.getByEmail(email);
		} catch (PersonManagerException e) {
			e.printStackTrace();
		}
		requestDAO.conditionallyApproveRequest(requestId, user, comment, template);

		final Request request = getById(requestId);
		executorService.submit(new Runnable() {
			@Override
			public void run() {
				try {
					emailUtils.sendRequesterInitiallyApprovedEmail(request);
				} catch (MessagingException e) {
					e.printStackTrace();
				}
			}
		});
	}

	@Override
	public void approveRequest(final String requestId, final String email, final String comment, String template) {
		User user = null;
		try {
			user = userManager.getByEmail(email);
		} catch (PersonManagerException e) {
			e.printStackTrace();
		}
		requestDAO.approveRequest(requestId, user, comment, template);

		final Request request = getById(requestId);
		executorService.submit(new Runnable() {
			@Override
			public void run() {
				try {
					emailUtils.sendRequesterApprovedEmail(request);
				} catch (MessagingException e) {
					e.printStackTrace();
				}
				if (request.getInvoice() == null) {
					try {
						emailUtils.sendRequesterInvoiceNotification(request);
						emailUtils.sendPublisherInvoiceNotification(request);
					} catch (MessagingException e) {
						e.printStackTrace();
					}
				} else {
					try {
						for (User user : userManager.getAccountingOfficers())
							emailUtils.sendAccountingRequestApprovedEmail(user, request);
					} catch (MessagingException e) {
						e.printStackTrace();
					}
				}
			}
		});
	}

	@Override
	public void rejectRequest(final String requestId, String email, String comment, String template) {
		User user = null;
		try {
			user = userManager.getByEmail(email);
		} catch (PersonManagerException e) {
			e.printStackTrace();
		}
		requestDAO.rejectRequest(requestId, user, comment, template);
		final Request request = getById(requestId);
		executorService.submit(new Runnable() {
			@Override
			public void run() {
				try {
					emailUtils.sendRequesterRejectedEmail(request);
				} catch (MessagingException e) {
					e.printStackTrace();
				}
			}
		});
	}

	@Override
	public void processingRequest(final String requestId, String email, String comment, String template) {
		User user = null;
		try {
			user = userManager.getByEmail(email);
		} catch (PersonManagerException e) {
			e.printStackTrace();
		}
		requestDAO.processingRequest(requestId, user, comment, template);
		final Request request = getById(requestId);
		executorService.submit(new Runnable() {
			@Override
			public void run() {
				try {
					for (User user : userManager.getModerators())
						emailUtils.sendModeratorProcessingEmail(user, request);

				} catch (MessagingException e) {
					e.printStackTrace();
				}
			}
		});
	}

	@Override
	public void paidRequest(final String requestId, String email, String comment, String template, float apc_paid,
							float transfer_cost, float other_cost, Date datePaid) {
		User user = null;
		try {
			user = userManager.getByEmail(email);
		} catch (PersonManagerException e) {
			e.printStackTrace();
		}

		requestDAO.paidRequest(requestId, user, comment, template, apc_paid, transfer_cost, other_cost, datePaid);
		final Request request = getById(requestId);
		executorService.submit(new Runnable() {
			@Override
			public void run() {

				try {
					emailUtils.sendRequesterPaidEmail(request);
					emailUtils.sendPublisherPaidEmail(request);

					for (User user : userManager.getModerators())
						emailUtils.sendModeratorPaidEmail(user, request);

					if (Boolean.parseBoolean(sendEvaEmail))
						emailUtils.sendEvaPaidEmail(evaEmail, request);

				} catch (MessagingException e) {
					e.printStackTrace();
				}
			}
		});
	}

	@Override
	public void paidLibraryRequest(String requestId, String email, String comment, String template, float apc_paid, float transfer_cost, float other_cost, Date datePaid) {
		User user = null;
		try {
			user = userManager.getByEmail(email);
		} catch (PersonManagerException e) {
			e.printStackTrace();
		}
		requestDAO.paidLibraryRequest(requestId, user, comment, template, apc_paid, transfer_cost, other_cost, datePaid);

//		executorService.submit(new Runnable() {
//			@Override
//			public void run() {
//				RequestInfo requestInfo = getById(requestId);
//
//				try {
//					emailUtils.sendRequesterPaidEmail(requestInfo);
//					emailUtils.sendPublisherPaidEmail(requestInfo);
//
//					for (Person person : personManager.getModerators())
//						emailUtils.sendModeratorPaidEmail(person, requestInfo);
//
//					if (sendEvaEmail)
//						emailUtils.sendEvaPaidEmail(evaEmail, requestInfo);
//
//				} catch (MessagingException e) {
//					e.printStackTrace();
//				}
//			}
//		});
	}

	@Override
	public void paidPublisherRequest(String requestId, String email, String comment,
									 String template, float apc_paid, float transfer_cost, float other_cost, Date datePaid) {
		User user = null;
		try {
			user = userManager.getByEmail(email);
		} catch (PersonManagerException e) {
			e.printStackTrace();
		}
		requestDAO.paidPublisherRequest(requestId, user, comment, template, apc_paid, transfer_cost, other_cost, datePaid);

		//		executorService.submit(new Runnable() {
//			@Override
//			public void run() {
//				RequestInfo requestInfo = getById(requestId);
//
//				try {
//					emailUtils.sendRequesterPaidEmail(requestInfo);
//					emailUtils.sendPublisherPaidEmail(requestInfo);
//
//					for (Person person : personManager.getModerators())
//						emailUtils.sendModeratorPaidEmail(person, requestInfo);
//
//					if (sendEvaEmail)
//						emailUtils.sendEvaPaidEmail(evaEmail, requestInfo);
//
//				} catch (MessagingException e) {
//					e.printStackTrace();
//				}
//			}
//		});
	}

	@Override
	public void onHoldRequest(final String requestId, String email, String comment, String template) {
		User user = null;
		try {
			user = userManager.getByEmail(email);
		} catch (PersonManagerException e) {
			e.printStackTrace();
		}
		requestDAO.onHoldRequest(requestId, user, comment, template);

		final Request request = getById(requestId);
		executorService.submit(new Runnable() {
			@Override
			public void run() {
				try {
					emailUtils.sendRequesterOnHoldEmail(request);
					emailUtils.sendPublisherOnHoldEmail(request);

					for (User user : userManager.getModerators())
						emailUtils.sendModeratorOnHoldEmail(user, request);
				} catch (MessagingException e) {
					e.printStackTrace();
				}
			}
		});
	}

	@Override
	public void deniedRequest(final String requestId, String email, String comment, String template) {
		User user = null;
		try {
			user = userManager.getByEmail(email);
		} catch (PersonManagerException e) {
			e.printStackTrace();
		}
		requestDAO.deniedRequest(requestId, user, comment, template);
		final Request request = getById(requestId);
		executorService.submit(new Runnable() {
			@Override
			public void run() {
				try {
					emailUtils.sendRequesterDeniedEmail(request);
					emailUtils.sendPublisherDeniedEmail(request);

					for (User user : userManager.getModerators())
						emailUtils.sendModeratorDeniedEmail(user, request);
				} catch (MessagingException e) {
					e.printStackTrace();
				}
			}
		});
	}

	@Override
	public Invoice invoiceUploaded(final String requestId, String invoiceId) throws ManagerException {

		final Request request = getById(requestId);

		final List<User> moderators = userManager.getModerators();
		executorService.submit(new Runnable() {
			@Override
			public void run() {
				if (request.getStatus() == Request.RequestStatus.CONDITIONALLY_APPROVED) {
					try {
						for (User user : moderators)
							emailUtils.sendModeratorInvoiceUploaded(user, request);
					} catch (MessagingException e) {
						e.printStackTrace();
					}
				}
			}
		});
		return invoiceManager.getInvoice(invoiceId);
	}

	@Override
	public void uploadTransferReceipt(String requestid, String contentType, InputStream inputStream) {
		requestDAO.uploadBankTransferReceipt(requestid, contentType, inputStream);
	}


	public BankTransferReceipt downloadBankTransferReceipt(String requestId) throws RequestManagerException {
		try {
			return requestDAO.downloadBankTransferReceipt(requestId);
		} catch (EmptyResultDataAccessException e) {
			throw new RequestManagerException(RequestManagerException.ErrorCause.NOT_EXISTS);
		}
	}


	public List<CommentTemplate> getCommentTemplates(Request.RequestStatus requestStatus) {
		try {
			return requestDAO.getCommentTemplates(requestStatus);
		} catch (EmptyResultDataAccessException e) {
			return new ArrayList<CommentTemplate>();
		}
	}

	@Override
	@Transactional(propagation = Propagation.REQUIRED , rollbackFor = {PersonManagerException.class,
			 ManagerException.class,ParseException.class,Exception.class})
	public void importCSV(String csv) throws PersonManagerException, ManagerException, ParseException, OrganizationManagerException {

		String linesWithHeader[] = csv.split("\\r?\\n");
		String lines[] = Arrays.copyOfRange(linesWithHeader,1,linesWithHeader.length);
		for(String str : lines){

			LOGGER.debug("Importing line from csv -> " + str);

			String line[] = str.split(",");

			String firstname = !line[0].equals("")?line[0].trim():null;
			String lastname = !line[1].equals("")?line[1].trim():null;
			String organization = !line[2].equals("")?line[2].trim():null;
			String email = !line[3].equals("")?line[3].trim():null;

			String grant = !line[4].equals("")?line[4].trim():null;
			String doi = !line[5].equals("")?line[5].trim():null;
			String acceptanceDate = !line[6].equals("")?line[6].trim():null;
			String identifierType = !line[7].equals("")?line[7].trim():null;
			String identifierValue = !line[8].equals("")?line[8].trim():null;
			String apc = !line[9].equals("")?line[9].trim():"0";
			String apcCurrency = !line[10].equals("")?line[10].trim():null;
			String discount = !line[11].equals("")?line[11].trim():null;
			String status = line.length>12?line[12].trim():"0";

			LOGGER.debug(discount + "/" + status);

			importRequestFromCSV(firstname,lastname,organization,email,
					grant,doi,acceptanceDate, identifierType,
					identifierValue,apc, apcCurrency,discount,status);
		}
	}




	private void importRequestFromCSV(String firstname, String lastname, String organization, String email, String grant,
									  String doi, String acceptanceDate,
									  String identifierType, String identifierValue,
									  String apc, String apcCurrency, String discount, String status)
			throws PersonManagerException, ParseException, ManagerException, OrganizationManagerException {

		List<Object> orgs =  organizationManager.search(organization);
		if(orgs == null){
			LOGGER.debug("Organization " + organization +  "  not exists!");
			//org = organizationManager.createOrganization(organization);
		}
		Organization org = (Organization) organizationManager.search(organization).get(0);

		User user = null;
		try {
			user  = userManager.getByEmail(email);
		} catch (PersonManagerException e) {
			LOGGER.debug("User with email : " + email + " not exists!");
			LOGGER.debug("Creating new inactive user with default password!");
			user = userManager.createInActiveResearcher(firstname,lastname,email,org);
		}

		List<Object> rs = projectManager.search(grant);
		Project project = null;
		if(rs.size() == 0) {
			LOGGER.debug("Project with specified grant("+grant+") not found!");
			throw new ManagerException("Project with specified grant("+grant+") not found!");
		}else
			project = (Project) rs.get(0);

		Publication publication = null;
		try {
			LOGGER.debug("Resolving doi...");
			publication = publicationManager.resolveDOI(doi);
		} catch (ManagerException e) {
			LOGGER.debug("Requested doi("+doi+") not found!" , e);
			throw new ManagerException("Requested doi("+doi+") not found!");
		}


		if(publication.getJournal()!=null && publication.getJournal().getPublisher()!=null) {
			LOGGER.debug("publisher not null!");
			publisherManager.savePublisher(publication.getJournal().getPublisher());
		}else if(publication.getPublisher()!=null)
			publisherManager.savePublisher(publication.getPublisher());

		LOGGER.debug(publication.getJournal().getPublisher().getName());
		if ( publicationManager.getPublication(publication.getId())  == null )
			publicationManager.savePublication(publication);


		Request request = requestDAO.getRequestFromCSV(user,project,publication,org,
				acceptanceDate, identifierType,identifierValue,apc, apcCurrency,discount,status);

		request.setId("L" + new SimpleDateFormat("yyyyMMdd-").format(new Date()) + requestDAO.getRequestId());
		request.setEligibility(Eligibility.OK);


		if(!request.getEligibility().getStatus().equals(Eligibility.Status.OK))
			throw new ManagerException("Request for project "+grant+" is not eligible!");
		requestDAO.saveRequest(request);
		LOGGER.debug(request.getPublication().getType());
	}


	@Override
	public BigInteger getActiveNumber() {
		return requestDAO.getActiveNumber();
	}

	@Override
	public BigInteger getPaidNumber() {
		return requestDAO.getPaidNumber();
	}

	@Override
	public BigInteger getNumberOfProjects() {
		return requestDAO.getNumberOfProjects();
	}

	@Override
	public Float getTotalAmount() {
		return requestDAO.getTotalAmount();
	}

	@Override
	public Double getAverageAmount() {
		return requestDAO.getAverageAmount();
	}

	@Override
	public Double getAverageAmountPerBookChapter() {
		return requestDAO.getAverageAmountPerBookChapter();
	}

	@Override
	public Double getAverageAmountPerMonograph() {
		return requestDAO.getAverageAmountPerMonograph();
	}

	@Override
	public Double getAverageAmountPbooleanerMonograph() {
		return requestDAO.getAverageAmountPerMonograph();
	}

	@Override
	public Double getAverageAmountPerArticle() {
		return requestDAO.getAverageAmountPerArticle();
	}

	@Override
	public BigInteger getNumberOfPaidPublicationPerArticle() {
		return requestDAO.getNumberOfPaidPublicationPerArticle();
	}

	@Override
	public BigInteger getNumberOfPaidPublicationPerMonograph() {
		return requestDAO.getNumberOfPaidPublicationPerMonograph();
	}

	@Override
	public BigInteger getNumberOfPaidPublicationPerBookChapter() {
		return requestDAO.getNumberOfPaidPublicationPerBookChapter();
	}


	@Override
	public BigInteger getNumberOfPaidRequestsWithDOI() {
		return requestDAO.getNumberOfPaidRequestsWithDOI();
	}

	@Override
	public BigInteger getNumberOfApprovedRequestsWithDOI() {
		return requestDAO.getNumberOfApprovedRequestsWithDOI();
	}

	public String isSendCoordinatorEmails() {
		return sendCoordinatorEmails;
	}

	public void setSendCoordinatorEmails(String sendCoordinatorEmails) {
		this.sendCoordinatorEmails = sendCoordinatorEmails;
	}

	public String isSendEvaEmail() {
		return sendEvaEmail;
	}

	public void setSendEvaEmail(String sendEvaEmail) {
		this.sendEvaEmail = sendEvaEmail;
	}

	public String getEvaEmail() {
		return evaEmail;
	}

	public void setEvaEmail(String evaEmail) {
		this.evaEmail = evaEmail;
	}

	@Override
	public List<Request> getPendingRequestsByStatus(int status) {
		return requestDAO.getPendingRequestsByStatus(status);
	}

	@Override
	public void sendEmailForPendingIncompleteRequests(){

		/*if(Boolean.parseBoolean(pendingemails)) {
			List<Request> pendingRequests = getPendingRequestsByStatus(Request.RequestStatus.INCOMPLETE.getCode());
			int counter = 1;
			for (Request r : pendingRequests) {
                if(counter > 54) {
                    try {
                        LOGGER.debug("Send email " + counter + " of " + pendingRequests.size());
                        emailUtils.sendEmailForPendingIncompleteRequests(r);
                    } catch (MessagingException e) {
                        LOGGER.debug(e);
                    }
                }
                counter++;
			}
		}
		else{
			List<Request> pendingRequests = getPendingRequestsByStatus(Request.RequestStatus.INCOMPLETE.getCode());
			Request r = pendingRequests.get(0);
			LOGGER.debug("Sending email for debug.");
		}*/

	}

	@Override
	public void sendEmailForPendingConditionallyApprovedRequests() {
		/*if(Boolean.parseBoolean(pendingemails)) {
			List<Request> pendingRequests = getPendingRequestsByStatus(Request.RequestStatus.CONDITIONALLY_APPROVED.getCode());
			int counter = 1;
			for (Request r : pendingRequests) {
				LOGGER.debug("Send email " + counter + " of " + pendingRequests.size());
                try {
                    emailUtils.sendEmailForPendingConditionallyApprovedRequests(r);
                } catch (MessagingException e) {
                    LOGGER.debug(e);
                }

				counter++;
			}
		}
		else{
			List<Request> pendingRequests= getPendingRequestsByStatus(Request.RequestStatus.CONDITIONALLY_APPROVED.getCode());
			Request r = pendingRequests.get(0);
			LOGGER.debug("Sending email for debug.");
		}*/
	}


}