/*

 * 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 {