/**
 * MyMultiDimColHeaderModel.java
 *
 * Copyright 2000 Eliad Technologies, Inc. All Rights Reserved.
 *
 * This software is the proprietary information of Eliad Technologies, Inc.
 */
package MultiDimTable;

import java.awt.*;
import java.util.*;
import java.beans.*;

import javax.swing.*;
import javax.swing.tree.DefaultMutableTreeNode;

import com.eliad.model.*;
import com.eliad.model.defaults.*;


public class MyMultiDimColHeaderModel extends AbstractGridModel
				      implements RulerModelListener
{
  private MatrixCellModel[][]    headerCacheMatrix_     = null;
  private MyGridHeaderDirectSpan headerDirectSpanModel_ = new MyGridHeaderDirectSpan();
  private DirectColDragController dragController_;

  // little cache for getValue() method - to remove in final version
  private Object     cacheCellValue_  = null;
  private int        lastRow_         = -1;
  private int        lastColumn_      = -1;

  public MyMultiDimColHeaderModel(DefaultMutableTreeNode root)
  {
    headerCacheMatrix_ = parseHeaderCellTree(root);
  }

  // returns the height of the column header tree
  public int getRowCount()
  {
    return headerCacheMatrix_.length;
  }

  // returns the width of the column header tree
  public int getColumnCount()
  {
    return headerCacheMatrix_[0].length;
  }

  public Object getValueAt(int row, int column)
  {
      if (row != lastRow_ || column != lastColumn_)
      {
        cacheCellValue_ = headerCacheMatrix_[row][column].getValue();
        lastRow_        = row;
        lastColumn_     = column;
      }
      else
      {
        ;//MultiDimTable.traceln("Cache for GetValueAt(" + row + ", " + column + ") = " + cacheCellValue_);
      }

    return cacheCellValue_;
  }

  public void directColumnDragController(DirectColDragController dcdc) {
    dragController_ = dcdc;
  }


  // inner class for ColumnHeaderDirectSpan
  public class MyGridHeaderDirectSpan extends AbstractDirectSpanModel
  {
    // little cache for ExtentCell - to remove in final version
    private ExtentCell cacheExtentCell_ = null;
    private int        lastRow_         = -1;
    private int        lastColumn_      = -1;

    public ExtentCell getSpanOver(final int row, final int column)
    {
      if (row != lastRow_ || column != lastColumn_)
      {
        cacheExtentCell_ = headerCacheMatrix_[row][column].getExtentCell();
        lastRow_         = row;
        lastColumn_      = column;
      }
      else
      {
        ;//MultiDimTable.traceln("Cache for Extent Cells(" + row + ", " + column + ")");
      }

      return cacheExtentCell_;
    }

    public boolean isEmpty()
    {
      return false;
    }
  }


  public GridModel getColumnHeaderModel()
  {
    return this;
  }

  public DirectSpanModel getColumnHeaderSpanModel()
  {
    return this.headerDirectSpanModel_;
  }

  // TreeNodes parsing function
  public MatrixCellModel[][] parseHeaderCellTree(DefaultMutableTreeNode root)
  {
    MatrixCellModel[][] cacheMatrix;
    int treeHeight, treeWidth;
    int row, column, spanRowCount, spanColumnCount, firstLeafColumn;

    DefaultMutableTreeNode node           = null;
    Enumeration            allNodes       = null;
    Hashtable              leafNodesIndex = new Hashtable(20);


    treeWidth  = 0;
    treeHeight = root.getDepth() + 1;    // treeHeight of the tree
    node       = root.getFirstLeaf();    // Buttom left child of the entre tree

    /**
     * we parse each leaf child from left to right of the tree,
     * then we have the treeWidth of the tree and we can find the column index of parent nodes
     */
    while (node != null)
    {
      leafNodesIndex.put(node, new Integer(treeWidth));
      treeWidth++;
      node = node.getNextLeaf();
    }

    /**
     * cache matrix for quick acces to Cell Data and Spanned Area
     * [treeHeight][treeWidth] means => [maxRows][maxColumns]
     */
    cacheMatrix = new MatrixCell[treeHeight][treeWidth];


    allNodes = root.postorderEnumeration();  // this enumeration crosses the tree nodes in postorder

    /**
     * now we put usefull informations into our cache matrix by parsing the tree nodes
     */
    while (allNodes.hasMoreElements())
    {
      node = (DefaultMutableTreeNode) allNodes.nextElement();
      row  = node.getLevel();

      if (node.isLeaf())
      {
        column          = ((Integer)leafNodesIndex.get(node)).intValue();
        spanRowCount    = treeHeight - row;
        spanColumnCount = 1;

        for (int j=row+1; j<treeHeight; j++)
          cacheMatrix[j][column] = new MatrixCell("", row, column, spanRowCount, spanColumnCount);
      }
      else
      {
        column          = ((Integer)leafNodesIndex.get(node.getFirstLeaf())).intValue();
        spanRowCount    = 1;
        spanColumnCount = ((Integer)leafNodesIndex.get(node.getLastLeaf())).intValue()
                          - column
                          + 1;

        for (int i=column+1; i<treeWidth; i++)
          cacheMatrix[row][i] =  new MatrixCell("", row, column, spanRowCount, spanColumnCount);
      }

      cacheMatrix[row][column] = new MatrixCell(node.getUserObject(), row, column, spanRowCount, spanColumnCount);
    }

    return cacheMatrix;
  } // parseHeaderCellTree(...)


  /**
   * Called whenever the ruler model changes.
   * @param e the event that characterizes the change.
   */
  public void rulerModelChanged(RulerModelEvent e)
  {
    MultiDimTable.traceln("MMCHM.rulerModelChanged : " + e.getType());
  }

  /**
   * Called whenever the ruler model structure undergoes a local change.
   * Implemented here to catch column or row moves, and implements them
   * as data swapping.
   * @param e the event that characterizes the change.
   */
  public void rulerStructureChanged(RulerModelEvent e)
  {
MultiDimTable.traceln("MMCHM.rulerStructureChanged : " + e.getType());

    if (e.getType() == RulerModelEvent.RULER_ITEMS_MOVED)
    {
      final int c = e.getCount(),
      		fi = e.getFromIndex(),
		ti = e.getToIndex();
MultiDimTable.traceln("  count = " + c + ", from = " + fi + ", to = " + ti);

      final int fc, fn,
		tc, tn;
      if (dragController_.fromExtentCell_ != null) {
	fc = dragController_.fromExtentCell_.getColumn();
	fn = dragController_.fromExtentCell_.getColumnCount();
      } else {
	fc = fi;
	fn = c;		// c should be equal to 1
      }
      if (dragController_.toExtentCell_ != null) {
	tc = dragController_.toExtentCell_.getColumn();
	tn = dragController_.toExtentCell_.getColumnCount();
      } else {
	tc = ti;
	tn = 1;
      }

    // JHA 25/07/00, Moves nodes in root_
      DefaultMutableTreeNode fno = dragController_.fromNode_,
                             tno = dragController_.toNode_,
                             pno = (DefaultMutableTreeNode)fno.getParent();

MultiDimTable.traceln("  pno.getIndex(fno) = " + pno.getIndex(fno)
		  + ", pno.getIndex(tno) = " + pno.getIndex(tno));
      if (pno.getIndex(fno) > pno.getIndex(tno)) {
	fno.removeFromParent();
MultiDimTable.traceln("  pno.insert(fno," + pno.getIndex(tno) + ")");
	pno.insert(fno,pno.getIndex(tno));
      } else {
	fno.removeFromParent();
MultiDimTable.traceln("  pno.getIndex(tno)+1 = " + (pno.getIndex(tno)+1)
		  + ", pno.getChildCount() = " + pno.getChildCount());
	if (pno.getIndex(tno) + 1 < pno.getChildCount()) {
MultiDimTable.traceln("  pno.insert(fno," + (pno.getIndex(tno)+1) + ")");
	  pno.insert(fno,pno.getIndex(tno)+1);
	} else {
MultiDimTable.traceln("  pno.add(fno)");
	  pno.add(fno);
	}
      }
    // Rebuild the header's data matrix
      headerCacheMatrix_ = parseHeaderCellTree((DefaultMutableTreeNode)pno.getRoot());

      if (fc < tc) {
MultiDimTable.traceln("  fireGCC(" + fc + "," + (tc-fc+fn) + ")");
	fireGridColumnsChanged(fc,tc-fc+tn);
      } else {
MultiDimTable.traceln("  fireGCC(" + tc + "," + (fc-tc+fn) + ")");
	fireGridColumnsChanged(tc,fc-tc+fn);
      }
    }
  }

  /**
   * Called whenever some data in the ruler model changes.
   * @param e the event that characterizes the change.
   */
  public void rulerDataChanged(RulerModelEvent e)
  {
//MultiDimTable.traceln("MMCHM.rulerDataChanged : " + e.getType());
  }

  /**
   * Calls to send a prenotification that ruler items are to be moved. No action has yet been taken.
   */
  public void beforeItemsMoved(RulerModelEvent e)
    throws PropertyVetoException
  {
//MultiDimTable.traceln("MMCHM.beforeItemsMoved : " + e.getType());
  }
}