package net.sourceforge.fenixedu.domain.accounting.postingRules;

import java.util.Collections;
import java.util.List;
import java.util.Set;

import net.sourceforge.fenixedu.dataTransferObject.accounting.AccountingTransactionDetailDTO;
import net.sourceforge.fenixedu.dataTransferObject.accounting.EntryDTO;
import net.sourceforge.fenixedu.domain.User;
import net.sourceforge.fenixedu.domain.accounting.Account;
import net.sourceforge.fenixedu.domain.accounting.AccountingTransaction;
import net.sourceforge.fenixedu.domain.accounting.EntryType;
import net.sourceforge.fenixedu.domain.accounting.Event;
import net.sourceforge.fenixedu.domain.accounting.EventType;
import net.sourceforge.fenixedu.domain.accounting.ServiceAgreementTemplate;
import net.sourceforge.fenixedu.domain.accounting.events.EnrolmentInAppealSeasonEvent;
import net.sourceforge.fenixedu.domain.accounting.events.EnrolmentInAppealSeasonPenaltyExemption;
import net.sourceforge.fenixedu.domain.exceptions.DomainException;
import net.sourceforge.fenixedu.domain.exceptions.DomainExceptionWithLabelFormatter;
import net.sourceforge.fenixedu.util.Money;

import org.joda.time.DateTime;

import com.linkare.commons.metainfo.Linkare;

@Linkare(author = "Paulo Zenida")
public class EnrolmentInAppealSeasonPR extends EnrolmentInAppealSeasonPR_Base {

    protected EnrolmentInAppealSeasonPR() {
	super();
    }

    public EnrolmentInAppealSeasonPR(DateTime startDate, DateTime endDate, ServiceAgreementTemplate serviceAgreementTemplate,
	    Money fixedAmount, Money fixedAmountPenalty) {
	super.init(EntryType.ENROLMENT_IN_APPEAL_SEASON_FEE, EventType.ENROLMENT_IN_APPEAL_SEASON, startDate, endDate,
		serviceAgreementTemplate);
	checkParameters(fixedAmount, fixedAmountPenalty);
	super.setFixedAmount(fixedAmount);
	super.setFixedAmountPenalty(fixedAmountPenalty);
    }

    private void checkParameters(Money fixedAmount, Money fixedAmountPenalty) {
	if (fixedAmount == null) {
	    throw new DomainException("error.accounting.postingRules.EnrolmentInAppealSeasonPR.fixedAmount.cannot.be.null");
	}
	if (fixedAmountPenalty == null) {
	    throw new DomainException("error.accounting.postingRules.EnrolmentInAppealSeasonPR.fixedAmountPenalty.cannot.be.null");
	}
    }

    @Override
    public void setFixedAmountPenalty(Money fixedAmountPenalty) {
	throw new DomainException("error.accounting.postingRules.EnrolmentInAppealSeasonPR.cannot.modify.fixedAmountPenalty");
    }

    public EnrolmentInAppealSeasonPR edit(final Money fixedAmount, final Money fixedAmountPenalty) {
	deactivate();
	return new EnrolmentInAppealSeasonPR(new DateTime().minus(1000), null, getServiceAgreementTemplate(), fixedAmount,
		fixedAmountPenalty);
    }

    @Override
    public Money calculateTotalAmountToPay(Event event, DateTime when, boolean applyDiscount) {
	final EnrolmentInAppealSeasonEvent enrolmentInAppealSeasonEvent = (EnrolmentInAppealSeasonEvent) event;
	final boolean hasPenalty = hasPenalty(event, when);

	Money result = Money.ZERO;
	for (int i = 0; i < enrolmentInAppealSeasonEvent.getAppealEnrolmentEvaluationsCount(); i++) {
	    result = result.add(hasPenalty ? getFixedAmountPenalty() : getFixedAmount());
	}

	return result;
    }

    // Paulo Zenida - it may be added some additional logic in the future!
    private boolean hasPenalty(final Event event, final DateTime when) {
	if (event.hasAnyPenaltyExemptionsFor(EnrolmentInAppealSeasonPenaltyExemption.class)) {
	    return false;
	}
	return false;
    }

    @Override
    public List<EntryDTO> calculateEntries(Event event, DateTime when) {
	final Money totalAmountToPay = calculateTotalAmountToPay(event, when);
	return Collections.singletonList(new EntryDTO(getEntryType(), event, totalAmountToPay, Money.ZERO, totalAmountToPay,
		event.getDescriptionForEntryType(getEntryType()), totalAmountToPay));
    }

    @Override
    protected Set<AccountingTransaction> internalProcess(User user, List<EntryDTO> entryDTOs, Event event, Account fromAccount,
	    Account toAccount, AccountingTransactionDetailDTO transactionDetail) {
	if (entryDTOs.size() != 1) {
	    throw new DomainException("error.accounting.postingRules.EnrolmentInAppealSeasonPR.invalid.number.of.entryDTOs");
	}

	final EntryDTO entryDTO = entryDTOs.get(0);
	checkIfCanAddAmount(entryDTO.getAmountToPay(), event, transactionDetail.getWhenRegistered());

	return Collections.singleton(makeAccountingTransaction(user, event, fromAccount, toAccount, entryDTO.getEntryType(),
		entryDTO.getAmountToPay(), transactionDetail));
    }

    private void checkIfCanAddAmount(final Money amountToPay, final Event event, final DateTime when) {
	if (amountToPay.compareTo(calculateTotalAmountToPay(event, when)) < 0) {
	    throw new DomainExceptionWithLabelFormatter(
		    "error.accounting.postingRules.EnrolmentInAppealSeasonPR.amount.being.payed.must.match.amount.to.pay", event
			    .getDescriptionForEntryType(getEntryType()));
	}
    }
}