package org.eclipse.osbp.authentication.account.tables;

import com.github.wolfie.refresher.Refresher;
import com.vaadin.data.Container;
import com.vaadin.data.Property.ValueChangeListener;
import com.vaadin.server.ClientConnector;
import com.vaadin.server.Page;
import com.vaadin.server.Page.Styles;
import com.vaadin.shared.ui.label.ContentMode;
import com.vaadin.ui.Button;
import com.vaadin.ui.Button.ClickEvent;
import com.vaadin.ui.Component;
import com.vaadin.ui.CustomTable;
import com.vaadin.ui.CustomTable.Align;
import com.vaadin.ui.CustomTable.RowHeaderMode;
import com.vaadin.ui.HorizontalLayout;
import com.vaadin.ui.Label;
import com.vaadin.ui.Notification;
import com.vaadin.ui.Notification.Type;
import com.vaadin.ui.TabSheet;
import com.vaadin.ui.UI;
import com.vaadin.ui.VerticalLayout;
import java.io.PrintWriter;
import java.io.StringWriter;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Date;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.Set;
import java.util.TreeSet;
import java.util.UUID;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
import java.util.stream.Collectors;
import javax.inject.Inject;
import org.eclipse.bpmn2.Task;
import org.eclipse.e4.core.contexts.ContextInjectionFactory;
import org.eclipse.e4.core.contexts.IEclipseContext;
import org.eclipse.e4.core.di.extensions.EventUtils;
import org.eclipse.e4.core.services.events.IEventBroker;
import org.eclipse.e4.ui.di.Focus;
import org.eclipse.e4.ui.model.application.MApplication;
import org.eclipse.e4.ui.workbench.IPresentationEngine;
import org.eclipse.osbp.authentication.account.datamarts.UserAccountDatamart;
import org.eclipse.osbp.bpm.api.BPMOperation;
import org.eclipse.osbp.bpm.api.BPMTaskEventType;
import org.eclipse.osbp.bpm.api.BPMTaskSummary;
import org.eclipse.osbp.bpm.api.BPMTaskUserEvent;
import org.eclipse.osbp.bpm.api.IBlipBPMConstants;
import org.eclipse.osbp.bpm.api.IBlipBPMFunctionProvider;
import org.eclipse.osbp.bpm.api.IBlipBPMStartInfo;
import org.eclipse.osbp.bpm.api.IBlipBPMWorkloadModifiableItem;
import org.eclipse.osbp.dsl.common.datatypes.IDto;
import org.eclipse.osbp.dsl.dto.lib.impl.DtoServiceAccess;
import org.eclipse.osbp.eventbroker.EventBrokerMsg;
import org.eclipse.osbp.osgi.hybrid.api.AbstractHybridVaaclipseView;
import org.eclipse.osbp.preferences.ProductConfiguration;
import org.eclipse.osbp.runtime.common.event.EventDispatcherEvent;
import org.eclipse.osbp.runtime.common.event.EventDispatcherEvent.EventDispatcherCommand;
import org.eclipse.osbp.runtime.common.event.EventDispatcherEvent.EventDispatcherDataTag;
import org.eclipse.osbp.runtime.common.event.IEventDispatcher;
import org.eclipse.osbp.runtime.common.filter.IDTOServiceWithMutablePersistence;
import org.eclipse.osbp.runtime.web.vaadin.common.data.IBeanSearchServiceFactory;
import org.eclipse.osbp.ui.api.contextfunction.IViewEmbeddedProvider;
import org.eclipse.osbp.ui.api.customfields.IBlobService;
import org.eclipse.osbp.ui.api.datamart.DatamartFilter;
import org.eclipse.osbp.ui.api.datamart.DatamartPrimary;
import org.eclipse.osbp.ui.api.datamart.IDatamartFilterGenerator;
import org.eclipse.osbp.ui.api.datamart.IDatamartFilterGenerator.FilterChangeListener;
import org.eclipse.osbp.ui.api.e4.IE4Table;
import org.eclipse.osbp.ui.api.layout.IViewLayoutManager;
import org.eclipse.osbp.ui.api.metadata.IDSLMetadataService;
import org.eclipse.osbp.ui.api.themes.IThemeResourceService;
import org.eclipse.osbp.ui.api.themes.IThemeResourceService.ThemeResourceType;
import org.eclipse.osbp.ui.api.user.IUser;
import org.eclipse.osbp.utils.constants.ExtendedDate;
import org.eclipse.osbp.utils.vaadin.PropertyLookup;
import org.eclipse.osbp.utils.vaadin.SelectUserWindow;
import org.eclipse.osbp.utils.vaadin.ViewLayoutManager;
import org.eclipse.osbp.vaaclipse.common.ecview.api.IECViewSessionHelper;
import org.eclipse.osbp.xtext.action.SelectWorkloadActionEnum;
import org.eclipse.osbp.xtext.blip.BlipItem;
import org.eclipse.osbp.xtext.datamart.common.AEntityDatamart;
import org.eclipse.osbp.xtext.datamart.common.DatamartFilterGenerator;
import org.eclipse.osbp.xtext.datamart.common.olap.DerivedAxis;
import org.eclipse.osbp.xtext.datamart.common.olap.DerivedCellSet;
import org.eclipse.osbp.xtext.datamart.common.olap.DerivedHierarchy;
import org.eclipse.osbp.xtext.datamart.common.olap.DerivedLevel;
import org.eclipse.osbp.xtext.datamart.common.olap.DerivedMember;
import org.eclipse.osbp.xtext.datamart.common.olap.DerivedPosition;
import org.eclipse.osbp.xtext.datamart.common.sql.OperativeDtoContainer;
import org.eclipse.osbp.xtext.table.common.BeanFilterTable;
import org.eclipse.osbp.xtext.table.common.CellSetFilterTable;
import org.eclipse.osbp.xtext.table.common.CellSetIndexedContainer;
import org.eclipse.osbp.xtext.table.common.CellSetPagedFilterTable;
import org.eclipse.osbp.xtext.table.common.CheckboxSelectionCellSetFilterTable;
import org.eclipse.osbp.xtext.table.common.TableFilterDecorator;
import org.eclipse.osbp.xtext.table.common.TableFilterGenerator;
import org.osgi.service.event.Event;
import org.osgi.service.event.EventHandler;
import org.slf4j.Logger;
import org.vaadin.hene.popupbutton.PopupButton;

@SuppressWarnings("all")
public class UserAdministrationTable extends AbstractHybridVaaclipseView implements IUser.UserLocaleListener, ClientConnector.DetachListener, ClientConnector.AttachListener, IEventDispatcher.Receiver, IE4Table, IDatamartFilterGenerator.FilterChangeListener {
  private static Logger log = org.slf4j.LoggerFactory.getLogger("tables");
  
  private boolean initDone = false;
  
  @Inject
  private IEclipseContext eclipseContext;
  
  @Inject
  private IUser user;
  
  @Inject
  private IEventDispatcher eventDispatcher;
  
  private ArrayList<Integer> coordinateSystem;
  
  private IViewLayoutManager layoutManager;
  
  @Inject
  private IDSLMetadataService dslMetadataService;
  
  @Inject
  private IBlobService blobService;
  
  private UserAccountDatamart datamartInstance;
  
  private IDatamartFilterGenerator filterGenerator;
  
  private Refresher tableSelectDelay;
  
  private Refresher tableRefresher;
  
  private Component dataComponent;
  
  private boolean mustRefresh = false;
  
  private HashMap<String, PropertyLookup> attributeLookupMap;
  
  private HashMap<Component, ArrayList<String>> tabSheets;
  
  private CellSetIndexedContainer dataSourceContainer;
  
  private OperativeDtoContainer operativeDtoContainer;
  
  private ArrayList<CellSetFilterTable> tables;
  
  @Inject
  private IEventBroker eventBroker;
  
  @Inject
  private IPresentationEngine renderingEngine;
  
  @Inject
  private IThemeResourceService themeResourceService;
  
  private EventHandler delegatedTask;
  
  private TableFilterDecorator tableFilterDecorator;
  
  @Inject
  public UserAdministrationTable(final VerticalLayout parent, final IEclipseContext context, final MApplication app) {
    super(parent,context,app);
    
  }
  
  public ArrayList<Integer> getCoordinateSystem() {
    return this.coordinateSystem;
  }
  
  public DerivedCellSet getCellSet() {
    operativeDtoContainer = null;
    DerivedCellSet cellSet = datamartInstance.getResults(getTaskOperativeDtoClass(), getTaskInitialOperativeDtos());
    if	(cellSet != null) {
    	operativeDtoContainer = cellSet.getOperativeDtoContainer();
    }
    return cellSet;
    
  }
  
  @Focus
  public void setFocus() {
    if(!tables.isEmpty()) {
    	tables.get(0).focus();
    }
  }
  
  @Override
  public void attach(final ClientConnector.AttachEvent event) {
    user.addUserLocaleListener(this);
    eventDispatcher.addEventReceiver(this);
    filterGenerator.addFilterChangeListener(this);
    if(mustRefresh){
    	dataRefresh();
    }
  }
  
  @Override
  public void detach(final ClientConnector.DetachEvent event) {
    user.removeUserLocaleListener(this);
    eventDispatcher.removeEventReceiver(this);
    filterGenerator.removeFilterChangeListener(this);
    
  }
  
  public void createView(final VerticalLayout parent) {
    getContext().set(IE4Table.class, this);
    tables = new ArrayList<CellSetFilterTable>();
    tableFilterDecorator = new TableFilterDecorator(dslMetadataService, user.getLocale());
    // the timeout to begin the filter process after the last key pressed
    tableFilterDecorator.setTextChangeTimeout(500);
    parent.setPrimaryStyleName("osbp");
    parent.setId("parent");
    parent.setSizeFull();
    parent.addAttachListener(this);
    parent.addDetachListener(this);
    layoutManager = new ViewLayoutManager();
    layoutManager.init(parent);
    datamartInstance = new UserAccountDatamart();
    datamartInstance.setUser(user);
    filterGenerator = new DatamartFilterGenerator(datamartInstance, dslMetadataService);
    filterGenerator.createUIFilters(layoutManager);
    coordinateSystem = new ArrayList<Integer>();
    tableSelectDelay = new Refresher();
    tableRefresher = new Refresher();
    attributeLookupMap = new HashMap<>();
    tabSheets = new HashMap<>();
    initDone = true;
    
  }
  
  public void createComponents() {
    // get the results
    final DerivedCellSet cellSet = getCellSet();
    if (cellSet == null) {
    	promptSecurityMessage(dslMetadataService.translate(user.getLocale().toLanguageTag(), "securityMessage"), layoutManager.getDataArea());
    	return;
    } else {
    	layoutManager.getDataArea().removeAllComponents();
    }
    getCoordinateSystem().clear();
    // generate a new result component
    if (cellSet != null) {
    	// create a multidimensional coordinate system against the cellSet
    	for	(int axis = 0; axis < cellSet.getAxes().size(); axis++) {
    		getCoordinateSystem().add(0);
    	}
    	// remove any previous component
    	if	(dataComponent != null) {
    		layoutManager.getDataArea().removeComponent(dataComponent);
    		dataComponent = null;
    	}
    	if (cellSet.getAxes().size() < 2) {
    		log.error("at least 2 axes from referenced datamart UserAccount are needed to render UserAdministration");
    	} else {
    		dataComponent = createTabSheet(cellSet, cellSet.getAxes().size());
    		if	(dataComponent != null) {
    			dataComponent.setSizeFull();
    			dataComponent.setId("dataComponent");
    			layoutManager.getDataArea().addComponent(dataComponent);
    			layoutManager.getDataArea().setExpandRatio(dataComponent, 1);
    		}
    	}
    } 
    else {
    	log.error("referenced datamart UserAccount generates no results");
    }
    
  }
  
  public Component createTabSheet(final DerivedCellSet cellSet, final Integer axisNo) {
    tables.clear();
    // either create a recursive tabsheet or a table
    Component component = null;
    if	(axisNo == 2) {
    	component = createTable(cellSet);
    }
    else {		
    	Integer axis = axisNo-1;
    	TabSheet tabsheet = new TabSheet();
    	tabsheet.setSizeFull();
    	tabSheets.put(tabsheet, new ArrayList<String>());
    	DerivedAxis tabAxis = cellSet.getAxes().get(axis);
    	// create a tab page for all tab axis members
    	int tabNo = 0;
    	for	(DerivedPosition column : tabAxis.getPositions()) {
    		// create the title for the axis
    		for (DerivedMember member : column.getMembers()) {
    			tabSheets.get(tabsheet).add(member.getCaption());
    		}
    		// position the data to this coordinate
    		getCoordinateSystem().set(axis, tabNo);
    		component = createTabSheet(cellSet, axis);
    		// set the caption
    		if (component != null) {
    			component.setCaption("");
    			tabsheet.addComponent(component);
        		if (component instanceof CellSetFilterTable) {
    	    		tabsheet.addComponent(((CellSetFilterTable)component));
        		}
    		}
    		tabNo++;
    	}
    	component = tabsheet;
    }
    return component;
  }
  
  public Component createTable(final DerivedCellSet cellSet) {
    final CellSetFilterTable table = new CellSetFilterTable();
    VerticalLayout tableLayout = new VerticalLayout();
    table.setImmediate(true);
    table.setMultiSelect(false);
    table.setColumnCollapsingAllowed(true);
    table.setColumnReorderingAllowed(true);
    table.setId("table");
    table.setRowHeaderMode(RowHeaderMode.HIDDEN);
    table.setFilterDecorator(tableFilterDecorator);
    table.setFilterBarVisible(true);
    table.setSelectable(true);
    table.setSizeFull();
    tableLayout.addComponent(table);
    tables.add(table);
    // add attributeLookups for column and row attribute supplements
    attributeLookupMap.put("__USERACCOUNT__ID__", new PropertyLookup(themeResourceService, dslMetadataService, blobService, user.getLocale())
    	.setCollapseColumn(true)
    );
    attributeLookupMap.put("PROFILEIMAGE", new PropertyLookup(themeResourceService, dslMetadataService, blobService, user.getLocale())
    	.setBlob(true, 2)
    );
    dataSourceContainer = new CellSetIndexedContainer(dslMetadataService, user.getLocale(), themeResourceService, blobService, attributeLookupMap, cellSet, coordinateSystem, false);
    table.setContainerDataSource(dataSourceContainer);
    dataSourceContainer.addExtras(table);
    table.addValueChangeListener(new ValueChangeListener() {
    	@Override
    	public void valueChange(com.vaadin.data.Property.ValueChangeEvent event) {
    		Object msg = null;
    		Object id = null;
    		String target = null;
    		Object value = table.getValue();
    		int selection = -1;
    		if	(value instanceof Integer) {
    			selection = (Integer)value;
    		}
    		else {
    			if ((value instanceof Collection<?>) && (((Collection<?>)value).size() == 1)) {
    				value = ((Collection<?>)value).iterator().next();
        			if	(value instanceof Integer) {
        				selection = (Integer)value;
        			}
    			}
    		}
    		EventDispatcherEvent evnt = new EventDispatcherEvent(EventDispatcherCommand.SELECT, "org.eclipse.osbp.authentication.account.entities.UserAccount.id", "org.eclipse.osbp.authentication.account.tables.UserAdministration");
    		evnt.addItem(EventDispatcherDataTag.ID, dataSourceContainer.getValueByProperty(selection, "__useraccount__id__"));
    		eventDispatcher.sendEvent(evnt);
    	}
    });
    return tableLayout;
  }
  
  public void dataRefresh() {
    try {
    	// if no current ui found
    	if (UI.getCurrent() == null) {
    		for(CellSetFilterTable table:tables) {
    			UI.setCurrent(table.getUI());
    			break;
    		}
    	}
    	if(dataSourceContainer== null || !dataSourceContainer.updateContainer(getCellSet())) {
    		log.debug("cannot update container - full refresh");
    		renderData();
    	}
    	for(CellSetFilterTable table:tables) {
    		table.sanitizeSelection();
    	}
    } catch (Exception e) {
    	StringWriter sw = new StringWriter();
    	e.printStackTrace(new PrintWriter(sw));
    	String exceptionDetails = sw.toString();
    	log.error("table data refresh:{}", exceptionDetails);
    }
  }
  
  @Override
  public void localeChanged(final Locale locale) {
    if(initDone) {
    	tableFilterDecorator.setLocale(locale);
    	for(CellSetFilterTable table:tables) {
    		table.setLocale(locale);
    	}
    	for(String key:attributeLookupMap.keySet()) {
    		attributeLookupMap.get(key).setLocale(locale);
    	}
    	for(Component tabSheet : tabSheets.keySet()) {
    		((TabSheet)tabSheet).setCaption(tabSheets.get(tabSheet).stream().map(x->dslMetadataService.translate(locale.toLanguageTag(), x)).collect(Collectors.joining("/")));
    	}
    	if(dataSourceContainer != null) {
    		dataSourceContainer.setLocale(locale);
    	}
    	layoutManager.setLabelValue(dslMetadataService.translate(locale.toLanguageTag(), "UserAdministration"));
    }
    
  }
  
  @Override
  public void receiveEvent(final EventDispatcherEvent event) {
    switch(event.getCommand()) {
    	case SELECT:
    		if(!event.getSender().equals("org.eclipse.osbp.authentication.account.tables.UserAdministration")) {
    			if(filterGenerator.selectItem(event, false)) {
    				renderData();
    			}
    		}
    		break;
    	case SAVE:
    	case DELETE:
    		if(!event.getSender().equals("org.eclipse.osbp.authentication.account.tables.UserAdministration")) {
    			if(event.getTopic().equals("org.eclipse.osbp.authentication.account.entities.UserAccount")){
    				datamartInstance.clearCache();
    				List<DatamartPrimary<?>> primaryKeys = datamartInstance.getPrimaryList();
    				for(DatamartPrimary key : primaryKeys) {
    					if(key.contains(event.getData().get(EventDispatcherDataTag.ID))) {
    						dataRefresh();
    					}
    				}
    			}
    		}
    		break;
    	case REFRESH:
    		if(!event.getSender().equals("org.eclipse.osbp.authentication.account.tables.UserAdministration")) {
    			if(event.getTopic().equals("org.eclipse.osbp.authentication.account.entities.UserAccount")){
    				datamartInstance.clearCache();
    				dataRefresh();
    			}
    		}
    		break;
    	}
    
  }
  
  @Override
  public void filterChanged(final DatamartFilter changedFilter) {
    if(changedFilter != null) {
    	EventDispatcherEvent evnt = new EventDispatcherEvent(EventDispatcherCommand.SELECT, changedFilter.getName(), "org.eclipse.osbp.authentication.account.tables.UserAdministration");
    	evnt.addData(changedFilter.getSelectedData());
    	eventDispatcher.sendEvent(evnt);
    }
    dataRefresh();
    
  }
}