// SpryNestedXMLDataSet.js - version 0.7 - Spry Pre-Release 1.6.1
//
// Copyright (c) 2007. Adobe Systems Incorporated.
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are met:
//
//   * Redistributions of source code must retain the above copyright notice,
//     this list of conditions and the following disclaimer.
//   * Redistributions in binary form must reproduce the above copyright notice,
//     this list of conditions and the following disclaimer in the documentation
//     and/or other materials provided with the distribution.
//   * Neither the name of Adobe Systems Incorporated nor the names of its
//     contributors may be used to endorse or promote products derived from this
//     software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
// POSSIBILITY OF SUCH DAMAGE.

Spry.Data.NestedXMLDataSet = function(parentDataSet, xpath, options)
{
        this.parentDataSet = parentDataSet;
        this.xpath = xpath;
        this.nestedDataSets = [];
        this.nestedDataSetsHash = {};
        this.currentDS = null;
        this.currentDSAncestor = null;
        this.options = options;
        this.ignoreOnDataChanged = false;
        this.entityEncodeStrings = parentDataSet ? parentDataSet.entityEncodeStrings : true;

        Spry.Data.DataSet.call(this, options);

        parentDataSet.addObserver(this);
};

Spry.Data.NestedXMLDataSet.prototype = new Spry.Data.DataSet();
Spry.Data.NestedXMLDataSet.prototype.constructor = Spry.Data.NestedXMLDataSet.prototype;

Spry.Data.NestedXMLDataSet.prototype.getParentDataSet = function()
{
        return this.parentDataSet;
};

Spry.Data.NestedXMLDataSet.prototype.getNestedDataSetForParentRow = function(parentRow)
{
        // Return the internal nested data set associated with the parent's
        // specified row object.
        
        var xmlNode = parentRow.ds_XMLNode;
        if (xmlNode && this.nestedDataSets)
        {
                // Before we go through all of the trouble of looking up the data set
                // we want, check to see if it is already our current data set!
                
                if (this.currentDSAncestor && this.currentDSAncestor == xmlNode)
                        return this.currentDS;

                // The caller is asking for a data set that isn't our current one.
                // Manually walk through all of the data sets we have, and return the
                // one that is associated with xmlNode.

                var nDSArr = this.nestedDataSets;
                var nDSArrLen = nDSArr.length;
                for (var i = 0; i < nDSArrLen; i++)
                {
                        var dsObj = nDSArr[i];
                        if (dsObj && xmlNode == dsObj.ancestor)
                                return dsObj.dataSet;
                }
        }
        return null;
};

Spry.Data.NestedXMLDataSet.prototype.getNestedXMLDataSetsArray = function()
{
        // Return an array of all of our internal nested data sets.

        var resultsArray = [];
        if (this.nestedDataSets)
        {
                var arrDS = this.nestedDataSets;
                var numDS = this.nestedDataSets.length;
                for (var i = 0; i < numDS; i++)
                        resultsArray.push(arrDS[i].dataSet);
        }
        return resultsArray;
};

Spry.Data.NestedXMLDataSet.prototype.onDataChanged = function(notifier, data)
{
        // This function gets called any time the *parent* data set gets changed.

        if (!this.ignoreOnDataChanged)
                this.loadData();
};

Spry.Data.NestedXMLDataSet.prototype.onCurrentRowChanged = function(notifier, data)
{
        // The current row for our parent data set changed. We need to sync
        // our internal state so that our current data set is the nested data
        // for the parent's current row.
        //
        // From the outside, this appears as if the *entire* data inside this
        // data set changes. We don't want any of our nested child data sets
        // to recalculate their internal nested data structures, we simply want
        // them to select the correct one from the set they already have. To do
        // this, we dispatch a pre and post context change message that allows
        // them to figure out what is going on, and that they can safely ignore
        // any onDataChanged message they get from their parent.

        this.notifyObservers("onPreParentContextChange");
        this.currentDS = null;
        this.currentDSAncestor = null;
        var pCurRow = this.parentDataSet.getCurrentRow();
        if (pCurRow)
        {
                var nestedDS = this.getNestedDataSetForParentRow(pCurRow);
                if (nestedDS)
                {
                        this.currentDS = nestedDS;
                        this.currentDSAncestor = pCurRow.ds_XMLNode;
                }
        }
        this.notifyObservers("onDataChanged");
        this.notifyObservers("onPostParentContextChange");
        this.ignoreOnDataChanged = false;
};

// If we get an onPostParentContextChange, we want to treat it as if we got an
// onCurrentRowChanged message from our parent, that way, we don't have to recalculate
// any of our internal data, we just have to select the correct data set
// that matches our parent's current row.

Spry.Data.NestedXMLDataSet.prototype.onPostParentContextChange = Spry.Data.NestedXMLDataSet.prototype.onCurrentRowChanged;
Spry.Data.NestedXMLDataSet.prototype.onPreParentContextChange = function(notifier, data)
{
        this.ignoreOnDataChanged = true;
};

Spry.Data.NestedXMLDataSet.prototype.filterAndSortData = function()
{
        // This method is almost identical to the one from the
        // DataSet base class, except that it does not set the
        // current row id.

        // If there is a data filter installed, run it.

        if (this.filterDataFunc)
                this.filterData(this.filterDataFunc, true);

        // If the distinct flag was set, run through all the records in the recordset
        // and toss out any that are duplicates.

        if (this.distinctOnLoad)
                this.distinct(this.distinctFieldsOnLoad);

        // If sortOnLoad was set, sort the data based on the columns
        // specified in sortOnLoad.

        if (this.keepSorted && this.getSortColumn())
                this.sort(this.lastSortColumns, this.lastSortOrder);
        else if (this.sortOnLoad)
                this.sort(this.sortOnLoad, this.sortOrderOnLoad);

        // If there is a view filter installed, run it.

        if (this.filterFunc)
                this.filter(this.filterFunc, true);
};

Spry.Data.NestedXMLDataSet.prototype.loadData = function()
{
        var parentDS = this.parentDataSet;

        if (!parentDS || parentDS.getLoadDataRequestIsPending() || !this.xpath)
                return;

        if (!parentDS.getDataWasLoaded())
        {
                // Someone is asking us to load our data, but our parent
                // hasn't even initiated a load yet. Tell our parent to
                // load its data, so we can get our data!

                parentDS.loadData();
                return;
        }

        this.notifyObservers("onPreLoad");

        this.nestedDataSets = [];
        this.currentDS = null;
        this.currentDSAncestor = null;

        this.data = [];
        this.dataHash = {};

        var self = this;

        var ancestorDS = [ parentDS ];
        if (parentDS.getNestedXMLDataSetsArray)
                ancestorDS = parentDS.getNestedXMLDataSetsArray();

        var currentAncestor = null;
        var currentAncestorRow = parentDS.getCurrentRow();
        if (currentAncestorRow)
                currentAncestor = currentAncestorRow.ds_XMLNode;

        var numAncestors = ancestorDS.length;
        for (var i = 0; i < numAncestors; i++)
        {
                // Run through each row of *every* ancestor data set and create
                // a nested data set.

                var aDS = ancestorDS[i];
                var aData = aDS.getData(true);
                if (aData)
                {
                        var aDataLen = aData.length;
                        for (var j = 0; j < aDataLen; j++)
                        {
                                var row = aData[j];
                                if (row && row.ds_XMLNode)
                                {
                                        // Create an internal nested data set for this row.

                                        var ds = new Spry.Data.DataSet(this.options);

                                        // Make sure the internal nested data set has the same set
                                        // of columnTypes as the nested data set itself.

                                        for (var cname in this.columnTypes)
                                                ds.setColumnType(cname, this.columnTypes[cname]);

                                        // Flatten any data that matches our XPath and stuff it into
                                        // our new nested data set.

                                        var dataArr = Spry.Data.XMLDataSet.getRecordSetFromXMLDoc(row.ds_XMLNode, this.xpath, false, this.entityEncodeStrings);
                                        ds.setDataFromArray(dataArr.data, true);

                                        // Create an object that stores the relationship between our
                                        // internal nested data set, and the ancestor node that was used
                                        // extract the data for the data set.

                                        var dsObj = new Object;
                                        dsObj.ancestor = row.ds_XMLNode;
                                        dsObj.dataSet = ds;

                                        this.nestedDataSets.push(dsObj);

                                        // If this ancestor is the one for our parent's current row,
                                        // make the current data set our current data set.

                                        if (row.ds_XMLNode == currentAncestor)
                                        {
                                                this.currentDS = ds;
                                                this.currentDSAncestor = this.ds_XMLNode;
                                        }
                
                                        // Add an observer on the nested data set so that whenever it dispatches
                                        // a notifications, we forward it on as if we generated the notification.
                
                                        ds.addObserver(function(notificationType, notifier, data){ if (notifier == self.currentDS) setTimeout(function() { self.notifyObservers(notificationType, data); }, 0); });
                                }
                        }
                }
        }

        this.pendingRequest = new Object;
        this.dataWasLoaded = false;

        this.pendingRequest.timer = setTimeout(function() {
                self.pendingRequest = null;
                self.dataWasLoaded = true;

                self.disableNotifications();
                self.filterAndSortData();
                self.enableNotifications();

                self.notifyObservers("onPostLoad");
                self.notifyObservers("onDataChanged");
        }, 0);
};

Spry.Data.NestedXMLDataSet.prototype.getData = function(unfiltered)
{
        if (this.currentDS)
                return this.currentDS.getData(unfiltered);
        return [];
};

Spry.Data.NestedXMLDataSet.prototype.getRowCount = function(unfiltered)
{
        if (this.currentDS)
                return this.currentDS.getRowCount(unfiltered);
        return 0;
};

Spry.Data.NestedXMLDataSet.prototype.getRowByID = function(rowID)
{
        if (this.currentDS)
                return this.currentDS.getRowByID(rowID);
        return undefined;
};

Spry.Data.NestedXMLDataSet.prototype.getRowByRowNumber = function(rowNumber, unfiltered)
{
        if (this.currentDS)
                return this.currentDS.getRowByRowNumber(rowNumber, unfiltered);
        return null;
};

Spry.Data.NestedXMLDataSet.prototype.getCurrentRow = function()
{
        if (this.currentDS)
                return this.currentDS.getCurrentRow();
        return null;
};

Spry.Data.NestedXMLDataSet.prototype.setCurrentRow = function(rowID)
{
        if (this.currentDS)
                return this.currentDS.setCurrentRow(rowID);
};

Spry.Data.NestedXMLDataSet.prototype.getRowNumber = function(row)
{
        if (this.currentDS)
                return this.currentDS.getRowNumber(row);
        return 0;
};

Spry.Data.NestedXMLDataSet.prototype.getCurrentRowNumber = function()
{
        if (this.currentDS)
                return this.currentDS.getCurrentRowNumber();
        return 0;
};

Spry.Data.NestedXMLDataSet.prototype.getCurrentRowID = function()
{
        if (this.currentDS)
                return this.currentDS.getCurrentRowID();
        return 0;
};

Spry.Data.NestedXMLDataSet.prototype.setCurrentRowNumber = function(rowNumber)
{
        if (this.currentDS)
                return this.currentDS.setCurrentRowNumber(rowNumber);
};

Spry.Data.NestedXMLDataSet.prototype.findRowsWithColumnValues = function(valueObj, firstMatchOnly, unfiltered)
{
        if (this.currentDS)
                return this.currentDS.findRowsWithColumnValues(valueObj, firstMatchOnly, unfiltered);
        return firstMatchOnly ? null : [];
};

Spry.Data.NestedXMLDataSet.prototype.setColumnType = function(columnNames, columnType)
{
        if (columnNames)
        {
                // Make sure the nested xml data set tracks the column types
                // that the user sets so that if our data changes, we can re-apply
                // the column types.

                Spry.Data.DataSet.prototype.setColumnType.call(this, columnNames, columnType);

                // Now apply the column types to any internal nested data sets
                // that exist.

                var dsArr = this.nestedDataSets;
                var dsArrLen = dsArr.length;
                for (var i = 0; i < dsArrLen; i++)
                        dsArr[i].dataSet.setColumnType(columnNames, columnType);
        }
};

Spry.Data.NestedXMLDataSet.prototype.getColumnType = function(columnName)
{
        if (this.currentDS)
                return this.currentDS.getColumnType(columnName);
        return "string";
};

Spry.Data.NestedXMLDataSet.prototype.distinct = function(columnNames)
{
        if (columnNames)
        {
                var dsArr = this.nestedDataSets;
                var dsArrLen = dsArr.length;
                for (var i = 0; i < dsArrLen; i++)
                        dsArr[i].dataSet.distinct(columnNames);
        }
};

Spry.Data.NestedXMLDataSet.prototype.sort = function(columnNames, sortOrder)
{
        if (columnNames)
        {
                // Forward the sort request to all internal data sets.

                var dsArr = this.nestedDataSets;
                var dsArrLen = dsArr.length;
                for (var i = 0; i < dsArrLen; i++)
                        dsArr[i].dataSet.sort(columnNames, sortOrder);

                // Make sure we store a local copy of the last sort order
                // column so we can restore it if new data is loaded.

                if (dsArrLen > 0)
                {
                        var ds = dsArr[0].dataSet;
                        this.lastSortColumns = ds.lastSortColumns.slice(0); // Copy the array.
                        this.lastSortOrder = ds.lastSortOrder;
                }
        }
};

Spry.Data.NestedXMLDataSet.prototype.filterData = function(filterFunc, filterOnly)
{
        // Store a copy of the filterFunc so we can apply it
        // if the data set loads new data.

        this.filterDataFunc = filterFunc;

        // Now set the filterFunc on all of the internal
        // data sets.

        var dsArr = this.nestedDataSets;
        var dsArrLen = dsArr.length;
        for (var i = 0; i < dsArrLen; i++)
                dsArr[i].dataSet.filterData(filterFunc, filterOnly);
};

Spry.Data.NestedXMLDataSet.prototype.filter = function(filterFunc, filterOnly)
{
        // Store a copy of the filterFunc so we can apply it
        // if the data set loads new data.

        this.filterFunc = filterFunc;

        // Now set the filterFunc on all of the internal
        // data sets.

        var dsArr = this.nestedDataSets;
        var dsArrLen = dsArr.length;
        for (var i = 0; i < dsArrLen; i++)
                dsArr[i].dataSet.filter(filterFunc, filterOnly);
};

Spry.Data.NestedXMLDataSet.prototype.setXPath = function(path)
{
        if (this.xpath != path)
        {
                this.xpath = path;
                this.loadData();
        }
};