/*
 * 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) 1998, 2012, 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.text.*;
import javax.swing.border.*;
import javax.swing.tree.*;

import java.util.List;
import java.util.*;
import java.io.*;
import java.net.*;

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

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

/**
 * SMC code adapted for Visual Panels
 *
 * Authorization Settings Panel
 */

public class AuthsPanel extends JPanel {

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

    private AuthAttrMgmt authAttrMgmt;
    private AuthAttrModelEntry[] authArr;
    private DblTreeNode root;

    public static SelPanel authPanel;
    private DblTreeNode [] authNode;

    private boolean isNew;
    private boolean viewNames = false;

    /**
     * Constructs a panel to contain authorizations properties for the
     * right object.
     *
     */
    public AuthsPanel(UserMgrPanelDescriptor panelDesc,
		UserManagedObject userObj) {
	super();
	this.panelDesc = panelDesc;
        this.userObj = userObj;
	isNew = userObj.isNewUser();

	createGui();
	loadAuths();

    } // constructor

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

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

	authPanel = new SelPanel("usermgr.advanced.auths.available",
		"usermgr.advanced.auths.granted");

	authPanel.srcTree.setCellRenderer(new AuthRenderer(this));
	authPanel.dstTree.setCellRenderer(new AuthRenderer(this));

	Constraints.constrain(this, authPanel,
	    0, 0, 1, 1, gbc.BOTH, gbc.CENTER, 1.0, 1, 10, 10, 10, 10);
    } // end createGui

    public void loadUserAuths() {
	authPanel.resetAll();

	if (isNew == false) {
	    authAttrMgmt = new AuthAttrMgmt(panelDesc, userObj);
	    authArr = authAttrMgmt.getAuthEntries();
	    setAuthArr(authArr);
        }

	if (authArr == null) {
	    return;
	}


	// At this point, everything is in the left tree, with
	// all of the branches collaped.

	for (int i = 0; i < authArr.length; i++) {
	    if (authArr[i].isHeader()) {

		// Expand all the headers

		TreePath nodepath = new TreePath(authNode[i].getPath());
		authPanel.srcTree.expandPath(nodepath);
	    } else {

		// Move all the granted auths leaves to the right
		if (isNew == false && authArr[i].isGranted()) {
		    authPanel.initLeaf(authPanel.srcTree, authPanel.dstTree,
		    authNode[i]);
		}
	    }
	}

	authPanel.srcTree.setRootVisible(false);
	authPanel.setInitSelection();
    }

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

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

	DefaultTreeModel srcModel =
	    (DefaultTreeModel)authPanel.srcTree.getModel();
	root = (DblTreeNode)srcModel.getRoot();
	int topCount = 0;
	int headerCount = 0;

	// First time through use a dummy profile
	authAttrMgmt = new AuthAttrMgmt(panelDesc, userObj);

	authArr = authAttrMgmt.getAuthEntries();

	int [] headerList = new int[authArr.length];
	authNode = new DblTreeNode[authArr.length];

	for (int i = 0; i < authArr.length; i++) {
	    AuthTreeNode authObject = new AuthTreeNode(authArr[i], i);
	    authNode[i] = new DblTreeNode((Object)authObject);

	    String nodeName = authArr[i].getAuthName();
	    if (authArr[i].isHeader()) {
		// Add subheaders to headers

		boolean foundHeader = false;
		int	headerIndex = 0;

		for (int j = 0; j < headerCount; j++) {
		    int k = headerList[j];
		    AuthTreeNode  headerNode =
			(AuthTreeNode)authNode[k].getUserObject();
		    String headerName = headerNode.toString();
		    if (nodeName.startsWith(headerName)) {
			foundHeader = true;
			headerIndex = k;
			// loop for closest match
		    }
		}

		if (foundHeader) {
		    authNode[headerIndex].add(authNode[i]);
		} else {
		    srcModel.insertNodeInto(authNode[i], root, topCount++);
		    TreePath nodepath = new TreePath(authNode[i].getPath());
		    authPanel.srcTree.scrollPathToVisible(nodepath);
		}
		// add header to header list
		headerList[headerCount++] = i;

	    } else { // Add the leaves to the headers

		// Set auth's treenode disabled to
		// indicate the auth "can not be granted" to another user
		// (No auths leaves could ever have child nodes)

		if (authArr[i].canBeGranted() == false) {
		    authNode[i].setEnabled(false);
		}
		if (headerCount > 0) {
		    for (int j = headerCount - 1; j >= 0; j--) {
			AuthTreeNode  headerNode = (AuthTreeNode)
			    authNode[headerList[j]].getUserObject();
			String headerName = headerNode.toString();
			if (nodeName.startsWith(headerName)) {
			    authNode[headerList[j]].add(authNode[i]);
			    break;
			}
		    }
		} else {
		    srcModel.insertNodeInto(authNode[i], root, topCount++);
		}
	    }
	}

	loadUserAuths();

    } // end loadAuths


    public void setAuthArr(AuthAttrModelEntry[] arr) {
	authArr = arr;
    }

    public AuthAttrModelEntry[] getAuthArr() {
	return authArr;
    }

    public boolean getViewNames() {
	return viewNames;
    }


    public void getChecks() {

	AuthAttrModelEntry[] authEntryArr = getAuthArr();

	if (authNode == null) {
	    return;
        }

	for (int i = 0; i < authNode.length; i++) {
	    if (authEntryArr[i].isHeader()) {
		authEntryArr[i].grant();
		continue;
	    }

	    // root is in the excluded tree.
	    if (authNode[i].getRoot().equals(root))
		authEntryArr[i].revoke();
	    else
		authEntryArr[i].grant();
	}

	DblTreeNode node;
	Enumeration inclAuths = root.depthFirstEnumeration();
	while (inclAuths.hasMoreElements()) {
	    node = (DblTreeNode)inclAuths.nextElement();
	    if (node.isRoot())
		continue;

	    AuthTreeNode authtreenode = (AuthTreeNode)node.getUserObject();
	    int i = authtreenode.getSubscript();
	    if (authEntryArr[i].isHeader())
		authEntryArr[i].revoke();
	}

	setAuthArr(authEntryArr);

    } // end getChecks

    /**
     * Get the authorizations assigned to the selected user/role.
     */
    public Vector<String> getAssignedAuths() {
	getChecks();
        Vector<String> vAuths = authAttrMgmt.setAuthEntries(getAuthArr());

	return vAuths;
    }

    /**
     * Get a list of available authorizations that can be assigned
     * to selected user/role.
     */
    private String[] getAvailableAuths() {
	List<String> auths = panelDesc.getAuths();
        int authsize =  auths.size();
	String[] authList = new String[authsize];

	for (int i = 0; i < authsize; i++) {
	    authList[i] = auths.get(i);
	}
    	return (authList);
    }

    /**
     * Refresh authorizations for the new user.
     */
    public void setUser(UserManagedObject userObj) {
    	this.userObj = userObj;
	loadAuths();
    }

    public UserManagedObject updateUser() {
        Vector<String> vAuths = getAssignedAuths();
	String authStr;

	if (vAuths.size() > 0) {
		authStr = vAuths.elementAt(0);
	} else {
		authStr = "";
	}

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

	userObj.getAuthsProperty().setValue(authStr);

	return (userObj);
    }

} // end AuthsPanel

class AuthTreeNode {

    String name = null;
    AuthAttrModelEntry authModel = null;
    boolean enabled = true;
    int subscript;

    public AuthTreeNode(AuthAttrModelEntry authModel, int subscript) {
	name = authModel.getName();
	enabled = authModel.canBeGranted();
	this.authModel = authModel;
	this.subscript = subscript;
    }

    public String getDesc() {
	return authModel.getDesc();
    }

    public String toString() {
	return name;
    }

    public AuthAttrModelEntry getAuthModel() {
	return authModel;
    }

    public boolean isEnabled() {
	return enabled;
    }

    public int getSubscript() {
	return this.subscript;
    }

}

class AuthRenderer extends DefaultTreeCellRenderer {

    private boolean selected;
    static AuthsPanel authsPanel;

    public AuthRenderer(AuthsPanel authsPanel) {
	this.authsPanel = authsPanel;
	setClosedIcon(null);
	setOpenIcon(null);
    }

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

	AuthTreeNode authdef = null;
	FocusEvent e = null;

	this.selected = selected;

	DefaultTreeCellRenderer cr =
	    (DefaultTreeCellRenderer)tree.getCellRenderer();

	DblTreeNode node = (DblTreeNode)value;
	// authdef = (AuthTreeNode)node.getUserObject();

	if (node.getParent() == null) {
	    setText("All Authorizations");
	} else  if (node.getUserObject() instanceof AuthTreeNode) {
	    authdef = (AuthTreeNode)node.getUserObject();
	    setText(authdef.toString());

	}

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

	return this;

    }
}