/*********************************************************************
 *
 *      Copyright (C) 2002 Andrew Khan
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
 ***************************************************************************/

package org.xbib.datastructures.xslx.jxl.biff;

import java.text.DateFormat;
import java.text.DecimalFormat;
import java.text.NumberFormat;
import java.text.SimpleDateFormat;
import org.xbib.datastructures.xslx.jxl.WorkbookSettings;
import org.xbib.datastructures.xslx.jxl.common.Logger;
import org.xbib.datastructures.xslx.jxl.format.Format;
import org.xbib.datastructures.xslx.jxl.read.biff.Record;

/**
 * A non-built in format record
 */
public class FormatRecord extends WritableRecordData
        implements DisplayFormat, Format {
    public static final BiffType biff8 = new BiffType();
    public static final BiffType biff7 = new BiffType();
    /**
     * The logger
     */
    public static Logger logger = Logger.getLogger(FormatRecord.class);
    /**
     * The date strings to look for
     */
    private static final String[] dateStrings = new String[]
            {
                    "dd",
                    "mm",
                    "yy",
                    "hh",
                    "ss",
                    "m/",
                    "/d"
            };
    /**
     * Initialized flag
     */
    private boolean initialized;
    /**
     * The raw data
     */
    private byte[] data;
    /**
     * The index code
     */
    private int indexCode;
    /**
     * The formatting string
     */
    private String formatString;
    /**
     * Indicates whether this is a date formatting record
     */
    private boolean date;
    /**
     * Indicates whether this a number formatting record
     */
    private boolean number;
    /**
     * The format object
     */
    private java.text.Format format;
    /**
     * Constructor invoked when copying sheets
     *
     * @param fmt   the format string
     * @param refno the index code
     */
    FormatRecord(String fmt, int refno) {
        super(Type.FORMAT);
        formatString = fmt;
        indexCode = refno;
        initialized = true;
    }

    /**
     * Constructor used by writable formats
     */
    protected FormatRecord() {
        super(Type.FORMAT);
        initialized = false;
    }

    /**
     * Copy constructor - can be invoked by public access
     *
     * @param fr the format to copy
     */
    protected FormatRecord(FormatRecord fr) {
        super(Type.FORMAT);
        initialized = false;

        formatString = fr.formatString;
        date = fr.date;
        number = fr.number;
        //    format = (java.text.Format) fr.format.clone();
    }

    /**
     * Constructs this object from the raw data.  Used when reading in a
     * format record
     *
     * @param t        the raw data
     * @param ws       the workbook settings
     * @param biffType biff type dummy overload
     */
    public FormatRecord(Record t, WorkbookSettings ws, BiffType biffType) {
        super(t);

        byte[] data = getRecord().getData();
        indexCode = IntegerHelper.getInt(data[0], data[1]);
        initialized = true;

        if (biffType == biff8) {
            int numchars = IntegerHelper.getInt(data[2], data[3]);
            if (data[4] == 0) {
                formatString = StringHelper.getString(data, numchars, 5, ws);
            } else {
                formatString = StringHelper.getUnicodeString(data, numchars, 5);
            }
        } else {
            int numchars = data[2];
            byte[] chars = new byte[numchars];
            System.arraycopy(data, 3, chars, 0, chars.length);
            formatString = new String(chars);
        }

        date = false;
        number = false;

        // First see if this is a date format
        for (int i = 0; i < dateStrings.length; i++) {
            String dateString = dateStrings[i];
            if (formatString.indexOf(dateString) != -1 ||
                    formatString.indexOf(dateString.toUpperCase()) != -1) {
                date = true;
                break;
            }
        }

        // See if this is number format - look for the # or 0 characters
        if (!date) {
            if (formatString.indexOf('#') != -1 ||
                    formatString.indexOf('0') != -1) {
                number = true;
            }
        }
    }

    /**
     * Used to get the data when writing out the format record
     *
     * @return the raw data
     */
    public byte[] getData() {
        data = new byte[formatString.length() * 2 + 3 + 2];

        IntegerHelper.getTwoBytes(indexCode, data, 0);
        IntegerHelper.getTwoBytes(formatString.length(), data, 2);
        data[4] = (byte) 1; // unicode indicator
        StringHelper.getUnicodeBytes(formatString, data, 5);

        return data;
    }

    /**
     * Gets the format index of this record
     *
     * @return the format index of this record
     */
    public int getFormatIndex() {
        return indexCode;
    }

    /**
     * Accessor to see whether this object is initialized or not.
     *
     * @return TRUE if this font record has been initialized, FALSE otherwise
     */
    public boolean isInitialized() {
        return initialized;
    }

    /**
     * Sets the index of this record.  Called from the FormattingRecords
     * object
     *
     * @param pos the position of this font in the workbooks font list
     */

    public void initialize(int pos) {
        indexCode = pos;
        initialized = true;
    }

    /**
     * Replaces all instances of search with replace in the input.  Used for
     * replacing microsoft number formatting characters with java equivalents
     *
     * @param input   the format string
     * @param search  the Excel character to be replaced
     * @param replace the java equivalent
     * @return the input string with the specified substring replaced
     */
    protected final String replace(String input, String search, String replace) {
        String fmtstr = input;
        int pos = fmtstr.indexOf(search);
        while (pos != -1) {
            StringBuffer tmp = new StringBuffer(fmtstr.substring(0, pos));
            tmp.append(replace);
            tmp.append(fmtstr.substring(pos + search.length()));
            fmtstr = tmp.toString();
            pos = fmtstr.indexOf(search);
        }
        return fmtstr;
    }

    /**
     * Sees if this format is a date format
     *
     * @return TRUE if this format is a date
     */
    public final boolean isDate() {
        return date;
    }

    /**
     * Sees if this format is a number format
     *
     * @return TRUE if this format is a number
     */
    public final boolean isNumber() {
        return number;
    }

    /**
     * Gets the java equivalent number format for the formatString
     *
     * @return The java equivalent of the number format for this object
     */
    public final NumberFormat getNumberFormat() {
        if (format != null && format instanceof NumberFormat) {
            return (NumberFormat) format;
        }

        try {
            String fs = formatString;

            // Replace the Excel formatting characters with java equivalents
            fs = replace(fs, "E+", "E");
            fs = replace(fs, "_)", "");
            fs = replace(fs, "_", "");
            fs = replace(fs, "[Red]", "");
            fs = replace(fs, "\\", "");

            format = new DecimalFormat(fs);
        } catch (IllegalArgumentException e) {
            // Something went wrong with the date format - fail silently
            // and return a default value
            format = new DecimalFormat("#.###");
        }

        return (NumberFormat) format;
    }

    /**
     * Gets the java equivalent date format for the formatString
     *
     * @return The java equivalent of the date format for this object
     */
    public final DateFormat getDateFormat() {
        if (format != null && format instanceof DateFormat) {
            return (DateFormat) format;
        }

        String fmt = formatString;

        // Replace the AM/PM indicator with an a
        int pos = fmt.indexOf("AM/PM");
        while (pos != -1) {
            StringBuffer sb = new StringBuffer(fmt.substring(0, pos));
            sb.append('a');
            sb.append(fmt.substring(pos + 5));
            fmt = sb.toString();
            pos = fmt.indexOf("AM/PM");
        }

        // Replace ss.0 with ss.SSS (necessary to always specify milliseconds
        // because of NT)
        pos = fmt.indexOf("ss.0");
        while (pos != -1) {
            StringBuffer sb = new StringBuffer(fmt.substring(0, pos));
            sb.append("ss.SSS");

            // Keep going until we run out of zeros
            pos += 4;
            while (pos < fmt.length() && fmt.charAt(pos) == '0') {
                pos++;
            }

            sb.append(fmt.substring(pos));
            fmt = sb.toString();
            pos = fmt.indexOf("ss.0");
        }


        // Filter out the backslashes
        StringBuffer sb = new StringBuffer();
        for (int i = 0; i < fmt.length(); i++) {
            if (fmt.charAt(i) != '\\') {
                sb.append(fmt.charAt(i));
            }
        }

        fmt = sb.toString();

        // If the date format starts with anything inside square brackets then
        // filter tham out
        if (fmt.charAt(0) == '[') {
            int end = fmt.indexOf(']');
            if (end != -1) {
                fmt = fmt.substring(end + 1);
            }
        }

        // Get rid of some spurious characters that can creep in
        fmt = replace(fmt, ";@", "");

        // We need to convert the month indicator m, to upper case when we
        // are dealing with dates
        char[] formatBytes = fmt.toCharArray();

        for (int i = 0; i < formatBytes.length; i++) {
            if (formatBytes[i] == 'm') {
                // Firstly, see if the preceding character is also an m.  If so,
                // copy that
                if (i > 0 && (formatBytes[i - 1] == 'm' || formatBytes[i - 1] == 'M')) {
                    formatBytes[i] = formatBytes[i - 1];
                } else {
                    // There is no easy way out.  We have to deduce whether this an
                    // minute or a month?  See which is closest out of the
                    // letters H d s or y
                    // First, h
                    int minuteDist = Integer.MAX_VALUE;
                    for (int j = i - 1; j > 0; j--) {
                        if (formatBytes[j] == 'h') {
                            minuteDist = i - j;
                            break;
                        }
                    }

                    for (int j = i + 1; j < formatBytes.length; j++) {
                        if (formatBytes[j] == 'h') {
                            minuteDist = Math.min(minuteDist, j - i);
                            break;
                        }
                    }

                    for (int j = i - 1; j > 0; j--) {
                        if (formatBytes[j] == 'H') {
                            minuteDist = i - j;
                            break;
                        }
                    }

                    for (int j = i + 1; j < formatBytes.length; j++) {
                        if (formatBytes[j] == 'H') {
                            minuteDist = Math.min(minuteDist, j - i);
                            break;
                        }
                    }

                    // Now repeat for s
                    for (int j = i - 1; j > 0; j--) {
                        if (formatBytes[j] == 's') {
                            minuteDist = Math.min(minuteDist, i - j);
                            break;
                        }
                    }
                    for (int j = i + 1; j < formatBytes.length; j++) {
                        if (formatBytes[j] == 's') {
                            minuteDist = Math.min(minuteDist, j - i);
                            break;
                        }
                    }
                    // We now have the distance of the closest character which could
                    // indicate the the m refers to a minute
                    // Repeat for d and y
                    int monthDist = Integer.MAX_VALUE;
                    for (int j = i - 1; j > 0; j--) {
                        if (formatBytes[j] == 'd') {
                            monthDist = i - j;
                            break;
                        }
                    }

                    for (int j = i + 1; j < formatBytes.length; j++) {
                        if (formatBytes[j] == 'd') {
                            monthDist = Math.min(monthDist, j - i);
                            break;
                        }
                    }
                    // Now repeat for y
                    for (int j = i - 1; j > 0; j--) {
                        if (formatBytes[j] == 'y') {
                            monthDist = Math.min(monthDist, i - j);
                            break;
                        }
                    }
                    for (int j = i + 1; j < formatBytes.length; j++) {
                        if (formatBytes[j] == 'y') {
                            monthDist = Math.min(monthDist, j - i);
                            break;
                        }
                    }

                    if (monthDist < minuteDist) {
                        // The month indicator is closer, so convert to a capital M
                        formatBytes[i] = Character.toUpperCase(formatBytes[i]);
                    } else if ((monthDist == minuteDist) &&
                            (monthDist != Integer.MAX_VALUE)) {
                        // They are equidistant.  As a tie-breaker, take the formatting
                        // character which precedes the m
                        char ind = formatBytes[i - monthDist];
                        if (ind == 'y' || ind == 'd') {
                            // The preceding item indicates a month measure, so convert
                            formatBytes[i] = Character.toUpperCase(formatBytes[i]);
                        }
                    }
                }
            }
        }

        try {
            this.format = new SimpleDateFormat(new String(formatBytes));
        } catch (IllegalArgumentException e) {
            // There was a spurious character - fail silently
            this.format = new SimpleDateFormat("dd MM yyyy hh:mm:ss");
        }
        return (DateFormat) this.format;
    }

    /**
     * Gets the index code, for use as a hash value
     *
     * @return the ifmt code for this cell
     */
    public int getIndexCode() {
        return indexCode;
    }

    /**
     * Gets the formatting string.
     *
     * @return the excel format string
     */
    public String getFormatString() {
        return formatString;
    }

    /**
     * Called by the immediate subclass to set the string
     * once the Java-Excel replacements have been done
     *
     * @param s the format string
     */
    protected final void setFormatString(String s) {
        formatString = s;
    }

    /**
     * Indicates whether this formula is a built in
     *
     * @return FALSE
     */
    public boolean isBuiltIn() {
        return false;
    }

    /**
     * Standard hash code method
     *
     * @return the hash code value for this object
     */
    public int hashCode() {
        return formatString.hashCode();
    }

    /**
     * Standard equals method.  This compares the contents of two
     * format records, and not their indexCodes, which are ignored
     *
     * @param o the object to compare
     * @return TRUE if the two objects are equal, FALSE otherwise
     */
    public boolean equals(Object o) {
        if (o == this) {
            return true;
        }

        if (!(o instanceof FormatRecord)) {
            return false;
        }

        FormatRecord fr = (FormatRecord) o;

        // Initialized format comparison
        if (initialized && fr.initialized) {
            // Must be either a number or a date format
            if (date != fr.date ||
                    number != fr.number) {
                return false;
            }

            return formatString.equals(fr.formatString);
        }

        // Uninitialized format comparison
        return formatString.equals(fr.formatString);
    }

    // Type to distinguish between biff7 and biff8
    private static class BiffType {
    }
}






