/*
 * Copyright 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.sys.report;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;

import org.apache.commons.beanutils.PropertyUtils;
import org.apache.commons.lang.StringUtils;
import org.kuali.ole.sys.OLEConstants;
import org.kuali.rice.core.web.format.BigDecimalFormatter;
import org.kuali.rice.core.web.format.CurrencyFormatter;
import org.kuali.rice.core.web.format.Formatter;
import org.kuali.rice.core.web.format.IntegerFormatter;
import org.kuali.rice.core.web.format.KualiIntegerCurrencyFormatter;
import org.kuali.rice.core.web.format.LongFormatter;
import org.kuali.rice.core.web.format.PercentageFormatter;
import org.kuali.rice.kns.service.DataDictionaryService;
import org.kuali.rice.krad.bo.BusinessObject;
import org.kuali.rice.krad.util.ObjectUtils;

/**
 * Helper class for business objects to assist formatting them for error reporting. Utilizes spring injection for modularization and
 * configurability
 * 
 * @see org.kuali.ole.sys.service.impl.ReportWriterTextServiceImpl
 */
public class BusinessObjectReportHelper {
    private static org.apache.log4j.Logger LOG = org.apache.log4j.Logger.getLogger(BusinessObjectReportHelper.class);

    protected int minimumMessageLength;
    protected String messageLabel;
    protected Class<? extends BusinessObject> dataDictionaryBusinessObjectClass;
    protected Map<String, String> orderedPropertyNameToHeaderLabelMap;
    protected DataDictionaryService dataDictionaryService;

    private int columnCount = 0;
    private Map<String, Integer> columnSpanDefinition;
    
    public final static String LEFT_ALIGNMENT = "LEFT"; 
    public final static String RIGHT_ALIGNMENT = "RIGHT"; 
    public final static String LINE_BREAK = "\n";

    /**
     * Returns the values in a list of the passed in business object in order of the spring definition.
     * 
     * @param businessObject for which to return the values
     * @return the values
     */
    public List<Object> getValues(BusinessObject businessObject) {
        List<Object> keys = new ArrayList<Object>();

        for (Iterator<String> propertyNames = orderedPropertyNameToHeaderLabelMap.keySet().iterator(); propertyNames.hasNext();) {
            String propertyName = propertyNames.next();
            keys.add(retrievePropertyValue(businessObject, propertyName));
        }

        return keys;
    }

    /**
     * Returns a value for a given property, can be overridden to allow for pseudo-properties
     * 
     * @param businessObject
     * @param propertyName
     * @return
     */
    protected Object retrievePropertyValue(BusinessObject businessObject, String propertyName) {
        try {
            return PropertyUtils.getProperty(businessObject, propertyName);
        }
        catch (Exception e) {
            throw new RuntimeException("Failed getting propertyName=" + propertyName + " from businessObjecName=" + businessObject.getClass().getName(), e);
        }
    }

    /**
     * Returns the maximum length of a value for a given propery, can be overridden to allow for pseudo-properties
     * 
     * @param businessObjectClass
     * @param propertyName
     * @return
     */
    protected int retrievePropertyValueMaximumLength(Class<? extends BusinessObject> businessObjectClass, String propertyName) {
        return dataDictionaryService.getAttributeMaxLength(businessObjectClass, propertyName);
    }
    
    /**
     * Returns the maximum length of a value for a given propery, can be overridden to allow for pseudo-properties
     * 
     * @param businessObjectClass
     * @param propertyName
     * @return
     */
    protected Class<? extends Formatter> retrievePropertyFormatterClass(Class<? extends BusinessObject> businessObjectClass, String propertyName) {
        return dataDictionaryService.getAttributeFormatter(businessObjectClass, propertyName);
    }

    /**
     * Same as getValues except that it actually doesn't retrieve the values from the BO but instead returns a blank linke. This is
     * useful if indentation for message printing is necessary.
     * 
     * @param businessObject for which to return the values
     * @return spaces in the length of values
     */
    public List<Object> getBlankValues(BusinessObject businessObject) {
        List<Object> keys = new ArrayList<Object>();

        for (Iterator<String> propertyNames = orderedPropertyNameToHeaderLabelMap.keySet().iterator(); propertyNames.hasNext();) {
            String propertyName = propertyNames.next();

            keys.add("");
        }

        return keys;
    }

    /**
     * Returns multiple lines of what represent a table header. The last line in this list is the format of the table cells.
     * 
     * @param maximumPageWidth maximum before line is out of bounds. Used to fill message to the end of this range. Note that if
     *        there isn't at least maximumPageWidth characters available it will go minimumMessageLength out of bounds. It is up to
     *        the calling class to handle that
     * @return table header. Last element is the format of the table cells.
     */
    public List<String> getTableHeader(int maximumPageWidth) {
        String separatorLine = StringUtils.EMPTY;
        String messageFormat = StringUtils.EMPTY;

        // Construct the header based on orderedPropertyNameToHeaderLabelMap. It will pick the longest of label or DD size
        for (Iterator<Map.Entry<String, String>> entries = orderedPropertyNameToHeaderLabelMap.entrySet().iterator(); entries.hasNext();) {
            Map.Entry<String, String> entry = entries.next();

            int longest;
            try {
                longest = retrievePropertyValueMaximumLength(dataDictionaryBusinessObjectClass, entry.getKey());
            }
            catch (Exception e) {
                throw new RuntimeException("Failed getting propertyName=" + entry.getKey() + " from businessObjecName=" + dataDictionaryBusinessObjectClass.getName(), e);
            }
            if (entry.getValue().length() > longest) {
                longest = entry.getValue().length();
            }

            separatorLine = separatorLine + StringUtils.rightPad("", longest, OLEConstants.DASH) + " ";
            messageFormat = messageFormat + "%-" + longest + "s ";
        }

        // Now fill to the end of pageWidth for the message column. If there is not enough space go out of bounds
        int availableWidth = maximumPageWidth - (separatorLine.length() + 1);
        if (availableWidth < minimumMessageLength) {
            availableWidth = minimumMessageLength;
        }
        separatorLine = separatorLine + StringUtils.rightPad("", availableWidth, OLEConstants.DASH);
        messageFormat = messageFormat + "%-" + availableWidth + "s";

        // Fill in the header labels. We use the errorFormat to do this to get justification right
        List<Object> formatterArgs = new ArrayList<Object>();
        formatterArgs.addAll(orderedPropertyNameToHeaderLabelMap.values());
        formatterArgs.add(messageLabel);
        String tableHeaderLine = String.format(messageFormat, formatterArgs.toArray());

        // Construct return list
        List<String> tableHeader = new ArrayList<String>();
        tableHeader.add(tableHeaderLine);
        tableHeader.add(separatorLine);
        tableHeader.add(messageFormat);

        return tableHeader;
    }

    /**
     * get the primary information that can define a table structure
     * 
     * @return the primary information that can define a table structure
     */
    public Map<String, String> getTableDefinition() {       
        List<Integer> cellWidthList = this.getTableCellWidth();
        
        String separatorLine = this.getSepartorLine(cellWidthList);       
        String tableCellFormat = this.getTableCellFormat(false, true, null);
        String tableHeaderLineFormat = this.getTableCellFormat(false, false, separatorLine);

        // fill in the header labels
        int numberOfCell = cellWidthList.size();
        List<String> tableHeaderLabelValues = new ArrayList<String>(orderedPropertyNameToHeaderLabelMap.values());
        this.paddingTableCellValues(numberOfCell, tableHeaderLabelValues);

        String tableHeaderLine = String.format(tableHeaderLineFormat, tableHeaderLabelValues.toArray());

        Map<String, String> tableDefinition = new HashMap<String, String>();
        tableDefinition.put(OLEConstants.ReportConstants.TABLE_HEADER_LINE_KEY, tableHeaderLine);
        tableDefinition.put(OLEConstants.ReportConstants.SEPARATOR_LINE_KEY, separatorLine);
        tableDefinition.put(OLEConstants.ReportConstants.TABLE_CELL_FORMAT_KEY, tableCellFormat);

        return tableDefinition;
    }

    /**
     * Returns the values in a list of the passed in business object in order of the spring definition. The value for the
     * "EMPTY_CELL" entry is an empty string.
     * 
     * @param businessObject for which to return the values
     * @param allowColspan indicate whether colspan definition can be applied
     * @return the values being put into the table cells
     */
    public List<String> getTableCellValues(BusinessObject businessObject, boolean allowColspan) {
        List<String> tableCellValues = new ArrayList<String>();

        for (Map.Entry<String, String> entry : orderedPropertyNameToHeaderLabelMap.entrySet()) {
            String attributeName = entry.getKey();

            if (attributeName.startsWith(OLEConstants.ReportConstants.EMPTY_CELL_ENTRY_KEY_PREFIX)) {
                tableCellValues.add(StringUtils.EMPTY);
            }
            else {
                try {
                    Object propertyValue = retrievePropertyValue(businessObject, attributeName);
                    
                    if (ObjectUtils.isNotNull(propertyValue)) {
                        Formatter formatter = Formatter.getFormatter(propertyValue.getClass());
                        if(ObjectUtils.isNotNull(formatter) && ObjectUtils.isNotNull(propertyValue)) {
                            propertyValue = formatter.format(propertyValue);
                        }
                        else {
                            propertyValue = StringUtils.EMPTY;
                        }
                    } else {
                        propertyValue = StringUtils.EMPTY;
                    }
                    
                    tableCellValues.add(propertyValue.toString());
                }
                catch (Exception e) {
                    throw new RuntimeException("Failed getting propertyName=" + entry.getKey() + " from businessObjecName=" + dataDictionaryBusinessObjectClass.getName(), e);
                }
            }
        }
        
        if(allowColspan) {
            this.applyColspanOnCellValues(tableCellValues);
        }

        return tableCellValues;
    }

    /**
     * get the format string for all cells in a table row. Colspan definition will be applied if allowColspan is true 
     * 
     * @param allowColspan indicate whether colspan definition can be applied
     * @param allowRightAlignment indicate whether the right alignment can be applied
     * @param separatorLine the separation line for better look
     * 
     * @return the format string for all cells in a table row
     */
    public String getTableCellFormat(boolean allowColspan, boolean allowRightAlignment, String separatorLine) {
        List<Integer> cellWidthList = this.getTableCellWidth();
        List<String> cellAlignmentList = this.getTableCellAlignment();
        
        if(allowColspan) {
            this.applyColspanOnCellWidth(cellWidthList);
        }

        int numberOfCell = cellWidthList.size();
        int rowCount = (int) Math.ceil(numberOfCell * 1.0 / columnCount);

        StringBuffer tableCellFormat = new StringBuffer();
        for (int rowIndex = 0; rowIndex < rowCount; rowIndex++) {
            StringBuffer singleRowFormat = new StringBuffer();
            
            for (int columnIndex = 0; columnIndex < this.columnCount; columnIndex++) {
                int index = columnCount * rowIndex + columnIndex; 
                
                if(index >= numberOfCell) {
                    break;
                }
                
                int width = cellWidthList.get(index);
                String alignment = (allowRightAlignment && cellAlignmentList.get(index).equals(RIGHT_ALIGNMENT)) ? StringUtils.EMPTY : "-";
                if(width > 0) {
                    // following translates to %<alignment><width>.<precision>s where the precision for Strings forces a maxLength
                    singleRowFormat = singleRowFormat.append("%").append(alignment).append(width).append("." + width).append("s ");
                }
            }
            
            tableCellFormat = tableCellFormat.append(singleRowFormat).append(LINE_BREAK);
            if(StringUtils.isNotBlank(separatorLine)) {
                tableCellFormat = tableCellFormat.append(separatorLine).append(LINE_BREAK);
            }
        }

        return tableCellFormat.toString();
    }
    
    /**
     * get the separator line
     * @param cellWidthList the given cell width list
     * @return the separator line
     */
    public String getSepartorLine(List<Integer> cellWidthList) {
        StringBuffer separatorLine = new StringBuffer();
        
        for (int index = 0; index < this.columnCount; index++) {
            Integer cellWidth = cellWidthList.get(index);
            separatorLine = separatorLine.append(StringUtils.rightPad(StringUtils.EMPTY, cellWidth, OLEConstants.DASH)).append(" ");
        }
        
        return separatorLine.toString();
    }

    /**
     * apply the colspan definition on the default width of the table cells
     * 
     * @param the default width of the table cells
     */
    public void applyColspanOnCellWidth(List<Integer> cellWidthList) {
        if(ObjectUtils.isNull(columnSpanDefinition)) {
            return;
        }
        
        int indexOfCurrentCell = 0;
        for (Map.Entry<String, String> entry : orderedPropertyNameToHeaderLabelMap.entrySet()) {
            String attributeName = entry.getKey();

            if (columnSpanDefinition.containsKey(attributeName)) {
                int columnSpan = columnSpanDefinition.get(attributeName);

                int widthOfCurrentNonEmptyCell = cellWidthList.get(indexOfCurrentCell);
                for (int i = 1; i < columnSpan; i++) {
                    widthOfCurrentNonEmptyCell += cellWidthList.get(indexOfCurrentCell + i);
                    cellWidthList.set(indexOfCurrentCell + i, 0);
                }
                cellWidthList.set(indexOfCurrentCell, widthOfCurrentNonEmptyCell + columnSpan - 1);
            }

            indexOfCurrentCell++;
        }
    }
    
    /**
     * apply the colspan definition on the default values of the table cells. The values will be removed if their positions are taken by others.
     * 
     * @param the default values of the table cells
     */
    public void applyColspanOnCellValues(List<String> cellValues) {
        if(ObjectUtils.isNull(columnSpanDefinition)) {
            return;
        }
        
        String REMOVE_ME = "REMOVE-ME-!";
        
        int indexOfCurrentCell = 0;
        for (Map.Entry<String, String> entry : orderedPropertyNameToHeaderLabelMap.entrySet()) {
            String attributeName = entry.getKey();

            if (columnSpanDefinition.containsKey(attributeName)) {
                int columnSpan = columnSpanDefinition.get(attributeName);

                for (int i = 1; i < columnSpan; i++) {
                    cellValues.set(indexOfCurrentCell + i, REMOVE_ME);
                }
            }

            indexOfCurrentCell++;
        }
        
        int originalLength = cellValues.size();
        for(int index = originalLength -1; index>=0; index-- ) {
            if(StringUtils.equals(cellValues.get(index), REMOVE_ME)) {
                cellValues.remove(index);
            }
        }
    }

    /**
     * get the values that can be fed into a predefined table. If the values are not enought to occupy the table cells, a number of empty values are provided.
     * 
     * @param businessObject the given business object whose property values will be collected 
     * @param allowColspan indicate whether colspan definition can be applied
     * @return
     */
    public List<String> getTableCellValuesPaddingWithEmptyCell(BusinessObject businessObject, boolean allowColspan) {
        List<String> tableCellValues = this.getTableCellValues(businessObject, allowColspan);

        int numberOfCell = orderedPropertyNameToHeaderLabelMap.entrySet().size();
        this.paddingTableCellValues(numberOfCell, tableCellValues);

        return tableCellValues;
    }

    /**
     * get the width of all table cells according to the definition
     * 
     * @return the width of all table cells. The width is in the order defined as the orderedPropertyNameToHeaderLabelMap
     */
    public List<Integer> getTableCellWidth() {
        List<Integer> cellWidthList = new ArrayList<Integer>();
        for (Map.Entry<String, String> entry : orderedPropertyNameToHeaderLabelMap.entrySet()) {
            String attributeName = entry.getKey();
            String attributeValue = entry.getValue();

            int cellWidth = attributeValue.length();
            if (!attributeName.startsWith(OLEConstants.ReportConstants.EMPTY_CELL_ENTRY_KEY_PREFIX)) {
                try {
                    cellWidth = retrievePropertyValueMaximumLength(dataDictionaryBusinessObjectClass, attributeName);
                }
                catch (Exception e) {
                    throw new RuntimeException("Failed getting propertyName=" + attributeName + " from businessObjecName=" + dataDictionaryBusinessObjectClass.getName(), e);
                }
            }

            if (attributeValue.length() > cellWidth) {
                cellWidth = attributeValue.length();
            }

            cellWidthList.add(cellWidth);
        }

        int numberOfCell = cellWidthList.size();
        int rowCount = (int) Math.ceil(numberOfCell * 1.0 / columnCount);
        for (int colIndex = 0; colIndex < columnCount; colIndex++) {
            int longestLength = cellWidthList.get(colIndex);

            for (int rowIndex = 1; rowIndex < rowCount; rowIndex++) {
                int currentIndex = rowIndex * columnCount + colIndex;
                if (currentIndex >= numberOfCell) {
                    break;
                }

                int currentLength = cellWidthList.get(currentIndex);
                if (currentLength > longestLength) {
                    cellWidthList.set(colIndex, currentLength);
                }
            }
        }

        for (int colIndex = 0; colIndex < columnCount; colIndex++) {
            int longestLength = cellWidthList.get(colIndex);

            for (int rowIndex = 1; rowIndex < rowCount; rowIndex++) {
                int currentIndex = rowIndex * columnCount + colIndex;
                if (currentIndex >= numberOfCell) {
                    break;
                }

                cellWidthList.set(currentIndex, longestLength);
            }
        }

        return cellWidthList;
    }
    
    /**
     * get the alignment definitions of all table cells in one row according to the property's formatter class
     * 
     * @return the alignment definitions of all table cells in one row according to the property's formatter class
     */
    public List<String> getTableCellAlignment() {
        List<String> cellWidthList = new ArrayList<String>();
        List<Class<? extends Formatter>> numberFormatters = this.getNumberFormatters();
        
        for (Map.Entry<String, String> entry : orderedPropertyNameToHeaderLabelMap.entrySet()) {
            String attributeName = entry.getKey();
            
            boolean isNumber = false;
            if (!attributeName.startsWith(OLEConstants.ReportConstants.EMPTY_CELL_ENTRY_KEY_PREFIX)) {
                try {
                    Class<? extends Formatter> formatterClass = this.retrievePropertyFormatterClass(dataDictionaryBusinessObjectClass, attributeName);
                    
                    isNumber = numberFormatters.contains(formatterClass);
                }
                catch (Exception e) {
                    throw new RuntimeException("Failed getting propertyName=" + attributeName + " from businessObjecName=" + dataDictionaryBusinessObjectClass.getName(), e);
                }
            }

            cellWidthList.add(isNumber ? RIGHT_ALIGNMENT : LEFT_ALIGNMENT);
        }
        
        return cellWidthList;
    }

    // put empty strings into the table cell values if the values are not enough to feed the table
    protected void paddingTableCellValues(int numberOfCell, List<String> tableCellValues) {
        int reminder = columnCount - numberOfCell % columnCount;
        if (reminder < columnCount) {
            List<String> paddingObject = new ArrayList<String>(reminder);
            for (int index = 0; index < reminder; index++) {
                paddingObject.add(StringUtils.EMPTY);
            }

            tableCellValues.addAll(paddingObject);
        }
    }
    
    /**
     * get formatter classes defined for numbers
     * 
     * @return the formatter classes defined for numbers
     */
    protected List<Class<? extends Formatter>> getNumberFormatters(){
        List<Class<? extends Formatter>> numberFormatters = new ArrayList<Class<? extends Formatter>>();
        
        numberFormatters.add(BigDecimalFormatter.class);
        numberFormatters.add(CurrencyFormatter.class); 
        numberFormatters.add(KualiIntegerCurrencyFormatter.class);
        numberFormatters.add(PercentageFormatter.class);
        numberFormatters.add(IntegerFormatter.class);
        numberFormatters.add(LongFormatter.class);
        
        return numberFormatters;
    }

    /**
     * Sets the minimumMessageLength
     * 
     * @param minimumMessageLength The minimumMessageLength to set.
     */
    public void setMinimumMessageLength(int minimumMessageLength) {
        this.minimumMessageLength = minimumMessageLength;
    }

    /**
     * Sets the messageLabel
     * 
     * @param messageLabel The messageLabel to set.
     */
    public void setMessageLabel(String messageLabel) {
        this.messageLabel = messageLabel;
    }

    /**
     * Sets the dataDictionaryBusinessObjectClass
     * 
     * @param dataDictionaryBusinessObjectClass The dataDictionaryBusinessObjectClass to set.
     */
    public void setDataDictionaryBusinessObjectClass(Class<? extends BusinessObject> dataDictionaryBusinessObjectClass) {
        this.dataDictionaryBusinessObjectClass = dataDictionaryBusinessObjectClass;
    }

    /**
     * Sets the orderedPropertyNameToHeaderLabelMap
     * 
     * @param orderedPropertyNameToHeaderLabelMap The orderedPropertyNameToHeaderLabelMap to set.
     */
    public void setOrderedPropertyNameToHeaderLabelMap(Map<String, String> orderedPropertyNameToHeaderLabelMap) {
        this.orderedPropertyNameToHeaderLabelMap = orderedPropertyNameToHeaderLabelMap;
    }

    /**
     * Sets the dataDictionaryService
     * 
     * @param dataDictionaryService The dataDictionaryService to set.
     */
    public void setDataDictionaryService(DataDictionaryService dataDictionaryService) {
        this.dataDictionaryService = dataDictionaryService;
    }

    /**
     * Sets the columnCount attribute value.
     * 
     * @param columnCount The columnCount to set.
     */
    public void setColumnCount(int columnCount) {
        this.columnCount = columnCount;
    }

    /**
     * Sets the columnSpanDefinition attribute value.
     * 
     * @param columnSpanDefinition The columnSpanDefinition to set.
     */
    public void setColumnSpanDefinition(Map<String, Integer> columnSpanDefinition) {
        this.columnSpanDefinition = columnSpanDefinition;
    }
}