/*********************************************************************
 *
 *      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.read.biff;

import java.util.ArrayList;
import org.xbib.datastructures.xslx.jxl.WorkbookSettings;
import org.xbib.datastructures.xslx.jxl.biff.BuiltInName;
import org.xbib.datastructures.xslx.jxl.biff.IntegerHelper;
import org.xbib.datastructures.xslx.jxl.biff.RecordData;
import org.xbib.datastructures.xslx.jxl.biff.StringHelper;
import org.xbib.datastructures.xslx.jxl.common.Assert;
import org.xbib.datastructures.xslx.jxl.common.Logger;

/**
 * Holds an excel name record, and the details of the cells/ranges it refers
 * to
 */
public class NameRecord extends RecordData {
    // Constants which refer to the name type
    private static final int commandMacro = 0xc;
    private static final int builtIn = 0x20;
    // Constants which refer to the parse tokens after the string
    private static final int cellReference = 0x3a;
    private static final int areaReference = 0x3b;
    private static final int subExpression = 0x29;
    private static final int union = 0x10;
    public static Biff7 biff7 = new Biff7();

    /**
     * The logger
     */
    private static final Logger logger = Logger.getLogger(NameRecord.class);
    /**
     * The name
     */
    private String name;
    /**
     * The built in name
     */
    private BuiltInName builtInName;
    /**
     * The 0-based index in the name table
     */
    private final int index;
    /**
     * The 0-based index sheet reference for a record name
     * 0 is for a global reference
     */
    private int sheetRef = 0;
    /**
     * Indicates whether this is a biff8 name record.  Used during copying
     */
    private final boolean isbiff8;
    /**
     * The ranges referenced by this name
     */
    private ArrayList ranges;

    /**
     * Constructs this object from the raw data
     *
     * @param t   the raw data
     * @param ws  the workbook settings
     * @param ind the index in the name table
     */
    NameRecord(Record t, WorkbookSettings ws, int ind) {
        super(t);
        index = ind;
        isbiff8 = true;

        try {
            ranges = new ArrayList();

            byte[] data = getRecord().getData();
            int option = IntegerHelper.getInt(data[0], data[1]);
            int length = data[3];
            sheetRef = IntegerHelper.getInt(data[8], data[9]);

            if ((option & builtIn) != 0) {
                builtInName = BuiltInName.getBuiltInName(data[15]);
            } else {
                name = StringHelper.getString(data, length, 15, ws);
            }

            if ((option & commandMacro) != 0) {
                // This is a command macro, so it has no cell references
                return;
            }

            int pos = length + 15;

            if (data[pos] == cellReference) {
                int sheet = IntegerHelper.getInt(data[pos + 1], data[pos + 2]);
                int row = IntegerHelper.getInt(data[pos + 3], data[pos + 4]);
                int columnMask = IntegerHelper.getInt(data[pos + 5], data[pos + 6]);
                int column = columnMask & 0xff;

                // Check that we are not dealing with offsets
                Assert.verify((columnMask & 0xc0000) == 0);

                NameRange r = new NameRange(sheet, column, row, column, row);
                ranges.add(r);
            } else if (data[pos] == areaReference) {
                int sheet1 = 0;
                int r1 = 0;
                int columnMask = 0;
                int c1 = 0;
                int r2 = 0;
                int c2 = 0;
                NameRange range = null;

                while (pos < data.length) {
                    sheet1 = IntegerHelper.getInt(data[pos + 1], data[pos + 2]);
                    r1 = IntegerHelper.getInt(data[pos + 3], data[pos + 4]);
                    r2 = IntegerHelper.getInt(data[pos + 5], data[pos + 6]);

                    columnMask = IntegerHelper.getInt(data[pos + 7], data[pos + 8]);
                    c1 = columnMask & 0xff;

                    // Check that we are not dealing with offsets
                    Assert.verify((columnMask & 0xc0000) == 0);

                    columnMask = IntegerHelper.getInt(data[pos + 9], data[pos + 10]);
                    c2 = columnMask & 0xff;

                    // Check that we are not dealing with offsets
                    Assert.verify((columnMask & 0xc0000) == 0);

                    range = new NameRange(sheet1, c1, r1, c2, r2);
                    ranges.add(range);

                    pos += 11;
                }
            } else if (data[pos] == subExpression) {
                int sheet1 = 0;
                int r1 = 0;
                int columnMask = 0;
                int c1 = 0;
                int r2 = 0;
                int c2 = 0;
                NameRange range = null;

                // Consume unnecessary parsed tokens
                if (pos < data.length &&
                        data[pos] != cellReference &&
                        data[pos] != areaReference) {
                    if (data[pos] == subExpression) {
                        pos += 3;
                    } else if (data[pos] == union) {
                        pos += 1;
                    }
                }

                while (pos < data.length) {
                    sheet1 = IntegerHelper.getInt(data[pos + 1], data[pos + 2]);
                    r1 = IntegerHelper.getInt(data[pos + 3], data[pos + 4]);
                    r2 = IntegerHelper.getInt(data[pos + 5], data[pos + 6]);

                    columnMask = IntegerHelper.getInt(data[pos + 7], data[pos + 8]);
                    c1 = columnMask & 0xff;

                    // Check that we are not dealing with offsets
                    Assert.verify((columnMask & 0xc0000) == 0);

                    columnMask = IntegerHelper.getInt(data[pos + 9], data[pos + 10]);
                    c2 = columnMask & 0xff;

                    // Check that we are not dealing with offsets
                    Assert.verify((columnMask & 0xc0000) == 0);

                    range = new NameRange(sheet1, c1, r1, c2, r2);
                    ranges.add(range);

                    pos += 11;

                    // Consume unnecessary parsed tokens
                    if (pos < data.length &&
                            data[pos] != cellReference &&
                            data[pos] != areaReference) {
                        if (data[pos] == subExpression) {
                            pos += 3;
                        } else if (data[pos] == union) {
                            pos += 1;
                        }
                    }
                }
            } else {
                String n = name != null ? name : builtInName.getName();
                logger.warn("Cannot read name ranges for " + n +
                        " - setting to empty");
                NameRange range = new NameRange(0, 0, 0, 0, 0);
                ranges.add(range);
            }
        } catch (Throwable t1) {
            // Generate a warning
            // Names are really a nice to have, and we don't want to halt the
            // reading process for functionality that probably won't be used
            logger.warn("Cannot read name");
            name = "ERROR";
        }
    }

    /**
     * Constructs this object from the raw data
     *
     * @param t     the raw data
     * @param ws    the workbook settings
     * @param ind   the index in the name table
     * @param dummy dummy parameter to indicate a biff7 workbook
     */
    NameRecord(Record t, WorkbookSettings ws, int ind, Biff7 dummy) {
        super(t);
        index = ind;
        isbiff8 = false;

        try {
            ranges = new ArrayList();
            byte[] data = getRecord().getData();
            int length = data[3];
            sheetRef = IntegerHelper.getInt(data[8], data[9]);
            name = StringHelper.getString(data, length, 14, ws);

            int pos = length + 14;

            if (pos >= data.length) {
                // There appears to be nothing after the name, so return
                return;
            }

            if (data[pos] == cellReference) {
                int sheet = IntegerHelper.getInt(data[pos + 11], data[pos + 12]);
                int row = IntegerHelper.getInt(data[pos + 15], data[pos + 16]);
                int column = data[pos + 17];

                NameRange r = new NameRange(sheet, column, row, column, row);
                ranges.add(r);
            } else if (data[pos] == areaReference) {
                int sheet1 = 0;
                int r1 = 0;
                int c1 = 0;
                int r2 = 0;
                int c2 = 0;
                NameRange range = null;

                while (pos < data.length) {
                    sheet1 = IntegerHelper.getInt(data[pos + 11], data[pos + 12]);
                    r1 = IntegerHelper.getInt(data[pos + 15], data[pos + 16]);
                    r2 = IntegerHelper.getInt(data[pos + 17], data[pos + 18]);

                    c1 = data[pos + 19];
                    c2 = data[pos + 20];

                    range = new NameRange(sheet1, c1, r1, c2, r2);
                    ranges.add(range);

                    pos += 21;
                }
            } else if (data[pos] == subExpression) {
                int sheet1 = 0;
                int sheet2 = 0;
                int r1 = 0;
                int c1 = 0;
                int r2 = 0;
                int c2 = 0;
                NameRange range = null;

                // Consume unnecessary parsed tokens
                if (pos < data.length &&
                        data[pos] != cellReference &&
                        data[pos] != areaReference) {
                    if (data[pos] == subExpression) {
                        pos += 3;
                    } else if (data[pos] == union) {
                        pos += 1;
                    }
                }

                while (pos < data.length) {
                    sheet1 = IntegerHelper.getInt(data[pos + 11], data[pos + 12]);
                    r1 = IntegerHelper.getInt(data[pos + 15], data[pos + 16]);
                    r2 = IntegerHelper.getInt(data[pos + 17], data[pos + 18]);

                    c1 = data[pos + 19];
                    c2 = data[pos + 20];

                    range = new NameRange(sheet1, c1, r1, c2, r2);
                    ranges.add(range);

                    pos += 21;

                    // Consume unnecessary parsed tokens
                    if (pos < data.length &&
                            data[pos] != cellReference &&
                            data[pos] != areaReference) {
                        if (data[pos] == subExpression) {
                            pos += 3;
                        } else if (data[pos] == union) {
                            pos += 1;
                        }
                    }
                }
            }
        } catch (Throwable t1) {
            // Generate a warning
            // Names are really a nice to have, and we don't want to halt the
            // reading process for functionality that probably won't be used
            logger.warn("Cannot read name.");
            name = "ERROR";
        }
    }

    /**
     * Gets the name
     *
     * @return the strings
     */
    public String getName() {
        return name;
    }

    /**
     * Gets the built in name
     *
     * @return the built in name
     */
    public BuiltInName getBuiltInName() {
        return builtInName;
    }

    /**
     * Gets the array of ranges for this name.  This method is public as it is
     * used from the writable side when copying ranges
     *
     * @return the ranges
     */
    public NameRange[] getRanges() {
        NameRange[] nr = new NameRange[ranges.size()];
        return (NameRange[]) ranges.toArray(nr);
    }

    /**
     * Accessor for the index into the name table
     *
     * @return the 0-based index into the name table
     */
    int getIndex() {
        return index;
    }

    /**
     * The 0-based index sheet reference for a record name
     * 0 is for a global reference
     *
     * @return the sheet reference for name formula
     */
    public int getSheetRef() {
        return sheetRef;
    }

    /**
     * Set the index sheet reference for a record name
     * 0 is for a global reference
     */
    public void setSheetRef(int i) {
        sheetRef = i;
    }

    /**
     * Called when copying a sheet.  Just returns the raw data
     *
     * @return the raw data
     */
    public byte[] getData() {
        return getRecord().getData();
    }

    /**
     * Called when copying to determine whether this is a biff8 name
     *
     * @return TRUE if this is a biff8 name record, FALSE otherwise
     */
    public boolean isBiff8() {
        return isbiff8;
    }

    /**
     * Queries whether this is a global name or not
     *
     * @return TRUE if this is a global name, FALSE otherwise
     */
    public boolean isGlobal() {
        return sheetRef == 0;
    }

    /**
     * Dummy indicators for overloading the constructor
     */
    private static class Biff7 {
    }

    /**
     * A nested class to hold range information
     */
    public class NameRange {
        /**
         * The first column
         */
        private final int columnFirst;

        /**
         * The first row
         */
        private final int rowFirst;

        /**
         * The last column
         */
        private final int columnLast;

        /**
         * The last row
         */
        private final int rowLast;

        /**
         * The first sheet
         */
        private final int externalSheet;

        /**
         * Constructor
         *
         * @param s1 the sheet
         * @param c1 the first column
         * @param r1 the first row
         * @param c2 the last column
         * @param r2 the last row
         */
        NameRange(int s1, int c1, int r1, int c2, int r2) {
            columnFirst = c1;
            rowFirst = r1;
            columnLast = c2;
            rowLast = r2;
            externalSheet = s1;
        }

        /**
         * Accessor for the first column
         *
         * @return the index of the first column
         */
        public int getFirstColumn() {
            return columnFirst;
        }

        /**
         * Accessor for the first row
         *
         * @return the index of the first row
         */
        public int getFirstRow() {
            return rowFirst;
        }

        /**
         * Accessor for the last column
         *
         * @return the index of the last column
         */
        public int getLastColumn() {
            return columnLast;
        }

        /**
         * Accessor for the last row
         *
         * @return the index of the last row
         */
        public int getLastRow() {
            return rowLast;
        }

        /**
         * Accessor for the first sheet
         *
         * @return the index of the external  sheet
         */
        public int getExternalSheet() {
            return externalSheet;
        }
    }
}

