/*

 * 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) 2009, 2010, Oracle and/or its affiliates. All rights reserved.

 */

package org.opensolaris.os.vp.client.swing;

import java.io.*;

import java.net.*;

import java.util.*;

import java.util.logging.*;

import org.opensolaris.os.uds.*;

import org.opensolaris.os.vp.client.common.*;

import org.opensolaris.os.vp.panel.common.*;

import org.opensolaris.os.vp.panel.common.action.*;

import org.opensolaris.os.vp.panel.common.control.*;

import org.opensolaris.os.vp.util.cli.*;

import org.opensolaris.os.vp.util.misc.*;

import org.opensolaris.os.vp.util.misc.finder.Finder;

/**

 * The {@code App} class is a thread that listens for UDS connections from other

 * processes.  Multiple addresses of panels to display, one per

 * newline-terminated lines, may be sent through these connections.

 */

public class App extends Thread implements AppConstants {

    //

    // Inner classes

    //

    public static class CommandLineOptionsBean {

	//

	// Instance data

	//

	private String host = RadLoginManager.LOCAL_HOST;

	private String user = RadLoginManager.LOCAL_USER;

	private String role;

	private String address = null;

	private boolean newJVM;

	private HelpFormatter help;

	private Properties properties = new Properties();

	private boolean inParam = false;

	//

	// Constructors

	//

	public CommandLineOptionsBean(HelpFormatter help) {

	    this.help = help;

	}

	//

	// CommandLineOptionsBean methods

	//

	public String getAddress() {

	    return address;

	}

	public String getHost() {

	    return host;

	}

	public boolean getNewjvm() {

	    return newJVM;

	}

	public Properties getProperties() {

	    return properties;

	}

	public String getRole() {

	    return role;

	}

	public String getUser() {

	    return user;

	}

	public void setAddress(String address) {

	    boolean absolute = address.startsWith("/");

	    if (this.address == null) {

		if (!absolute) {

		    // Assume non-relative path is a standalone shortcut

		    address = String.format("/%s/%s",

			Control.encode(AppRootControl.ID, null), address);

		}

		this.address = address;

	    } else {

		/*

		 * If the address has already been set, we accumulate

		 * additional operands as query parameters or subsequent

		 * path elements.

		 */

		if (absolute) {

		    this.address = this.address + address;

		    inParam = false;

		} else {

		    try {

			/*

			 * Ideally we'd use Control.encode, but mapping

			 * from our input to what it requires would be

			 * much less straightforward than what follows.

			 */

			String[] parts = address.split("=", 2);

			StringBuffer b = new StringBuffer(this.address);

			b.append(inParam ? "&" : "?");

			b.append(URLEncoder.encode(parts[0], Control.ENCODING));

			b.append('=');

			if (parts.length > 1)

			    b.append(URLEncoder.encode(parts[1],

				Control.ENCODING));

			this.address = b.toString();

			inParam = true;

		    } catch (UnsupportedEncodingException ex) {

		    }

		}

	    }

	}

	public void setHelp() {

	    System.out.println(help.getHelp());

	    System.exit(0);

	}

	public void setHost(String host) {

	    this.host = host;

	}

	public void setNewjvm() {

	    newJVM = true;

	}

	public void setProperty(String property) {

	    String value;

	    int index = property.indexOf("=");

	    if (index == -1) {

		value = "";

	    } else {

		value = property.substring(index + 1);

		property = property.substring(0, index - 1);

	    }

	    properties.setProperty(property, value);

	}

	public void setRole(String role) {

	    this.role = role;

	}

	public void setUser(String user) {

	    this.user = user;

	}

	public void setVersion() {

	    showVersion();

	    System.exit(0);

	}

    }

    //

    // Static data

    //

    private static final String ARG_NONOPT_ADDRESS = "address";

    private static final String ARG_SHORT_HOST = "h";

    private static final String ARG_LONG_HOST = "host";

    private static final String ARG_SHORT_NEWJVM = "j";

    private static final String ARG_LONG_NEWJVM = "newjvm";

    private static final String ARG_SHORT_USER = "u";

    private static final String ARG_LONG_USER = "user";

    private static final String ARG_SHORT_ROLE = "r";

    private static final String ARG_LONG_ROLE = "role";

    private static final String ARG_SHORT_VERSION = "v";

    private static final String ARG_LONG_VERSION = "version";

    private static final String ARG_SHORT_HELP = "?";

    private static final String ARG_LONG_HELP = "help";

    private static final String ARG_SHORT_PROPERTY = "D";

    private static final String ARG_LONG_PROPERTY = "property";

    private static final String COMMAND_NAME = "vp";

    private static final String COMMAND_DESC =

	Finder.getString("cli.description");

    private static OptionChoiceGroup options;

    static {

	OptionElement addressOption = new NoOptOptionElement(

	    true, ARG_NONOPT_ADDRESS, Finder.getString("cli.arg.address"), -1);

	OptionElement propOption = new OptionElement(ARG_SHORT_PROPERTY,

	    ARG_LONG_PROPERTY, false, "property", "");

	propOption.setDocumented(false);

	propOption.setUseLimit(-1);

	OptionElement hostOption = new OptionElement(ARG_SHORT_HOST,

	    ARG_LONG_HOST, false, "host", Finder.getString("cli.arg.host"));

	OptionElement newJVMOption = new OptionElement(ARG_SHORT_NEWJVM,

	    ARG_LONG_NEWJVM, false, Finder.getString("cli.arg.newjvm"));

	OptionElement userOption = new OptionElement(ARG_SHORT_USER,

	    ARG_LONG_USER, false, "user", Finder.getString("cli.arg.user"));

	OptionElement roleOption = new OptionElement(ARG_SHORT_ROLE,

	    ARG_LONG_ROLE, false, "role", Finder.getString("cli.arg.role"));

	OptionElement versionOption = new OptionElement(ARG_SHORT_VERSION,

	    ARG_LONG_VERSION, false, Finder.getString("cli.arg.version"));

	OptionElement helpOption = new OptionElement(ARG_SHORT_HELP,

	    ARG_LONG_HELP, false, Finder.getString("cli.arg.help"));

	OptionListGroup mainGroup = new OptionListGroup(false,

	    propOption, hostOption, userOption, roleOption, newJVMOption,

	    addressOption);

	options = new OptionChoiceGroup(true, mainGroup, versionOption,

	    helpOption);

    }

    public static final String URI_SCHEME = "vp";

    public static final String URI_USER_ROLE_SEPARATOR = ":";

    public static final String VP_USER_DIR =

	System.getProperty("user.home") + File.separator + ".vp";

    static {

	// Set up client logging

	String fileName = VP_USER_DIR + File.separator + "log";

	// Root Logger

	Logger log = Logger.getLogger("");

	try {

	    File parent = new File(fileName).getParentFile();

	    if (!parent.exists()) {

		if (!parent.mkdirs()) {

		    throw new IOException(

			"could not create directory: " +

			parent.getAbsolutePath());

		}

	    }

	    Handler fHandler = new FileHandler(fileName);

	    fHandler.setFormatter(new SimpleFormatter());

	    log.addHandler(fHandler);

	    // Don't output to the console by default

	    for (Handler cHandler : log.getHandlers()) {

		if (cHandler instanceof ConsoleHandler) {

		    log.removeHandler(cHandler);

		}

	    }

	} catch (IOException e) {

	    Logger.getLogger(App.class.getName()).log(Level.WARNING,

		"unable to create log file: " + fileName);

	}

    }

    public static final File TRUSTSTORE_FILE =

	new File(VP_USER_DIR, "truststore");

    public static final File VP_UDS;

    static {

	String hostName = NetUtil.getHostName();

	if (hostName == null) {

	    hostName = "localhost";

	}

	// May be null or malformed if not an X client

	String display = System.getenv("DISPLAY");

	if (display != null && !display.matches(".*:\\d+(\\.\\d)?$")) {

	    String error = "invalid DISPLAY environment variable: " + display;

	    Logger.getLogger(App.class.getName()).log(Level.WARNING, error);

	    display = null;

	}

	if (display == null) {

	    display = ":0.0";

	} else {

	    if (display.matches(".*:\\d+$")) {

		display += ".0";

	    }

	    if (display.startsWith(hostName)) {

		display = display.substring(hostName.length());

	    }

	}

	String name = String.format(".uds-%s-%s", hostName, display);

	VP_UDS = new File(VP_USER_DIR, name);

    }

    public static final String VP_USER_PREFS =

	VP_USER_DIR + File.separator + "vp.init";

    private static final Preferences prefs = new Preferences(VP_USER_PREFS);

    //

    // Instance data

    //

    private UDSocketServer server;

    private final List<AppInstance> instances = new ArrayList<AppInstance>();

    private ConnectionManager connManager = new ConnectionManager();

    private LoginHistoryManager loginHistoryManager =

	new LoginHistoryManager(connManager, new File(VP_USER_DIR, "history"));

    //

    // Constructors

    //

    public App() {

	addVersionToThreadName(this);

    }

    //

    // Runnable methods

    //

    @Override

    public void run() {

        Logger log = Logger.getLogger(getClass().getName());

	// Start singleton application instance...

	try {

	    server = UnixDomainSocket.bind(VP_UDS, 0600);

	    while (true) {

		final UDSocket socket = server.accept();

		String peerUser = socket.getPeerUser();

		if (!RadLoginManager.LOCAL_USER.equals(peerUser)) {

		    String error = String.format(

			"user %s attempted to connect as %s", peerUser,

			RadLoginManager.LOCAL_USER);

		    log.log(Level.WARNING, error);

		} else {

		    // Spawn on a separate thread so as not to block other

		    // incoming to conections -- not so much because we

		    // anticipate a lot of traffic, but because we can't

		    // guarantee that some poorly-behaved client won't keep its

		    // connection open indefinitely.

		    new Thread() {

			@Override

			public void run() {

			    readFully(socket);

			}

		    }.start();

		}

	    }

	} catch (UDSNotSupportedException e) {

	    // Bummer

	    return;

	} catch (IOException e) {

	    // Major bummer

	    log.log(Level.SEVERE, "error creating daemon", e);

	    return;

	}

    }

    //

    // App methods

    //

    public void abortableExit() throws ActionAbortedException {

	synchronized (instances) {

	    for (int i = instances.size() - 1; i >= 0; i--) {

		// Throws ActionAbortedException

		instances.get(i).closeInstance(false);

	    }

	}

	exit();

    }

    public void exit(int exitCode) {

	try {

	    if (server != null) {

		server.close();

	    }

	} catch (IOException ignore) {

	}

	try {

	    prefs.store();

	} catch (IOException e) {

	    Logger.getLogger(getClass().getName()).log(Level.WARNING,

		"could not write preferences", e);

	}

	System.exit(exitCode);

    }

    public void exit() {

	exit(0);

    }

    private void exitIfNoIntances(int exitCode) {

	if (instances.isEmpty()) {

	    exit(exitCode);

	}

    }

    public ConnectionManager getConnectionManager() {

	return connManager;

    }

    public LoginHistoryManager getLoginHistoryManager() {

	return loginHistoryManager;

    }

    protected Preferences getPreferences() {

	return prefs;

    }

    protected void instanceClosed(AppInstance instance) {

	synchronized (instances) {

	    if (instances.remove(instance)) {

		exitIfNoIntances(0);

	    }

	}

    }

    protected void instanceCreated(AppInstance instance) {

	synchronized (instances) {

	    instances.add(instance);

	}

    }

    public void newInstance(Properties properties, URI uri) {

	String hostVal = uri.getHost();

	String roleVal = null;

	String userVal = uri.getUserInfo();

	int i = userVal.indexOf(URI_USER_ROLE_SEPARATOR);

	if (i != -1) {

	    roleVal = userVal.substring(i + 1);

	    userVal = userVal.substring(0, i);

	}

	AppInstance instance = null;

	boolean success = false;

	try {

	    StringLoginProperty host = new StringLoginProperty(hostVal, false);

	    StringLoginProperty user = new StringLoginProperty(userVal, false);

	    StringLoginProperty role = new StringLoginProperty(roleVal, false);

	    LoginRequest request = new LoginRequest(host, user, role);

	    instance = new AppInstance(this, properties, request);

	    SimpleNavigable[] path = Navigator.toArray(uri.getPath());

	    instance.getNavigator().goToAsyncAndWait(true, null, path);

	    success = true;

	// User is aware of this because he explicitly caused it

	} catch (ActionAbortedException e) {

	// User has been advised of this by RadLoginManager

	} catch (ActionFailedException e) {

	// User has been advised of this by SwingNavigator

	} catch (NavigationException e) {

	// Unexpected error - write to log

	} catch (RuntimeException e) {

	    Logger log = Logger.getLogger(getClass().getName());

	    log.log(Level.SEVERE, "could not launch: " + uri, e);

	// Unexpected error - write to log

	} catch (Error e) {

	    Logger log = Logger.getLogger(getClass().getName());

	    log.log(Level.SEVERE, "could not launch: " + uri, e);