package org.argeo.cms.ui.fs;
   
   import java.io.IOException;
   import java.net.URI;
   import java.net.URISyntaxException;
   import java.nio.file.DirectoryStream;
   import java.nio.file.FileSystem;
   import java.nio.file.Files;
   import java.nio.file.Path;
  import java.nio.file.Paths;
  import java.nio.file.spi.FileSystemProvider;
  import java.security.PrivilegedActionException;
  import java.security.PrivilegedExceptionAction;
  import java.util.ArrayList;
  import java.util.List;
  
  import javax.jcr.Node;
  import javax.jcr.Repository;
  import javax.jcr.Session;
  
  import org.argeo.api.NodeUtils;
  import org.argeo.cms.CmsException;
  import org.argeo.cms.auth.CurrentUser;
  import org.argeo.cms.ui.util.CmsUiUtils;
  import org.argeo.eclipse.ui.ColumnDefinition;
  import org.argeo.eclipse.ui.EclipseUiUtils;
  import org.argeo.eclipse.ui.fs.FileIconNameLabelProvider;
  import org.argeo.eclipse.ui.fs.FsTableViewer;
  import org.argeo.eclipse.ui.fs.FsUiConstants;
  import org.argeo.eclipse.ui.fs.FsUiUtils;
  import org.argeo.eclipse.ui.fs.NioFileLabelProvider;
  import org.argeo.jcr.JcrUtils;
  import org.eclipse.jface.viewers.DoubleClickEvent;
  import org.eclipse.jface.viewers.IDoubleClickListener;
  import org.eclipse.jface.viewers.ISelectionChangedListener;
  import org.eclipse.jface.viewers.IStructuredSelection;
  import org.eclipse.jface.viewers.SelectionChangedEvent;
  import org.eclipse.jface.viewers.Viewer;
  import org.eclipse.swt.SWT;
  import org.eclipse.swt.custom.SashForm;
  import org.eclipse.swt.events.KeyEvent;
  import org.eclipse.swt.events.KeyListener;
  import org.eclipse.swt.events.ModifyEvent;
  import org.eclipse.swt.events.ModifyListener;
  import org.eclipse.swt.events.MouseAdapter;
  import org.eclipse.swt.events.MouseEvent;
  import org.eclipse.swt.events.SelectionAdapter;
  import org.eclipse.swt.events.SelectionEvent;
  import org.eclipse.swt.graphics.Point;
  import org.eclipse.swt.layout.GridData;
  import org.eclipse.swt.layout.GridLayout;
  import org.eclipse.swt.layout.RowData;
  import org.eclipse.swt.layout.RowLayout;
  import org.eclipse.swt.widgets.Button;
  import org.eclipse.swt.widgets.Composite;
  import org.eclipse.swt.widgets.Control;
  import org.eclipse.swt.widgets.Label;
  import org.eclipse.swt.widgets.Table;
  import org.eclipse.swt.widgets.Text;
  
  /**
   * Default CMS browser composite: a sashForm layout with bookmarks at the left
   * hand side, a simple table in the middle and an overview at right hand side.
   */
  public class CmsFsBrowser extends Composite {
  	// private final static Log log = LogFactory.getLog(CmsFsBrowser.class);
  	private static final long serialVersionUID = -40347919096946585L;
  
  	private final FileSystemProvider nodeFileSystemProvider;
  	private final Node currentBaseContext;
  
  	// UI Parts for the browser
  	private Composite leftPannelCmp;
  	private Composite filterCmp;
  	private Text filterTxt;
  	private FsTableViewer directoryDisplayViewer;
  	private Composite rightPannelCmp;
  
  	private FsContextMenu contextMenu;
  
  	// Local context (this composite is state full)
  	private Path initialPath;
  	private Path currDisplayedFolder;
  	private Path currSelected;
  
  	// local variables (to be cleaned)
  	private int bookmarkColWith = 500;
  
  	/*
  	 * WARNING: unfinalised implementation of the mechanism to retrieve base
  	 * paths
  	 */
  
  	private final static String NODE_PREFIX = "node://";
  
  	private String getCurrentHomePath() {
  		Session session = null;
  		try {
  			Repository repo = currentBaseContext.getSession().getRepository();
 			session = CurrentUser.tryAs(() -> repo.login());
 			String homepath = NodeUtils.getUserHome(session).getPath();
 			return homepath;
 		} catch (Exception e) {
 			throw new CmsException("Cannot retrieve Current User Home Path", e);
 		} finally {
 			JcrUtils.logoutQuietly(session);
 		}
 	}
 
 	protected Path[] getMyFilesPath() {
 		// return Paths.get(System.getProperty("user.dir"));
 		String currHomeUriStr = NODE_PREFIX + getCurrentHomePath();
 		try {
 			URI uri = new URI(currHomeUriStr);
 			FileSystem fileSystem = nodeFileSystemProvider.getFileSystem(uri);
 			if (fileSystem == null) {
 				PrivilegedExceptionAction<FileSystem> pea = new PrivilegedExceptionAction<FileSystem>() {
 					@Override
 					public FileSystem run() throws Exception {
 						return nodeFileSystemProvider.newFileSystem(uri, null);
 					}
 
 				};
 				fileSystem = CurrentUser.tryAs(pea);
 			}
 			Path[] paths = { fileSystem.getPath(getCurrentHomePath()), fileSystem.getPath("/") };
 			return paths;
 		} catch (URISyntaxException | PrivilegedActionException e) {
 			throw new RuntimeException("unable to initialise home file system for " + currHomeUriStr, e);
 		}
 	}
 
 	private Path[] getMyGroupsFilesPath() {
 		// TODO
 		Path[] paths = { Paths.get(System.getProperty("user.dir")), Paths.get("/tmp") };
 		return paths;
 	}
 
 	private Path[] getMyBookmarks() {
 		// TODO
 		Path[] paths = { Paths.get(System.getProperty("user.dir")), Paths.get("/tmp"), Paths.get("/opt") };
 		return paths;
 	}
 
 	/* End of warning */
 
 	public CmsFsBrowser(Composite parent, int style, Node context, FileSystemProvider fileSystemProvider) {
 		super(parent, style);
 		this.nodeFileSystemProvider = fileSystemProvider;
 		this.currentBaseContext = context;
 
 		this.setLayout(EclipseUiUtils.noSpaceGridLayout());
 
 		SashForm form = new SashForm(this, SWT.HORIZONTAL);
 
 		leftPannelCmp = new Composite(form, SWT.NO_FOCUS);
 		// Bookmarks are still static
 		populateBookmarks(leftPannelCmp);
 
 		Composite centerCmp = new Composite(form, SWT.BORDER | SWT.NO_FOCUS);
 		createDisplay(centerCmp);
 
 		rightPannelCmp = new Composite(form, SWT.NO_FOCUS);
 
 		form.setLayoutData(new GridData(SWT.FILL, SWT.FILL, true, true));
 		form.setWeights(new int[] { 15, 40, 20 });
 	}
 
 	void refresh() {
 		modifyFilter(false);
 		// also refresh bookmarks and groups
 	}
 
 	private void createDisplay(final Composite parent) {
 		parent.setLayout(EclipseUiUtils.noSpaceGridLayout());
 
 		// top filter
 		filterCmp = new Composite(parent, SWT.NO_FOCUS);
 		filterCmp.setLayoutData(EclipseUiUtils.fillWidth());
 		addFilterPanel(filterCmp);
 
 		// Main display
 		directoryDisplayViewer = new FsTableViewer(parent, SWT.MULTI);
 		List<ColumnDefinition> colDefs = new ArrayList<>();
 		colDefs.add(new ColumnDefinition(new FileIconNameLabelProvider(), "Name", 250));
 		colDefs.add(new ColumnDefinition(new NioFileLabelProvider(FsUiConstants.PROPERTY_SIZE), "Size", 100));
 		colDefs.add(new ColumnDefinition(new NioFileLabelProvider(FsUiConstants.PROPERTY_TYPE), "Type", 150));
 		colDefs.add(new ColumnDefinition(new NioFileLabelProvider(FsUiConstants.PROPERTY_LAST_MODIFIED),
 				"Last modified", 400));
 		final Table table = directoryDisplayViewer.configureDefaultTable(colDefs);
 		table.setLayoutData(EclipseUiUtils.fillAll());
 
 		// table.addKeyListener(new KeyListener() {
 		// private static final long serialVersionUID = -8083424284436715709L;
 		//
 		// @Override
 		// public void keyReleased(KeyEvent e) {
 		// }
 		//
 		// @Override
 		// public void keyPressed(KeyEvent e) {
 		// if (log.isDebugEnabled())
 		// log.debug("Key event received: " + e.keyCode);
 		// IStructuredSelection selection = (IStructuredSelection)
 		// directoryDisplayViewer.getSelection();
 		// Path selected = null;
 		// if (!selection.isEmpty())
 		// selected = ((Path) selection.getFirstElement());
 		// if (e.keyCode == SWT.CR) {
 		// if (!Files.isDirectory(selected))
 		// return;
 		// if (selected != null) {
 		// currDisplayedFolder = selected;
 		// directoryDisplayViewer.setInput(currDisplayedFolder, "*");
 		// }
 		// } else if (e.keyCode == SWT.BS) {
 		// currDisplayedFolder = currDisplayedFolder.getParent();
 		// directoryDisplayViewer.setInput(currDisplayedFolder, "*");
 		// directoryDisplayViewer.getTable().setFocus();
 		// }
 		// }
 		// });
 
 		directoryDisplayViewer.addSelectionChangedListener(new ISelectionChangedListener() {
 
 			@Override
 			public void selectionChanged(SelectionChangedEvent event) {
 				IStructuredSelection selection = (IStructuredSelection) directoryDisplayViewer.getSelection();
 				Path selected = null;
 				if (selection.isEmpty())
 					setSelected(null);
 				else
 					selected = ((Path) selection.getFirstElement());
 				if (selected != null) {
 					// TODO manage multiple selection
 					setSelected(selected);
 				}
 			}
 		});
 
 		directoryDisplayViewer.addDoubleClickListener(new IDoubleClickListener() {
 			@Override
 			public void doubleClick(DoubleClickEvent event) {
 				IStructuredSelection selection = (IStructuredSelection) directoryDisplayViewer.getSelection();
 				Path selected = null;
 				if (!selection.isEmpty())
 					selected = ((Path) selection.getFirstElement());
 				if (selected != null) {
 					if (!Files.isDirectory(selected))
 						return;
 					setInput(selected);
 				}
 			}
 		});
 
 		// The context menu
 		contextMenu = new FsContextMenu(this);
 
 		table.addMouseListener(new MouseAdapter() {
 			private static final long serialVersionUID = 6737579410648595940L;
 
 			@Override
 			public void mouseDown(MouseEvent e) {
 				if (e.button == 3) {
 					// contextMenu.setCurrFolderPath(currDisplayedFolder);
 					contextMenu.show(table, new Point(e.x, e.y), currDisplayedFolder);
 				}
 			}
 		});
 	}
 
 	private void addPathElementBtn(Path path) {
 		Button elemBtn = new Button(filterCmp, SWT.PUSH);
 		String nameStr;
 		if (path.toString().equals("/"))
 			nameStr = "[jcr:root]";
 		else
 			nameStr = path.getFileName().toString();
 		elemBtn.setText(nameStr + " >> ");
 		CmsUiUtils.style(elemBtn, FsStyles.BREAD_CRUMB_BTN);
 		elemBtn.addSelectionListener(new SelectionAdapter() {
 			private static final long serialVersionUID = -4103695476023480651L;
 
 			@Override
 			public void widgetSelected(SelectionEvent e) {
 				setInput(path);
 			}
 		});
 	}
 
 	public void setInput(Path path) {
 		if (path.equals(currDisplayedFolder))
 			return;
 		currDisplayedFolder = path;
 
 		Path diff = initialPath.relativize(currDisplayedFolder);
 
 		for (Control child : filterCmp.getChildren())
 			if (!child.equals(filterTxt))
 				child.dispose();
 
 		addPathElementBtn(initialPath);
 		Path currTarget = initialPath;
 		if (!diff.toString().equals(""))
 			for (Path pathElem : diff) {
 				currTarget = currTarget.resolve(pathElem);
 				addPathElementBtn(currTarget);
 			}
 
 		filterTxt.setText("");
 		filterTxt.moveBelow(null);
 		setSelected(null);
 		filterCmp.getParent().layout(true, true);
 	}
 
 	private void setSelected(Path path) {
 		currSelected = path;
 		setOverviewInput(path);
 	}
 
 	public Viewer getViewer() {
 		return directoryDisplayViewer;
 	}
 
 	private void populateBookmarks(Composite parent) {
 		CmsUiUtils.clear(parent);
 		parent.setLayout(new GridLayout());
 		ISelectionChangedListener selList = new BookmarksSelChangeListener();
 
 		FsTableViewer homeViewer = new FsTableViewer(parent, SWT.SINGLE | SWT.NO_SCROLL);
 		Table table = homeViewer.configureDefaultSingleColumnTable(bookmarkColWith);
 		GridData gd = EclipseUiUtils.fillWidth();
 		gd.horizontalIndent = 10;
 		table.setLayoutData(gd);
 		homeViewer.addSelectionChangedListener(selList);
 		homeViewer.setPathsInput(getMyFilesPath());
 
 		appendTitle(parent, "Shared files");
 		FsTableViewer groupsViewer = new FsTableViewer(parent, SWT.SINGLE | SWT.NO_SCROLL);
 		table = groupsViewer.configureDefaultSingleColumnTable(bookmarkColWith);
 		gd = EclipseUiUtils.fillWidth();
 		gd.horizontalIndent = 10;
 		table.setLayoutData(gd);
 		groupsViewer.addSelectionChangedListener(selList);
 		groupsViewer.setPathsInput(getMyGroupsFilesPath());
 
 		appendTitle(parent, "My bookmarks");
 		FsTableViewer bookmarksViewer = new FsTableViewer(parent, SWT.SINGLE | SWT.NO_SCROLL);
 		table = bookmarksViewer.configureDefaultSingleColumnTable(bookmarkColWith);
 		gd = EclipseUiUtils.fillWidth();
 		gd.horizontalIndent = 10;
 		table.setLayoutData(gd);
 		bookmarksViewer.addSelectionChangedListener(selList);
 		bookmarksViewer.setPathsInput(getMyBookmarks());
 	}
 
 	/**
 	 * Recreates the content of the box that displays information about the
 	 * current selected Path.
 	 */
 	private void setOverviewInput(Path path) {
 		try {
 			EclipseUiUtils.clear(rightPannelCmp);
 			rightPannelCmp.setLayout(new GridLayout());
 			if (path != null) {
 				// if (isImg(context)) {
 				// EditableImage image = new Img(parent, RIGHT, context,
 				// imageWidth);
 				// image.setLayoutData(new GridData(SWT.CENTER, SWT.CENTER,
 				// true, false,
 				// 2, 1));
 				// }
 
 				Label contextL = new Label(rightPannelCmp, SWT.NONE);
 				contextL.setText(path.getFileName().toString());
 				contextL.setFont(EclipseUiUtils.getBoldFont(rightPannelCmp));
 				addProperty(rightPannelCmp, "Last modified", Files.getLastModifiedTime(path).toString());
 				// addProperty(rightPannelCmp, "Owner",
 				// Files.getOwner(path).getName());
 				if (Files.isDirectory(path)) {
 					addProperty(rightPannelCmp, "Type", "Folder");
 				} else {
 					String mimeType = Files.probeContentType(path);
 					if (EclipseUiUtils.isEmpty(mimeType))
 						mimeType = "<i>Unknown</i>";
 					addProperty(rightPannelCmp, "Type", mimeType);
 					addProperty(rightPannelCmp, "Size", FsUiUtils.humanReadableByteCount(Files.size(path), false));
 				}
 			}
 			rightPannelCmp.layout(true, true);
 		} catch (IOException e) {
 			throw new CmsException("Cannot display details for " + path.toString(), e);
 		}
 	}
 
 	private void addFilterPanel(Composite parent) {
 		RowLayout rl = new RowLayout(SWT.HORIZONTAL);
 		rl.wrap = true;
 		parent.setLayout(rl);
 		// parent.setLayout(EclipseUiUtils.noSpaceGridLayout(new GridLayout(2,
 		// false)));
 
 		filterTxt = new Text(parent, SWT.SEARCH | SWT.ICON_CANCEL);
 		filterTxt.setMessage("Search current folder");
 		filterTxt.setLayoutData(new RowData(250, SWT.DEFAULT));
 		filterTxt.addModifyListener(new ModifyListener() {
 			private static final long serialVersionUID = 1L;
 
 			public void modifyText(ModifyEvent event) {
 				modifyFilter(false);
 			}
 		});
 		filterTxt.addKeyListener(new KeyListener() {
 			private static final long serialVersionUID = 2533535233583035527L;
 
 			@Override
 			public void keyReleased(KeyEvent e) {
 			}
 
 			@Override
 			public void keyPressed(KeyEvent e) {
 				// boolean shiftPressed = (e.stateMask & SWT.SHIFT) != 0;
 				// // boolean altPressed = (e.stateMask & SWT.ALT) != 0;
 				// FilterEntitiesVirtualTable currTable = null;
 				// if (currEdited != null) {
 				// FilterEntitiesVirtualTable table =
 				// browserCols.get(currEdited);
 				// if (table != null && !table.isDisposed())
 				// currTable = table;
 				// }
 				//
 				// if (e.keyCode == SWT.ARROW_DOWN)
 				// currTable.setFocus();
 				// else if (e.keyCode == SWT.BS) {
 				// if (filterTxt.getText().equals("")
 				// && !(currEdited.getNameCount() == 1 ||
 				// currEdited.equals(initialPath))) {
 				// Path oldEdited = currEdited;
 				// Path parentPath = currEdited.getParent();
 				// setEdited(parentPath);
 				// if (browserCols.containsKey(parentPath))
 				// browserCols.get(parentPath).setSelected(oldEdited);
 				// filterTxt.setFocus();
 				// e.doit = false;
 				// }
 				// } else if (e.keyCode == SWT.TAB && !shiftPressed) {
 				// Path uniqueChild = getOnlyChild(currEdited,
 				// filterTxt.getText());
 				// if (uniqueChild != null) {
 				// // Highlight the unique chosen child
 				// currTable.setSelected(uniqueChild);
 				// setEdited(uniqueChild);
 				// }
 				// filterTxt.setFocus();
 				// e.doit = false;
 				// }
 			}
 		});
 	}
 
 	private Path getOnlyChild(Path parent, String filter) {
 		try (DirectoryStream<Path> stream = Files.newDirectoryStream(currDisplayedFolder, filter + "*")) {
 			Path uniqueChild = null;
 			boolean moreThanOne = false;
 			loop: for (Path entry : stream) {
 				if (uniqueChild == null) {
 					uniqueChild = entry;
 				} else {
 					moreThanOne = true;
 					break loop;
 				}
 			}
 			if (!moreThanOne)
 				return uniqueChild;
 			return null;
 		} catch (IOException ioe) {
 			throw new CmsException(
 					"Unable to determine unique child existence and get it under " + parent + " with filter " + filter,
 					ioe);
 		}
 	}
 
 	private void modifyFilter(boolean fromOutside) {
 		if (!fromOutside)
 			if (currDisplayedFolder != null) {
 				String filter = filterTxt.getText() + "*";
 				directoryDisplayViewer.setInput(currDisplayedFolder, filter);
 			}
 	}
 
 	private class BookmarksSelChangeListener implements ISelectionChangedListener {
 
 		@Override
 		public void selectionChanged(SelectionChangedEvent event) {
 			IStructuredSelection selection = (IStructuredSelection) event.getSelection();
 			if (selection.isEmpty())
 				return;
 			else {
 				Path newSelected = (Path) selection.getFirstElement();
 				if (newSelected.equals(currDisplayedFolder) && newSelected.equals(initialPath))
 					return;
 				initialPath = newSelected;
 				setInput(newSelected);
 			}
 		}
 	}
 
 	// Simplify UI implementation
 	private void addProperty(Composite parent, String propName, String value) {
 		Label contextL = new Label(parent, SWT.NONE);
 		contextL.setText(propName + ": " + value);
 	}
 
 	private Label appendTitle(Composite parent, String value) {
 		Label titleLbl = new Label(parent, SWT.NONE);
 		titleLbl.setText(value);
 		titleLbl.setFont(EclipseUiUtils.getBoldFont(parent));
 		GridData gd = EclipseUiUtils.fillWidth();
 		gd.horizontalIndent = 5;
 		gd.verticalIndent = 5;
 		titleLbl.setLayoutData(gd);
 		return titleLbl;
 	}
 }