/* ====================================================================
   Licensed to the Apache Software Foundation (ASF) Under one or more
   contributor license agreements.  See the NOTICE file distributed with
   this work for Additional information regarding copyright ownership.
   The ASF licenses this file to You Under the Apache 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.apache.org/licenses/LICENSE-2.0

   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.
==================================================================== */


namespace HH.WMS.Utils.NPOI.HSSF.Record.Aggregates
{

    using System;
    using System.Text;
    using System.Collections;
    using HH.WMS.Utils.NPOI.DDF;
    using HH.WMS.Utils.NPOI.Util;
    using HH.WMS.Utils.NPOI.HSSF.Record;
    using HH.WMS.Utils.NPOI.SS.Formula;
    using HH.WMS.Utils.NPOI.HSSF.Model;
    using HH.WMS.Utils.NPOI.SS.Formula.PTG;

    /**
     *
     * Aggregate value records toGether.  Things are easier to handle that way.
     *
     * @author  andy
     * @author  Glen Stampoultzis (glens at apache.org)
     * @author Jason Height (jheight at chariot dot net dot au)
     */

    public class ValueRecordsAggregate
    {
        const int MAX_ROW_INDEX = 0XFFFF;
        const int INDEX_NOT_SET = -1;
        public const short sid = -1001; // 1000 clashes with RowRecordsAggregate
        int firstcell = INDEX_NOT_SET;
        int lastcell = INDEX_NOT_SET;
        CellValueRecordInterface[][] records;

        /** Creates a new instance of ValueRecordsAggregate */

        public ValueRecordsAggregate():
            this(INDEX_NOT_SET, INDEX_NOT_SET, new CellValueRecordInterface[30][]) // We start with 30 Rows.
        {
            
        }
        private ValueRecordsAggregate(int firstCellIx, int lastCellIx, CellValueRecordInterface[][] pRecords)
        {
            firstcell = firstCellIx;
            lastcell = lastCellIx;
            records = pRecords;
        }

        public void InsertCell(CellValueRecordInterface cell)
        {
            int column = cell.Column;
            int row = cell.Row;
            if (row >= records.Length)
            {
                CellValueRecordInterface[][] oldRecords = records;
                int newSize = oldRecords.Length * 2;
                if (newSize < row + 1) newSize = row + 1;
                records = new CellValueRecordInterface[newSize][];
                Array.Copy(oldRecords, 0, records, 0, oldRecords.Length);
            }
            object objRowCells = records[row];
            if (objRowCells == null)
            {
                int newSize = column + 1;
                if (newSize < 10) newSize = 10;
                objRowCells = new CellValueRecordInterface[newSize];
                records[row] = (CellValueRecordInterface[])objRowCells;
            }
            CellValueRecordInterface[] rowCells = (CellValueRecordInterface[])objRowCells;
            if (column >= rowCells.Length)
            {
                CellValueRecordInterface[] oldRowCells = rowCells;
                int newSize = oldRowCells.Length * 2;
                if (newSize < column + 1) newSize = column + 1;
                // if(newSize>257) newSize=257; // activate?
                rowCells = new CellValueRecordInterface[newSize];
                Array.Copy(oldRowCells, 0, rowCells, 0, oldRowCells.Length);
                records[row] = rowCells;
            }
            rowCells[column] = cell;

            if ((column < firstcell) || (firstcell == -1))
            {
                firstcell = column;
            }
            if ((column > lastcell) || (lastcell == -1))
            {
                lastcell = column;
            }
        }

        public void RemoveCell(CellValueRecordInterface cell)
        {
            if (cell == null)
            {
                throw new ArgumentException("cell must not be null");
            }

            int row = cell.Row;
            if (row >= records.Length)
            {
                throw new Exception("cell row is out of range"); 
            }
            CellValueRecordInterface[] rowCells = records[row];
            if (rowCells == null)
            {
                throw new Exception("cell row is already empty");
            }
            int column = cell.Column;
            if (column >= rowCells.Length)
            {
                throw new Exception("cell column is out of range");
            }
            rowCells[column] = null;
            
        }
        public void RemoveAllCellsValuesForRow(int rowIndex)
        {
            if (rowIndex < 0 || rowIndex > MAX_ROW_INDEX)
            {
                throw new ArgumentException("Specified rowIndex " + rowIndex
                        + " is outside the allowable range (0.." + MAX_ROW_INDEX + ")");
            }
            if (rowIndex >= records.Length)
            {
                // this can happen when the client code has created a row,
                // and then removes/replaces it before adding any cells. (see bug 46312)
                return;
            }

            records[rowIndex] = null;
        }
        public CellValueRecordInterface[] GetValueRecords()
        {
            ArrayList temp = new ArrayList();

            for (int i = 0; i < records.Length; i++)
            {
                CellValueRecordInterface[] rowCells = records[i];
                if (rowCells == null)
                {
                    continue;
                }
                for (int j = 0; j < rowCells.Length; j++)
                {
                    CellValueRecordInterface cell = rowCells[j];
                    if (cell != null)
                    {
                        temp.Add(cell);
                    }
                }
            }
             return (CellValueRecordInterface[])temp.ToArray(typeof(CellValueRecordInterface));
        }
        public int PhysicalNumberOfCells
        {
            get
            {
                int count = 0;
                for (int r = 0; r < records.Length; r++)
                {
                    CellValueRecordInterface[] rowCells = records[r];
                    if (rowCells != null)
                        for (short c = 0; c < rowCells.Length; c++)
                        {
                            if (rowCells[c] != null) count++;
                        }
                }
                return count;
            }
        }

        public int FirstCellNum
        {
            get
            {
                return firstcell;
            }
        }

        public int LastCellNum
        {
            get
            {
                return lastcell;
            }
        }
        public void AddMultipleBlanks(MulBlankRecord mbr)
        {
            for (int j = 0; j < mbr.NumColumns; j++)
            {
                BlankRecord br = new BlankRecord();

                br.Column = j + mbr.FirstColumn;
                br.Row = mbr.Row;
                br.XFIndex = (mbr.GetXFAt(j));
                InsertCell(br);
            }
        }
        private MulBlankRecord CreateMBR(CellValueRecordInterface[] cellValues, int startIx, int nBlank)
        {

            short[] xfs = new short[nBlank];
            for (int i = 0; i < xfs.Length; i++)
            {
                xfs[i] = ((BlankRecord)cellValues[startIx + i]).XFIndex;
            }
            int rowIx = cellValues[startIx].Row;
            return new MulBlankRecord(rowIx, startIx, xfs);
        }

        public void Construct(CellValueRecordInterface rec, RecordStream rs, SharedValueManager sfh)
        {
            if (rec is FormulaRecord)
            {
                FormulaRecord formulaRec = (FormulaRecord)rec;
                // read optional cached text value
                StringRecord cachedText=null;
                Type nextClass = rs.PeekNextClass();
                if (nextClass == typeof(StringRecord))
                {
                    cachedText = (StringRecord)rs.GetNext();
                }
                else
                {
                    cachedText = null;
                }
                InsertCell(new FormulaRecordAggregate(formulaRec, cachedText, sfh));
            }
            else
            {
                InsertCell(rec);
            }
        }

        /**
         * Sometimes the shared formula flag "seems" to be erroneously Set, in which case there is no 
         * call to <c>SharedFormulaRecord.ConvertSharedFormulaRecord</c> and hence the 
         * <c>ParsedExpression</c> field of this <c>FormulaRecord</c> will not Get updated.<br/>
         * As it turns out, this is not a problem, because in these circumstances, the existing value
         * for <c>ParsedExpression</c> is perfectly OK.<p/>
         * 
         * This method may also be used for Setting breakpoints to help diagnose Issues regarding the
         * abnormally-Set 'shared formula' flags. 
         * (see TestValueRecordsAggregate.testSpuriousSharedFormulaFlag()).<p/>
         * 
         * The method currently does nothing but do not delete it without Finding a nice home for this 
         * comment.
         */
        static void HandleMissingSharedFormulaRecord(FormulaRecord formula)
        {
            // could log an info message here since this is a fairly Unusual occurrence.
        }


        /** Tallies a count of the size of the cell records
         *  that are attached to the rows in the range specified.
         */
        public int GetRowCellBlockSize(int startRow, int endRow)
        {
            MyEnumerator itr = new MyEnumerator(ref records,startRow, endRow);
            int size = 0;
            while (itr.MoveNext())
            {
                CellValueRecordInterface cell = (CellValueRecordInterface)itr.Current;
                int row = cell.Row;
                if (row > endRow)
                    break;
                if ((row >= startRow) && (row <= endRow))
                    size += ((RecordBase)cell).RecordSize;
            }
            return size;
        }

        /** Returns true if the row has cells attached to it */
        public bool RowHasCells(int row)
        {
            if (row > records.Length - 1) //previously this said row > records.Length which means if 
                return false;  // if records.Length == 60 and I pass "60" here I Get array out of bounds
            CellValueRecordInterface[] rowCells = records[row]; //because a 60 Length array has the last index = 59
            if (rowCells == null) return false;
            for (int col = 0; col < rowCells.Length; col++)
            {
                if (rowCells[col] != null) return true;
            }
            return false;
        }
        public void UpdateFormulasAfterRowShift(FormulaShifter shifter, int currentExternSheetIndex)
        {
            for (int i = 0; i < records.Length; i++)
            {
                CellValueRecordInterface[] rowCells = records[i];
                if (rowCells == null)
                {
                    continue;
                }
                for (int j = 0; j < rowCells.Length; j++)
                {
                    CellValueRecordInterface cell = rowCells[j];
                    if (cell is FormulaRecordAggregate)
                    {
                        FormulaRecord fr = ((FormulaRecordAggregate)cell).FormulaRecord;
                        Ptg[] ptgs = fr.ParsedExpression; // needs clone() inside this getter?
                        if (shifter.AdjustFormula(ptgs, currentExternSheetIndex))
                        {
                            fr.ParsedExpression = (ptgs);
                        }
                    }
                }
            }
        }

        public void VisitCellsForRow(int rowIndex, RecordVisitor rv)
        {

            CellValueRecordInterface[] rowCells = records[rowIndex];
            if (rowCells == null)
            {
                throw new ArgumentException("Row [" + rowIndex + "] is empty");
            }
            for (int i = 0; i < rowCells.Length; i++)
            {
                RecordBase cvr = (RecordBase)rowCells[i];
                if (cvr == null)
                {
                    continue;
                }
                int nBlank = CountBlanks(rowCells, i);
                if (nBlank > 1)
                {
                    rv.VisitRecord(CreateMBR(rowCells, i, nBlank));
                    i += nBlank - 1;
                }
                else if (cvr is RecordAggregate)
                {
                    RecordAggregate agg = (RecordAggregate)cvr;
                    agg.VisitContainedRecords(rv);
                }
                else
                {
                    rv.VisitRecord((Record)cvr);
                }
            }
        }
        static int CountBlanks(CellValueRecordInterface[] rowCellValues, int startIx)
        {
            int i = startIx;
            while (i < rowCellValues.Length)
            {
                CellValueRecordInterface cvr = rowCellValues[i];
                if (!(cvr is BlankRecord))
                {
                    break;
                }
                i++;
            }
            return i - startIx;
        }
        /** Serializes the cells that are allocated to a certain row range*/
        public int SerializeCellRow(int row, int offset, byte[] data)
        {
            MyEnumerator itr = new MyEnumerator(ref records,row, row);
            int pos = offset;

            while (itr.MoveNext())
            {
                CellValueRecordInterface cell = (CellValueRecordInterface)itr.Current;
                if (cell.Row != row)
                    break;
                pos += ((RecordBase)cell).Serialize(pos, data);
            }
            return pos - offset;
        }

        public IEnumerator GetEnumerator()
        {
            return new MyEnumerator(ref records);
        }

        private class MyEnumerator : IEnumerator
        {
            short nextColumn = -1;
            int nextRow, lastRow;

            CellValueRecordInterface[][] records;

            public MyEnumerator(ref CellValueRecordInterface[][] _records)
            {
                this.records = _records;
                this.nextRow = 0;
                this.lastRow = _records.Length - 1;
                //FindNext();
            }

            public MyEnumerator(ref CellValueRecordInterface[][] _records,int firstRow, int lastRow)
            {
                this.records = _records;
                this.nextRow = firstRow;
                this.lastRow = lastRow;
                //FindNext();
            }
            public bool MoveNext()
            {
                
                FindNext();
                return nextRow <= lastRow; ;
            }
            public Object Current
            {
                get
                {
                    Object o = this.records[nextRow][nextColumn];

                    return o;
                }
            }
            public void Remove()
            {
                throw new InvalidOperationException("gibt's noch nicht");
            }

            private void FindNext()
            {
                nextColumn++;
                for (; nextRow <= lastRow; nextRow++)
                {
                    //previously this threw array out of bounds...
                    CellValueRecordInterface[] rowCells = (nextRow < records.Length) ? records[nextRow] : null;
                    if (rowCells == null)
                    { // This row is empty
                        nextColumn = 0;
                        continue;
                    }
                    for (; nextColumn < rowCells.Length; nextColumn++)
                    {
                        if (rowCells[nextColumn] != null) return;
                    }
                    nextColumn = 0;
                }
            }
            public void Reset()
            {
                nextColumn = -1;
                nextRow = 0;
            }
        }
    }
}