/*
 * Copyright 2007 The Kuali Foundation
 * 
 * Licensed under the Educational Community License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 * 
 * http://www.opensource.org/licenses/ecl2.php
 * 
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.kuali.ole.sys.businessobject;

import java.sql.Date;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;

import org.kuali.ole.coa.businessobject.Account;
import org.kuali.ole.coa.businessobject.ObjectCode;
import org.kuali.ole.sys.context.SpringContext;
import org.kuali.ole.sys.document.AccountingDocument;
import org.kuali.ole.sys.document.service.AccountPresenceService;
import org.kuali.rice.core.api.datetime.DateTimeService;
import org.kuali.rice.kew.api.exception.WorkflowException;
import org.kuali.rice.krad.document.Document;
import org.kuali.rice.krad.service.DocumentService;
import org.kuali.rice.krad.util.ObjectUtils;

/**
 * This class helps implement AccountingLine overrides. It is not persisted itself, but it simplifies working with the persisted
 * codes. Instances break the code into components. Static methods help with the AccountingLine.
 */
public class AccountingLineOverride {
    private static final org.apache.log4j.Logger LOG = org.apache.log4j.Logger.getLogger(AccountingLineOverride.class);

    /**
     * These codes are the way the override is persisted in the AccountingLine.
     */
    public static final class CODE { // todo: use JDK 1.5 enum
        public static final String NONE = "NONE";
        public static final String EXPIRED_ACCOUNT = "EXPIRED_ACCOUNT";
        public static final String NON_BUDGETED_OBJECT = "NON_BUDGETED_OBJECT";
        public static final String TRANSACTION_EXCEEDS_REMAINING_BUDGET = "TRANSACTION_EXCEEDS_REMAINING_BUDGET";
        public static final String EXPIRED_ACCOUNT_AND_NON_BUDGETED_OBJECT = "EXPIRED_ACCOUNT_AND_NON_BUDGETED_OBJECT";
        public static final String NON_BUDGETED_OBJECT_AND_TRANSACTION_EXCEEDS_REMAINING_BUDGET = "NON_BUDGETED_OBJECT_AND_TRANSACTION_EXCEEDS_REMAINING_BUDGET";
        public static final String EXPIRED_ACCOUNT_AND_TRANSACTION_EXCEEDS_REMAINING_BUDGET = "EXPIRED_ACCOUNT_AND_TRANSACTION_EXCEEDS_REMAINING_BUDGET";
        public static final String EXPIRED_ACCOUNT_AND_NON_BUDGETED_OBJECT_AND_TRANSACTION_EXCEEDS_REMAINING_BUDGET = "EXPIRED_ACCOUNT_AND_NON_BUDGETED_OBJECT_AND_TRANSACTION_EXCEEDS_REMAINING_BUDGET";
        public static final String NON_FRINGE_ACCOUNT_USED = "NON_FRINGE_ACCOUNT_USED";
        public static final String EXPIRED_ACCOUNT_AND_NON_FRINGE_ACCOUNT_USED = "EXPIRED_ACCOUNT_AND_NON_FRINGE_ACCOUNT_USED";
    }

    /**
     * These are the somewhat independent components of an override.
     */
    public static final class COMPONENT { // todo: use JDK 1.5 enum
        public static final Integer EXPIRED_ACCOUNT = new Integer(1);
        public static final Integer NON_BUDGETED_OBJECT = new Integer(2);
        public static final Integer TRANSACTION_EXCEEDS_REMAINING_BUDGET = new Integer(3);
        public static final Integer NON_FRINGE_ACCOUNT_USED = new Integer(8);
    }

    /**
     * The names of the AccountingLine properties that the processForOutput() and determineNeededOverrides() methods use. Callers of
     * those methods may need to refresh these fields from OJB.
     */
    public static final List<String> REFRESH_FIELDS = Collections.unmodifiableList(Arrays.asList(new String[] { "account", "objectCode" }));

    /**
     * This holds an instance of every valid override, mapped by code.
     */
    private static final Map<String, AccountingLineOverride> codeToOverrideMap = new HashMap<String, AccountingLineOverride>();

    /**
     * This holds an instance of every valid override, mapped by components.
     */
    private static final Map componentsToOverrideMap = new HashMap();

    static {
        // populate the code map
        new AccountingLineOverride(CODE.NONE, new Integer[] {});
        new AccountingLineOverride(CODE.EXPIRED_ACCOUNT,
        // todo: use JDK 1.5 ... args
            new Integer[] { COMPONENT.EXPIRED_ACCOUNT });
        new AccountingLineOverride(CODE.NON_BUDGETED_OBJECT, new Integer[] { COMPONENT.NON_BUDGETED_OBJECT });
        new AccountingLineOverride(CODE.TRANSACTION_EXCEEDS_REMAINING_BUDGET, new Integer[] { COMPONENT.TRANSACTION_EXCEEDS_REMAINING_BUDGET });
        new AccountingLineOverride(CODE.EXPIRED_ACCOUNT_AND_NON_BUDGETED_OBJECT, new Integer[] { COMPONENT.EXPIRED_ACCOUNT, COMPONENT.NON_BUDGETED_OBJECT });
        new AccountingLineOverride(CODE.NON_BUDGETED_OBJECT_AND_TRANSACTION_EXCEEDS_REMAINING_BUDGET, new Integer[] { COMPONENT.NON_BUDGETED_OBJECT, COMPONENT.TRANSACTION_EXCEEDS_REMAINING_BUDGET });
        new AccountingLineOverride(CODE.EXPIRED_ACCOUNT_AND_TRANSACTION_EXCEEDS_REMAINING_BUDGET, new Integer[] { COMPONENT.EXPIRED_ACCOUNT, COMPONENT.TRANSACTION_EXCEEDS_REMAINING_BUDGET });
        new AccountingLineOverride(CODE.EXPIRED_ACCOUNT_AND_NON_BUDGETED_OBJECT_AND_TRANSACTION_EXCEEDS_REMAINING_BUDGET, new Integer[] { COMPONENT.EXPIRED_ACCOUNT, COMPONENT.NON_BUDGETED_OBJECT, COMPONENT.TRANSACTION_EXCEEDS_REMAINING_BUDGET });
        new AccountingLineOverride(CODE.NON_FRINGE_ACCOUNT_USED, new Integer[] { COMPONENT.NON_FRINGE_ACCOUNT_USED });
        new AccountingLineOverride(CODE.EXPIRED_ACCOUNT_AND_NON_FRINGE_ACCOUNT_USED, new Integer[] { COMPONENT.EXPIRED_ACCOUNT, COMPONENT.NON_FRINGE_ACCOUNT_USED });
    }

    private final String code;
    private final Set components;

    /**
     * This private constructor is for the static initializer.
     * 
     * @param myCode
     * @param myComponents
     */
    private AccountingLineOverride(String myCode, Integer[] myComponents) {
        code = myCode;
        components = componentsAsSet(myComponents);
        codeToOverrideMap.put(code, this);
        componentsToOverrideMap.put(components, this);
    }

    /**
     * Checks whether this override contains the given component.
     * 
     * @param component
     * @return whether this override contains the given component.
     */
    public boolean hasComponent(Integer component) {
        return components.contains(component);
    }

    /**
     * Gets the code of this override.
     * 
     * @return the code of this override.
     */
    public String getCode() {
        return code;
    }

    /**
     * Gets the components of this override.
     * 
     * @return the components of this override.
     */
    private Set getComponents() {
        return components;
    }

    /**
     * @see java.lang.Object#toString()
     */
    @Override
    public String toString() {
        return "AccountingLineOverride (code " + code + ", components " + components + ")";
    }

    /**
     * Returns the AccountingLineOverride that has the components of this AccountingLineOverride minus any components not in the
     * given mask. This is like <code>&amp;</code>(a bit-wise and), if the components were bits.
     * 
     * @param mask
     * @return the AccountingLineOverride that has the components of this AccountingLineOverride minus any components not in the
     *         given mask.
     * @throws IllegalArgumentException if there is no such valid combination of components
     */
    public AccountingLineOverride mask(AccountingLineOverride mask) {
        Set key = maskComponents(mask);
        if (!isValidComponentSet(key)) {
            throw new IllegalArgumentException("invalid component set " + key);
        }
        return valueOf(key);
    }

    /**
     * Returns the Set of components that this override and the given override have in common.
     * 
     * @param mask
     * @return the Set of components that this override and the given override have in common.
     */
    private Set maskComponents(AccountingLineOverride mask) {
        Set retval = new HashSet(components);
        retval.retainAll(mask.getComponents());
        return retval;
    }

    /**
     * Returns whether this override, when masked by the given override, is valid. Some combinations of components have no override
     * code defined.
     * 
     * @param mask
     * @return whether this override, when masked by the given override, is valid.
     */
    public boolean isValidMask(AccountingLineOverride mask) {
        return isValidComponentSet(maskComponents(mask));
    }

    /**
     * Returns whether the given String is a valid override code.
     * 
     * @param code
     * @return whether the given String is a valid override code.
     */
    public static boolean isValidCode(String code) {
        return codeToOverrideMap.containsKey(code);
    }

    /**
     * Returns whether the given Integers are a valid set of components. Some combinations of components are invalid and have no
     * code defined.
     * 
     * @param components
     * @return whether the given Integers are a valid set of components.
     */
    public static boolean isValidComponentSet(Integer[] components) {
        return isValidComponentSet(componentsAsSet(components));
    }

    private static boolean isValidComponentSet(Set components) { // todo: JDK 1.5 generic Set
        return componentsToOverrideMap.containsKey(components);
    }

    /**
     * Factory method from code.
     * 
     * @param code the override code
     * @return the AccountingLineOverride instance corresponding to the given code.
     * @throws IllegalArgumentException if the given code is not valid
     */
    public static AccountingLineOverride valueOf(String code) {
        if (!isValidCode(code)) {
            throw new IllegalArgumentException("invalid code " + code);
        }
        return (AccountingLineOverride) codeToOverrideMap.get(code); // todo: JDK 1.5 generic Map instead of cast
    }

    /**
     * Factory method from components.
     * 
     * @param components the override components, treated as a set
     * @return the AccountingLineOverride instance corresponding to the given component set.
     * @throws IllegalArgumentException if the given set of components is not valid
     */
    public static AccountingLineOverride valueOf(Integer[] components) {
        Set key = componentsAsSet(components);
        if (!isValidComponentSet(key)) {
            throw new IllegalArgumentException("invalid component set " + key);
        }
        return valueOf(key);
    }

    public static AccountingLineOverride valueOf(Set components) {
        return (AccountingLineOverride) componentsToOverrideMap.get(components); // todo: JDK 1.5 generic Map instead of cast
    }

    private static Set componentsAsSet(Integer[] components) {
        return Collections.unmodifiableSet(new HashSet(Arrays.asList(components)));
    }

    /**
     * On the given AccountingLine, converts override input checkboxes from a Struts Form into a persistable override code.
     * 
     * @param line
     */
    public static void populateFromInput(AccountingLine line) {
        // todo: this logic won't work if a single account checkbox might also stands for NON_FRINGE_ACCOUNT_USED; needs thought

        Set overrideInputComponents = new HashSet();
        if (line.getAccountExpiredOverride()) {
            overrideInputComponents.add(COMPONENT.EXPIRED_ACCOUNT);
        }
        if (line.isObjectBudgetOverride()) {
            overrideInputComponents.add(COMPONENT.NON_BUDGETED_OBJECT);
        }
        if (!isValidComponentSet(overrideInputComponents)) {
            // todo: error for invalid override checkbox combinations, for which there is no override code
        }
        line.setOverrideCode(valueOf(overrideInputComponents).getCode());
    }

    /**
     * Prepares the given AccountingLine in a Struts Action for display by a JSP. This means converting the override code to
     * checkboxes for display and input, as well as analysing the accounting line and determining which override checkboxes are
     * needed.
     * 
     * @param line
     */
    public static void processForOutput(AccountingDocument document ,AccountingLine line) {
        AccountingLineOverride fromCurrentCode = valueOf(line.getOverrideCode());
        AccountingLineOverride needed = determineNeededOverrides(document,line);
        line.setAccountExpiredOverride(fromCurrentCode.hasComponent(COMPONENT.EXPIRED_ACCOUNT));
        line.setAccountExpiredOverrideNeeded(needed.hasComponent(COMPONENT.EXPIRED_ACCOUNT));
        line.setObjectBudgetOverride(fromCurrentCode.hasComponent(COMPONENT.NON_BUDGETED_OBJECT));
        line.setObjectBudgetOverrideNeeded(needed.hasComponent(COMPONENT.NON_BUDGETED_OBJECT));
    }

    /**
     * Determines what overrides the given line needs.
     * 
     * @param line
     * @return what overrides the given line needs.
     */
    public static AccountingLineOverride determineNeededOverrides(AccountingDocument document ,AccountingLine line) {
        boolean isDocumentFinalOrProcessed = false;
       if(ObjectUtils.isNotNull(document)) {
           AccountingDocument accountingDocument = (AccountingDocument) document;
           isDocumentFinalOrProcessed = accountingDocument.isDocumentFinalOrProcessed();
       }

        Set neededOverrideComponents = new HashSet();
        if (needsExpiredAccountOverride(line, isDocumentFinalOrProcessed)) {
            neededOverrideComponents.add(COMPONENT.EXPIRED_ACCOUNT);
        }
        if (needsObjectBudgetOverride(line.getAccount(), line.getObjectCode())) {
            neededOverrideComponents.add(COMPONENT.NON_BUDGETED_OBJECT);
        }

        if (!isValidComponentSet(neededOverrideComponents)) {
            // todo: error for invalid override checkbox combinations, for which there is no override code
        }
        return valueOf(neededOverrideComponents);
    }

    /**
     * Returns whether the given account needs an expired account override.
     * 
     * @param account
     * @return whether the given account needs an expired account override.
     */
    public static boolean needsExpiredAccountOverride(Account account) {
        return !ObjectUtils.isNull(account) && account.isActive() && account.isExpired();
    }

    /**
     * Returns whether the given account needs an expired account override.
     * 
     * @param account
     * @return whether the given account needs an expired account override.
     */
    public static boolean needsExpiredAccountOverride(AccountingLine line, boolean isDocumentFinalOrProcessed ) {
        if(isDocumentFinalOrProcessed){
            if(CODE.EXPIRED_ACCOUNT.equals(line.getOverrideCode())) {
                return true;
            }
            else {
                return false;
            }
        }
        else {
            return  !ObjectUtils.isNull(line.getAccount()) && line.getAccount().isActive() && line.getAccount().isExpired();
        }
    }

    /**
     * Returns whether the given account needs an expired account override.
     *
     * @param account
     * @return whether the given account needs an expired account override.
     */
    public static boolean needsNonFringAccountOverride(Account account) {
        return !ObjectUtils.isNull(account) && account.isActive() && !account.isAccountsFringesBnftIndicator();
    }

    /**
     * Returns whether the given object code needs an object budget override
     * 
     * @param account
     * @return whether the given object code needs an object budget override
     */
    public static boolean needsObjectBudgetOverride(Account account, ObjectCode objectCode) {
        return !ObjectUtils.isNull(account) && !ObjectUtils.isNull(objectCode) && account.isActive() && !SpringContext.getBean(AccountPresenceService.class).isObjectCodeBudgetedForAccountPresence(account, objectCode);
    }

    public static Document getDocument(AccountingLine line) {
        Document document = null;
        try {
            document = SpringContext.getBean(DocumentService.class).getByDocumentHeaderId(line.getDocumentNumber());

       }catch(WorkflowException exception) {
           LOG.error("Unable to locate document for documentId :: " + line.getDocumentNumber() );
       }

       return document;
    }
}