/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */

/*
 * Copyright (c) 2004, 2013, Oracle and/or its affiliates. All rights reserved.
 */

package com.oracle.solaris.vp.panels.usermgr.client.swing;

import javax.swing.*;
import javax.swing.event.*;
import javax.swing.tree.*;
import javax.swing.border.*;

import java.awt.*;
import java.awt.event.*;
import java.util.*;

import com.oracle.solaris.vp.util.misc.finder.Finder;

/**
 * SMC code adapted for Visual Panels
 *
 * Rights Profiles Panel for Rights Settings
 */
public class AuthRightsPanel extends JPanel {


    public static Arranger profPanel;
    private static DblTreeNode srcRoot;
    private static DblTreeNode dstRoot;
    private DefaultTreeModel srcModel, dstModel;

    private DblTreeNode [] profNodes;
    private ProfTreeNode [] profTreeNodes;

    private ProfTreeNode currProfTreeNode;
    private DblTreeNode currDblTreeNode;

    private String targetRightName;
    private String targetRight;
    private JPanel securityPanel;

    private UserManagedObject userObj = null;
    private UserMgrPanelDescriptor panelDesc = null;

    private Vector vAllRightObjs = null;

    private boolean isProfListOK = true;

    /**
     * Constructs a panel to contain supplementary rights properties for
     * the right object.
     */
    public AuthRightsPanel(UserMgrPanelDescriptor panelDesc,
        UserManagedObject userObj) {

	super();
	this.panelDesc = panelDesc;
	this.userObj = userObj;

	createGui();
	loadProfiles();
    } // constructor


    /**
     * Method for creating GUI
     */
    private void createGui() {

	// Set the panel layout
	GridBagConstraints gbc = new GridBagConstraints();
	this.setLayout(new GridBagLayout());

	// Excluded and Included rights panel
   	securityPanel = null;

	profPanel = new Arranger("usermgr.advanced.auth_rights.available",
		"usermgr.advanced.auth_rights.granted");

	Dimension dimension = new Dimension(200, 300);
	profPanel.srcTree.setCellRenderer(new ProfileRenderer(this));
	profPanel.srcTree.setVisibleRowCount(10);
	profPanel.srcTree.setSize(dimension);

	profPanel.dstTree.setCellRenderer(new ProfileRenderer(this));
	profPanel.dstTree.setVisibleRowCount(10);
	profPanel.dstTree.setSize(dimension);

	Constraints.constrain(this, profPanel,
		0, 0, 1, 1,
		gbc.BOTH, gbc.CENTER,
		1.0, 1.0, 10, 10, 10, 10);

    } // end createGui


    /**
     * Load the Source and Destination trees for rights excluded and
     * included lists.
     */
    private void loadProfiles() {

	// Reset the data models. So old data is discarded
	profPanel.resetModels();


	// Initialize the excluded rights list with all profiles
	// except for the current one, since a profile can not be
	// assigned to itself. Note that all profiles are created
	// as top-level profiles.

	vAllRightObjs = getAvailableProfs();

	srcModel = (DefaultTreeModel) profPanel.srcTree.getModel();
	srcRoot = (DblTreeNode) srcModel.getRoot();

	dstModel = (DefaultTreeModel) profPanel.dstTree.getModel();
	dstRoot = (DblTreeNode) dstModel.getRoot();

	profNodes = new DblTreeNode[vAllRightObjs.size()];
	profTreeNodes = new ProfTreeNode[vAllRightObjs.size()];

	int n = 0;
	Enumeration e = vAllRightObjs.elements();

	// Build an array of tree nodes that can be used for sorting.

	while (e.hasMoreElements()) {
	    String rightObj = (String)e.nextElement();
	    String rightName = rightObj;

	    profTreeNodes[n] = new ProfTreeNode(rightObj);

	    n++;
	}

	// Sort the list of ProfTreeNode objects.

	if (profTreeNodes.length > 1) {
	    NodeCompare comp = new NodeCompare();
	    Sort.sort(profTreeNodes, comp);
	}

	// With the sorted tree nodes, now we build the src tree.
	for (int i = 0; i < profTreeNodes.length; i++) {
	    profNodes[i] = new DblTreeNode((Object)profTreeNodes[i]);

	    srcModel.insertNodeInto(profNodes[i], srcRoot, i);
	    TreePath nodepath = new TreePath(profNodes[i].getPath());
	    // Make initial display of excluded list
	    profPanel.srcTree.scrollPathToVisible(nodepath);
	}


	// Set TreeModel listeners
	srcModel.addTreeModelListener(new TreeModelListener() {

	    public void treeNodesInserted(TreeModelEvent e) {
		enableProfileChoices(e);
	    }

	    public void treeNodesRemoved(TreeModelEvent e) {
		disableProfileChoices(e);
	    }

	    public void treeNodesChanged(TreeModelEvent e) {}

	    public void treeStructureChanged(TreeModelEvent e) {}

	});

	dstModel.addTreeModelListener(new TreeModelListener() {

	    public void treeNodesInserted(TreeModelEvent e) {
		updateDstTree(e);
	    }

	    public void treeNodesRemoved(TreeModelEvent e) {
		updateDstTree(e);
	    }

	    public void treeNodesChanged(TreeModelEvent e) {}

	    public void treeStructureChanged(TreeModelEvent e) {}

	});

	// Build subprofiles recursively
	for (int i = 0; i < profNodes.length; i++) {
	    rebuildSubProfiles(profNodes[i], profNodes[i]);
	}

	String [] subProfList = null;

	// Get the list of profiles that are assigned to current user/role
	// (in user_attr entry).
	String rights = userObj.getAuthRights();
	if (rights != null) {
	    subProfList = userObj.getAuthRights().split(",");
	}

	profPanel.setInitSelection();
	if (rights == null || subProfList == null) {
	    return;
	}

	// Move subprofiles of current profile from excluded list
	// to included list.
	// Note that a dimmed profile will stay dimmed after the move.
	// Therefore, a user can not "unassign" a dimmed profile on the
	// included list.


	for (int j = 0; j < subProfList.length; j++) {
	    boolean foundSubProf = false;

	    int count = 0;
	    for (int i = 0; i < profNodes.length; i++) {
		String profString = profNodes[i].toString();

		if (profString.equals(subProfList[j])) {
		    foundSubProf = true;
		    count = i;
		    break;
		}

	    }

	    if (foundSubProf) {
		profPanel.initLeaf(profPanel.srcTree,
		    profPanel.dstTree, profNodes[count]);
	    }
	}

	profPanel.setInitSelection();

    } // end loadProfiles


    private void updateDstTree(TreeModelEvent e) {

	Vector<DblTreeNode> inclProfsVec = new Vector<DblTreeNode>();
	Enumeration inclProfsEnum = dstRoot.breadthFirstEnumeration();

	while (inclProfsEnum.hasMoreElements()) {
	    DblTreeNode node = (DblTreeNode)inclProfsEnum.nextElement();
	    inclProfsVec.addElement(node);
	    node.setConflict(false);
	}

	// Maintain included names as array as optimization

	DblTreeNode [] inclProfs = new DblTreeNode[inclProfsVec.size()];
	inclProfsVec.copyInto(inclProfs);

	if (inclProfs.length < 2)
	    return;

	for (int i = 0; i < inclProfs.length; i++) {
	    String testString = inclProfs[i].toString();

	    for (int j = i + 1; j < inclProfs.length; j++) {
		if (testString.equals(inclProfs[j].toString())) {
		    inclProfs[j].setConflict(true);
		    inclProfs[i].setConflict(true);
		    TreeNode [] nodes = inclProfs[j].getPath();
		    DblTreeNode parentProf = (DblTreeNode)nodes[1];
		    parentProf.setConflict(true);
		}
	    }
	}

    } // end updateDstTree


    private void enableProfileChoices(TreeModelEvent e) {

	// Get names of currently included profiles
	if (e.getPath().length > 1)
	    return;

	Vector<String> inclProfsVec = new Vector<String>();
	Enumeration inclProfs = dstRoot.depthFirstEnumeration();

	while (inclProfs.hasMoreElements()) {
	    inclProfsVec.addElement(inclProfs.nextElement().toString());
	}

	// Maintain included names as array as optimization

	String [] inclProfNames = new String[inclProfsVec.size()];
	inclProfsVec.copyInto(inclProfNames);

	// Look for excluded list items needing updating

	Enumeration topProfs = srcRoot.children();
	while (topProfs.hasMoreElements()) {
	    DblTreeNode nextTop = (DblTreeNode)topProfs.nextElement();
	    boolean matchFound = false;
	    Enumeration exclProfs = nextTop.depthFirstEnumeration();

	    while (exclProfs.hasMoreElements()) {
		String testString = exclProfs.nextElement().toString();
		for (int i = 0; i < inclProfNames.length; i++) {
		    if (testString.equals(inclProfNames[i])) {
			matchFound = true;
			break;
		    }
		}
		if (matchFound)
		    break;
	    }

	    // A Profile hierarchy needs to be enabled

	    if (!matchFound) {
		exclProfs = nextTop.depthFirstEnumeration();
		while (exclProfs.hasMoreElements()) {
		    DblTreeNode onNode =
			(DblTreeNode) exclProfs.nextElement();
		    onNode.setConflict(false);
		}
		nextTop.setConflict(false);
	    }
	}

    } // end enableProfileChoices


    private void disableProfileChoices(TreeModelEvent e) {

	if (e.getPath().length > 1)
	    return;

	Object[] children = e.getChildren();
	DblTreeNode node = (DblTreeNode)children[0];
	Enumeration kids = node.breadthFirstEnumeration();
	while (kids.hasMoreElements()) {
	    disableRecursively((DblTreeNode)kids.nextElement());
	}

    } // end disableProfileChoices


    private void disableRecursively(DblTreeNode node) {

	String testString = node.toString();
	Enumeration exclProfs = srcRoot.breadthFirstEnumeration();
	while (exclProfs.hasMoreElements()) {
	    DblTreeNode exclNode = (DblTreeNode)exclProfs.nextElement();
	    if (testString.equals(exclNode.toString())) {
		TreeNode [] nodes = exclNode.getPath();

		DblTreeNode parentProf = (DblTreeNode)nodes[1];
		if (!parentProf.isConflict()) {
		    parentProf.setConflict(true);
		    exclNode.setConflict(true);
    		}
	    }
	}

    } // end disableRecursively


    private void rebuildSubProfiles(DblTreeNode profNode, DblTreeNode topNode) {

	// First unlink the old children
	int childCount = profNode.getChildCount();
	for (int i = 0; i < childCount; i++) {
	    DblTreeNode child = (DblTreeNode) srcModel.getChild(profNode, 0);
	    srcModel.removeNodeFromParent(child);
	}

	// Then recursively construct new nodes for all the children
	DblTreeNode childNode;
	int i = 0;
	Enumeration topList = topNode.breadthFirstEnumeration();

	// Find sub-profile list in RightObj of cached tree node
	ProfTreeNode pTreeNode = (ProfTreeNode)profNode.getUserObject();
	String rObj = pTreeNode.getRightObj();
	// ProfAttrObj targetProfAttr = rObj.getProfAttr();

	String [] profList = null; // targetProfAttr.getProfNames();

	if (profList == null)
	    return;

	for (int k = 0; k < profList.length; k++) {
	    String name = profList[k];

	    // Prevent infinite recursive loops
	    boolean cyclic = false;
	    while (topList.hasMoreElements()) {
		if (name.equals(topList.nextElement().toString())) {
		    cyclic = true;
		    // Mark the parent as cyclic
		    topNode.setCyclic(true);
		    Enumeration dupNodes = topNode.breadthFirstEnumeration();
		    while (dupNodes.hasMoreElements()) {
			childNode = (DblTreeNode)dupNodes.nextElement();
			if (name.equals(childNode.toString())) {
			    childNode.setCyclic(true);
			}
		    }
		    break;
		}
	    }

	    for (int j = 0; j < profTreeNodes.length; j++) {
		if (name.equals(profTreeNodes[j].toString())) {
		    childNode = new DblTreeNode((Object)profTreeNodes[j]);

		    srcModel.insertNodeInto(childNode, profNode, i++);
		    childNode.setEnabled(false);
		    if (cyclic)
			childNode.setCyclic(true);
		    else
			rebuildSubProfiles(childNode, topNode);
		}
	    }
	}

    } // end rebuildSubProfiles


    public String updateRightSubProps(String rightObj) {

	if (isProfListOK) {
	    Vector<String> vAssignedProfs = new Vector<String>();

	    // Get the first generation children that are assigned to
	    // current profile.
	    DblTreeNode root = (DblTreeNode)dstModel.getRoot();
	    Enumeration kids;
	    kids = root.children();

	    while (kids.hasMoreElements()) {
		DblTreeNode childNode;
		childNode = (DblTreeNode)kids.nextElement();
		vAssignedProfs.addElement(childNode.toString());
	    }

	    // ProfAttrObj profAttr = rightObj.getProfAttr();
	    // profAttr.setProfNamesVector(vAssignedProfs);
	}
	return (rightObj);

    } // end updateRightSubProps

    public Vector<String> getAssignedProfs() {
	Vector<String> vAssignedProfs = new Vector<String>();

	if (!isProfListOK) {
	    return vAssignedProfs;
	}

	// Get the first generation children that are assigned to
	// current profile.
	DblTreeNode root = (DblTreeNode)dstModel.getRoot();
	Enumeration kids;
	kids = root.children();
	while (kids.hasMoreElements()) {
	    DblTreeNode childNode;
	    childNode = (DblTreeNode)kids.nextElement();
	    vAssignedProfs.addElement(childNode.toString());
	}

	return vAssignedProfs;
    }

    private Vector<String> getAvailableProfs() {
        Vector<String> rights = new Vector<String>();
	for (String s : panelDesc.getProfiles()) {
	    rights.add(s);

	}
    	return (rights);
    }

    public void setUser(UserManagedObject userObj) {
    	this.userObj = userObj;
	loadProfiles();
    }

    public UserManagedObject updateUser() {
        Vector<String> vProfs = getAssignedProfs();
	String profStr;

	if (vProfs.size() > 0) {
		profStr = vProfs.elementAt(0);
	} else {
		profStr = "";
	}

	for (int i = 1; i < vProfs.size(); i++) {
	    profStr = profStr.concat(",");
	    profStr = profStr.concat(vProfs.elementAt(i));
        }

	userObj.getAuthRightsProperty().setValue(profStr);

	return (userObj);
    }



class ProfileRenderer extends DefaultTreeCellRenderer {

    private boolean selected;
    Icon warningIcon;
    AuthRightsPanel rightsPanel;

    public ProfileRenderer(AuthRightsPanel rightsPanel) {

	this.rightsPanel = rightsPanel;
	setClosedIcon(null);
	setOpenIcon(null);
	setLeafIcon(null);
    	warningIcon = Finder.getIcon("images/warning.gif");

    }


    public Component getTreeCellRendererComponent(
	JTree tree,
	Object value,
	boolean selected,
	boolean expanded,
	boolean leaf,
	int row,
	boolean hasFocus) {

	FocusEvent e = null;

	this.selected = selected;

	DefaultTreeCellRenderer cr =
	    (DefaultTreeCellRenderer)tree.getCellRenderer();
	cr.setLeafIcon(null);
	DblTreeNode node = (DblTreeNode)value;

	if (node.getParent() == null) {
	    // maybe the same as row == 0
	    setText(node.toString());

	} else if (node.getUserObject() instanceof ProfTreeNode) {
	    ProfTreeNode profsdef = (ProfTreeNode)node.getUserObject();
	    setText(profsdef.toString());
	    // setIcon(actionIcon);

	    if (node.isConflict())
		if (tree == rightsPanel.profPanel.dstTree)
		    cr.setLeafIcon(warningIcon);
	}

	super.getTreeCellRendererComponent(tree, value, selected, expanded,
	    leaf, row, hasFocus);

	return this;

    } // end getTreeCellRendererComponent

}

class ProfTreeNode {

    String name;
    String rightObj = null;

    public ProfTreeNode(String rightObj) {
	this.rightObj = rightObj;
	this.name = rightObj;
    }

    public String getRightObj() {
	return rightObj;
    }

    public String toString() {
	return name;
    }

}

class NodeCompare implements Compare {

    /**
     * The compare method compares two ProfTreeNode objects by comparing
     * their profile names.  The parameters are specified as Object class
     * objects for QuickSort.
     *
     * @param   a	The first Node.
     * @param   b	The second Node.
     *
     */
    public final int doCompare(Object a, Object b) {

	ProfTreeNode e1, e2;
	String e1Name, e2Name;

	e1 = (ProfTreeNode)a;
	e2 = (ProfTreeNode)b;
	e1Name = e1.toString();
	e2Name = e2.toString();
	return (e1Name.compareTo(e2Name));

    }

}
}