/*
 * Copyright 2008-2009 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.coa.batch.dataaccess.impl;

import java.sql.Date;
import java.util.Collection;
import java.util.Collections;
import java.util.GregorianCalendar;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import org.apache.commons.lang.StringUtils;
import org.kuali.ole.coa.businessobject.AccountingPeriod;
import org.kuali.ole.sys.OLEPropertyConstants;
import org.kuali.ole.sys.batch.dataaccess.impl.FiscalYearMakerImpl;
import org.kuali.ole.sys.businessobject.FiscalYearBasedBusinessObject;

/**
 * Performs custom population of accounting periods records for a new year being created in the fiscal year maker process
 */
public class AccountingPeriodFiscalYearMakerImpl extends FiscalYearMakerImpl {
    
    public AccountingPeriodFiscalYearMakerImpl() {
        super();
        
        super.setAllowOverrideTargetYear(false);
    }

    /**
     * Updates the year on the fiscal period name and sets status to open for next year records
     * 
     * @see org.kuali.ole.coa.batch.dataaccess.impl.FiscalYearMakerHelperImpl#changeForNewYear(java.lang.Integer,
     *      org.kuali.rice.krad.bo.PersistableBusinessObject)
     */
    @Override
    public void changeForNewYear(Integer baseFiscalYear, FiscalYearBasedBusinessObject currentRecord) {
        super.changeForNewYear(baseFiscalYear, currentRecord);

        AccountingPeriod accountingPeriod = (AccountingPeriod) currentRecord;

        // update fiscal period name which contains the fiscal year
        String fiscalPeriodName = accountingPeriod.getUniversityFiscalPeriodName();

        String oldCalendarStartYear = new Integer(accountingPeriod.getUniversityFiscalYear() - 2).toString();
        String oldCalendarEndYear = new Integer(accountingPeriod.getUniversityFiscalYear() - 1).toString();

        String newCalendarStartYear = new Integer(accountingPeriod.getUniversityFiscalYear() - 1).toString();
        String newCalendarEndYear = new Integer(accountingPeriod.getUniversityFiscalYear()).toString();

        // replace 4 digit year in name if found, else replace 2 digit
        if (StringUtils.contains(fiscalPeriodName, oldCalendarEndYear)) {
            fiscalPeriodName = StringUtils.replace(fiscalPeriodName, oldCalendarEndYear, newCalendarEndYear);
        }
        else if (StringUtils.contains(fiscalPeriodName, oldCalendarStartYear)) {
            fiscalPeriodName = StringUtils.replace(fiscalPeriodName, oldCalendarStartYear, newCalendarStartYear);
        }
        else {
            fiscalPeriodName = updateTwoDigitYear(newCalendarEndYear.substring(2, 4), oldCalendarEndYear.substring(2, 4), fiscalPeriodName);
            fiscalPeriodName = updateTwoDigitYear(newCalendarStartYear.substring(2, 4), oldCalendarStartYear.substring(2, 4), fiscalPeriodName);
        }

        accountingPeriod.setUniversityFiscalPeriodName(fiscalPeriodName);

        // increment period end date by one year
        accountingPeriod.setUniversityFiscalPeriodEndDate(addYearToDate(accountingPeriod.getUniversityFiscalPeriodEndDate()));

        // set status to closed
        accountingPeriod.setActive(false);
    }

    /**
     * Retrieves all Accounting Period records for the first copied fiscal year and make active
     * 
     * @see org.kuali.ole.coa.batch.dataaccess.impl.FiscalYearMakerHelperImpl#performCustomProcessing(java.lang.Integer)
     */
    @Override
    public void performCustomProcessing(Integer baseFiscalYear, boolean firstCopyYear) {
        if (!firstCopyYear) {
            return;
        }
        Collection<AccountingPeriod> accountingPeriods = businessObjectService.findMatching(AccountingPeriod.class,Collections.singletonMap(OLEPropertyConstants.UNIVERSITY_FISCAL_YEAR, baseFiscalYear + 1));
        for (AccountingPeriod accountingPeriod : accountingPeriods) {
            accountingPeriod.setActive(true);
            businessObjectService.save(accountingPeriod);
        }
    }

    /**
     * Adds one year to the given date
     * 
     * @param inDate date to increment
     * @return Date incoming date plus one year
     */
    protected java.sql.Date addYearToDate(Date inDate) {
        GregorianCalendar currentCalendarDate = new GregorianCalendar();
        currentCalendarDate.clear();

        currentCalendarDate.setTimeInMillis(inDate.getTime());
        currentCalendarDate.add(GregorianCalendar.YEAR, 1);

        return new Date(currentCalendarDate.getTimeInMillis());
    }

    /**
     * this routine is provided to update string fields which contain two-digit years that need to be updated for display. it is
     * very specific, but it's necessary. "two-digit year" means the two numeric characters preceded by a non-numeric character.
     * 
     * @param newYear
     * @param oldYear
     * @param currentString
     * @return the updated string for a two digit year
     */
    protected String updateTwoDigitYear(String newYear, String oldYear, String currentString) {
        // group 1 is the bounded by the outermost set of parentheses
        // group 2 is the first inner set
        // group 3 is the second inner set--a two-digit year at the beginning of the line
        String regExpString = "(([^0-9]{1}" + oldYear + ")|^(" + oldYear + "))";
        Pattern pattern = Pattern.compile(regExpString);
        Matcher matcher = pattern.matcher(currentString);

        // start looking for a match
        boolean matched = matcher.find();
        if (!matched) {
            // just return if nothing is found
            return currentString;
        }

        // we found something
        // we have to process it
        String returnString = currentString;
        StringBuffer outString = new StringBuffer();
        // is there a match at the beginning of the line (a match with group 3)?
        if (matcher.group(3) != null) {
            // there is a two-digit-year string at the beginning of the line
            // we want to replace it
            matcher.appendReplacement(outString, newYear);
            // find the next match if there is one
            matched = matcher.find();
        }

        while (matched) {
            // the new string will no longer match with group 3
            // if there is still a match, it will be with group 2
            // now we have to prefix the new year string with the same
            // non-numeric character as the next match (hyphen, space, whatever)
            String newYearString = matcher.group(2).substring(0, 1) + newYear;
            matcher.appendReplacement(outString, newYearString);
            matched = matcher.find();
        }

        // dump whatever detritus is left into the new string
        matcher.appendTail(outString);

        return outString.toString();
    }

}