package org.gcube.portlets.user.geoportaldataentry.client;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.TreeMap;

import org.gcube.application.geoportalcommon.shared.GeoNaItemRef;
import org.gcube.portlets.user.geoportaldataentry.client.events.CreateNewProjectEvent;
import org.gcube.portlets.user.geoportaldataentry.client.events.CreateNewProjectEventHandler;
import org.gcube.portlets.user.geoportaldataentry.client.events.SaveGeonaDataFormsEvent;
import org.gcube.portlets.user.geoportaldataentry.client.events.SaveGeonaDataFormsHandler;
import org.gcube.portlets.user.geoportaldataentry.client.ui.GeonaDataEntryMainForm;
import org.gcube.portlets.user.geoportaldataentry.client.ui.GeonaMainPanel;
import org.gcube.portlets.user.geoportaldataentry.client.ui.card.GeoNaFormCardModel;
import org.gcube.portlets.user.geoportaldataentry.client.ui.utils.LoaderIcon;
import org.gcube.portlets.user.geoportaldataentry.shared.CommitReport;
import org.gcube.portlets.user.geoportaldataentry.shared.GeoNaFormDataObject;
import org.gcube.portlets.user.geoportaldataentry.shared.GeonaISConfig;
import org.gcube.portlets.widgets.mpformbuilder.client.MetadataProfileFormBuilderServiceAsync;
import org.gcube.portlets.widgets.mpformbuilder.client.form.generic.CreateMetadataForm;
import org.gcube.portlets.widgets.mpformbuilder.shared.metadata.MetaDataProfileBean;

import com.github.gwtbootstrap.client.ui.Alert;
import com.github.gwtbootstrap.client.ui.Modal;
import com.github.gwtbootstrap.client.ui.constants.AlertType;
import com.google.gwt.core.client.EntryPoint;
import com.google.gwt.core.client.GWT;
import com.google.gwt.event.shared.HandlerManager;
import com.google.gwt.user.client.Window;
import com.google.gwt.user.client.rpc.AsyncCallback;
import com.google.gwt.user.client.ui.HTML;
import com.google.gwt.user.client.ui.HorizontalPanel;
import com.google.gwt.user.client.ui.RootPanel;

/**
 * Entry point classes define <code>onModuleLoad()</code>.
 */
public class GeoPortalDataEntryApp implements EntryPoint {
	

	/**
	 * The message displayed to the user when the server cannot be reached or
	 * returns an error.
	 */
	private static final String SERVER_ERROR = "An error occurred while "
			+ "attempting to contact the server. Please check your network " + "connection and try again.";

	private static final String DIV_PORTLET_ID = "geoportal-data-entry";

	/**
	 * Create a remote service proxy to talk to the server-side Greeting service.
	 */
	private final GeoportalDataEntryServiceAsync greetingService = GWT.create(GeoportalDataEntryService.class);

	private final HandlerManager appManagerBus = new HandlerManager(null);

	private LinkedHashMap<String, GeoNaFormCardModel> mapForms = new LinkedHashMap<String, GeoNaFormCardModel>();
	
	private GeonaDataEntryMainForm geoNaMainForm;
	
	private Collection<GeoNaFormCardModel> orderedCards;
	
	private GeonaMainPanel mainPanel;
	
	private LinkedHashMap<Long, List<GeoNaFormDataObject>> savedMap = new LinkedHashMap<Long, List<GeoNaFormDataObject>>();
	
	private boolean projectSavedWithSuccess;
	
	/**
	 * This is the entry point method.
	 */
	public void onModuleLoad() {
		
		mainPanel = new GeonaMainPanel(appManagerBus);
		mainPanel.setLoaderVisible("Loading...", true);
	
		geoNaMainForm = new GeonaDataEntryMainForm(appManagerBus);
		
		GeoportalDataEntryServiceAsync.Util.getInstance().getGeonaInitConfig(new AsyncCallback<GeonaISConfig>() {

			@Override
			public void onFailure(Throwable caught) {
				Window.alert(ConstantsGeoPortalDataEntryApp.ERROR_ON_INIZIALITAION_STAGE_PLEASE_CONTACT_THE_SUPPORT);
			}

			@Override
			public void onSuccess(GeonaISConfig result) {
				
				if(result!=null && result.getgRSecondaryType()!=null && result.getScope()!=null) {
					callGetMetadataProfiles(result.getScope(), result.getgRSecondaryType());
				}else
					Window.alert(ConstantsGeoPortalDataEntryApp.ERROR_ON_INIZIALITAION_STAGE_PLEASE_CONTACT_THE_SUPPORT);
				
			}
		});
		
		bindEvents();
		mainPanel.addFormPanel(geoNaMainForm);
		RootPanel.get(DIV_PORTLET_ID).add(mainPanel);
	}
	
	
	private void callGetMetadataProfiles(String scope, String secondaryType) {
		
		MetadataProfileFormBuilderServiceAsync.Util.getInstance().getProfilesInTheScope(scope, secondaryType, new AsyncCallback<List<MetaDataProfileBean>>() {
			
			@Override
			public void onSuccess(List<MetaDataProfileBean> result) {
				GWT.log("Returned "+result.size()+ "profile/s");
				orderedCards = setGeoNaFormsOrder(result);
				//ordered values
				buildNewCards(orderedCards);
			}
			
			@Override
			public void onFailure(Throwable caught) {
			}
		});
	}
	
	private void buildNewCards(Collection<GeoNaFormCardModel> orderedCards) {
		projectSavedWithSuccess = false; //resetting state of saving
		mainPanel.setLoaderVisible("Loading...", true);
		resetUI();
		//ordered values
		for (GeoNaFormCardModel geonaForm : orderedCards) {
			
			//TODO TO TEST
			//if(geonaForm.getFormCardTitle().equals(ConcessioniFormCardTitle.IMMAGINI_RAPPRESENTATIVE)){

				GWT.log("Adding card: "+geonaForm.getFormCardTitle());
				CreateMetadataForm baseForm = new CreateMetadataForm(Arrays.asList(geonaForm.getMetadataProfileBean()),appManagerBus);
				geonaForm.setMetadataForm(baseForm);
				String key = geonaForm.getMetadataProfileBean().getType();
				if(geonaForm.getFormCardTitle()!=null) {
					key = geonaForm.getFormCardTitle().getTitle();
				}
				geoNaMainForm.addForm(key, geonaForm);
				mapForms.put(key, geonaForm);
			
			//}
		}
		geoNaMainForm.enableButtonSave(true);
		mainPanel.setLoaderVisible("", false);
	}
	
	private void resetUI() {
		geoNaMainForm.reset();
		mapForms.clear();
	}
	
	private Collection<GeoNaFormCardModel> setGeoNaFormsOrder(List<MetaDataProfileBean> listMetadataProfilesForGeona) {
		
		TreeMap<Integer, GeoNaFormCardModel> treemapOrderedGeoNaProfiles = new TreeMap<Integer, GeoNaFormCardModel>();
		
		List<GeoNaFormCardModel> listUnknownType = new ArrayList<GeoNaFormCardModel>();

		for (MetaDataProfileBean metaDataProfileBean : listMetadataProfilesForGeona) {
			
			String theMetaType = metaDataProfileBean.getType().toLowerCase();
			GWT.log("Building form card for type: "+theMetaType);
			GeoNaFormCardModel geonaForm = new GeoNaFormCardModel(metaDataProfileBean, null, null);
			
			if(theMetaType.contains(ConcessioniFormCardTitle.INFORMAZIONI_DI_PROGETTO.getKey().toLowerCase())) {
				geonaForm.setFormCardTitle(ConcessioniFormCardTitle.INFORMAZIONI_DI_PROGETTO);
				treemapOrderedGeoNaProfiles.put(ConcessioniFormCardTitle.INFORMAZIONI_DI_PROGETTO.getOrder(), geonaForm);
			}else if(theMetaType.contains(ConcessioniFormCardTitle.ABSTRACT_RELAZIONE_DI_SCAVO.getKey().toLowerCase())) {
				geonaForm.setFormCardTitle(ConcessioniFormCardTitle.ABSTRACT_RELAZIONE_DI_SCAVO);
				treemapOrderedGeoNaProfiles.put(ConcessioniFormCardTitle.ABSTRACT_RELAZIONE_DI_SCAVO.getOrder(), geonaForm);
			}else if(theMetaType.contains(ConcessioniFormCardTitle.RELAZIONE_DI_SCAVO.getKey().toLowerCase())) {
				geonaForm.setFormCardTitle(ConcessioniFormCardTitle.RELAZIONE_DI_SCAVO);
				treemapOrderedGeoNaProfiles.put(ConcessioniFormCardTitle.RELAZIONE_DI_SCAVO.getOrder(), geonaForm);
			}else if(theMetaType.contains(ConcessioniFormCardTitle.IMMAGINI_RAPPRESENTATIVE.getKey().toLowerCase())) {
				geonaForm.setFormCardTitle(ConcessioniFormCardTitle.IMMAGINI_RAPPRESENTATIVE);
				treemapOrderedGeoNaProfiles.put(ConcessioniFormCardTitle.IMMAGINI_RAPPRESENTATIVE.getOrder(), geonaForm);
			}else if(theMetaType.contains(ConcessioniFormCardTitle.POSIZIONAMENTO_DELL_AREA_DI_INDAGINE.getKey().toLowerCase())) {
				geonaForm.setFormCardTitle(ConcessioniFormCardTitle.POSIZIONAMENTO_DELL_AREA_DI_INDAGINE);
				treemapOrderedGeoNaProfiles.put(ConcessioniFormCardTitle.POSIZIONAMENTO_DELL_AREA_DI_INDAGINE.getOrder(), geonaForm);
			}else if(theMetaType.contains(ConcessioniFormCardTitle.PIANTA_DI_FINE_SCAVO.getKey().toLowerCase())) {
				geonaForm.setFormCardTitle(ConcessioniFormCardTitle.PIANTA_DI_FINE_SCAVO);
				treemapOrderedGeoNaProfiles.put(ConcessioniFormCardTitle.PIANTA_DI_FINE_SCAVO.getOrder(), geonaForm);
			}else {
				//adding to unknown list
				listUnknownType.add(geonaForm);
			}
		}
		
		//adding unknown types
		for (GeoNaFormCardModel geoNaFormCardModel : listUnknownType) {
			Integer highestKey = treemapOrderedGeoNaProfiles.lastKey();
			highestKey++;
			treemapOrderedGeoNaProfiles.put(highestKey, geoNaFormCardModel);
		}
		
		GWT.log("Map size: "+treemapOrderedGeoNaProfiles.size());
		return treemapOrderedGeoNaProfiles.values();
		
	}
	
	
	private void bindEvents() {
		
		appManagerBus.addHandler(SaveGeonaDataFormsEvent.TYPE, new SaveGeonaDataFormsHandler() {
			
			@Override
			public void onSave(final SaveGeonaDataFormsEvent saveGeonaDataFormsEvent) {
				
				geoNaMainForm.enableButtonSave(false);
				
				if(saveGeonaDataFormsEvent.getListGeonaDataForms()!=null) {
					
					final Modal modal = new Modal(true);
					modal.setCloseVisible(false);
					modal.setTitle("Saving project...");
					modal.hide(false);
					final HorizontalPanel modalContainerPanel = new HorizontalPanel();
					final LoaderIcon loader = new LoaderIcon();
					loader.setText("Trying to save the data, please wait...");
					modalContainerPanel.add(loader);
					modal.add(modalContainerPanel);

					GeoportalDataEntryServiceAsync.Util.getInstance().saveGeonaDataForms(saveGeonaDataFormsEvent.getListGeonaDataForms(), new AsyncCallback<CommitReport>() {

						@Override
						public void onFailure(Throwable caught) {
							modalContainerPanel.clear();
							modal.setCloseVisible(true);
							try {
								modal.remove(loader);
							}catch (Exception e) {
							}
							Alert alert = new Alert(caught.getMessage());
							alert.setType(AlertType.ERROR);
							alert.setClose(false);
							modal.add(alert);
							//resetUI();
							geoNaMainForm.enableButtonSave(true);
						}

						@Override
						public void onSuccess(CommitReport result) {
							modalContainerPanel.clear();
							modal.setCloseVisible(true);
							Alert alert = new Alert(result.getMsg());
							switch (result.getState()) {
							case OK:
								alert.setType(AlertType.SUCCESS);
								projectSavedWithSuccess = true;
								geoNaMainForm.showAlertOnSaveAction(result.getMsg(), AlertType.SUCCESS, true);
								purgeFileUploaded();
								break;
							case WARN:
								alert.setType(AlertType.WARNING);
								geoNaMainForm.enableButtonSave(true);
								if(result.getReport()!=null)
									modal.add(new Alert(result.getReport(), AlertType.INFO));
								break;
							case ERROR:
								alert.setType(AlertType.ERROR);
								geoNaMainForm.enableButtonSave(true);
								if(result.getReport()!=null)
									modal.add(new Alert(result.getReport(), AlertType.INFO));
								break;
							default:
								break;
							}
							alert.setClose(false);
							modal.add(alert);
							
							try {
								savedMap.put(result.getRecordId(), saveGeonaDataFormsEvent.getListGeonaDataForms());
							}catch (Exception e) {
								// TODO: handle exception
							}
							
							final HorizontalPanel hpLoader = new HorizontalPanel();
							final LoaderIcon lc = new LoaderIcon("Get link...");
							hpLoader.add(lc);
							modal.add(hpLoader);
							GeoportalDataEntryServiceAsync.Util.getInstance().getLinksFor(result.getRecordId(), "concessione", new AsyncCallback<GeoNaItemRef>() {

								@Override
								public void onFailure(Throwable caught) {
									hpLoader.clear();
									
								}

								@Override
								public void onSuccess(GeoNaItemRef result) {
									hpLoader.clear();
									String htmlLink = "<div>Go to record: <a href="+result.getRestrictedLink().getShortURL()+" target=\"_blank\">"+result.getRestrictedLink().getShortURL()+"</a></div>";
									HTML html = new HTML(htmlLink);
									modal.add(html);
								}
							});

							
							//geoNaMainForm.enableButtonSave(true);
							//resetUI();
							
						}
					});
					
					modal.show();
				}else
					geoNaMainForm.enableButtonSave(true);
				
			}
		});
		
		appManagerBus.addHandler(CreateNewProjectEvent.TYPE, new CreateNewProjectEventHandler() {
			
			@Override
			public void onCreateNewProject(CreateNewProjectEvent newProjectEvent) {
				
				// means the form was not submitted
				if (savedMap.size() == 0) {
					boolean confirm = Window.confirm(
							"Creating a new project, the current project (is not saved) and will be lost, Confirm?");
					if (confirm)
						buildNewCards(orderedCards);
				} else if (projectSavedWithSuccess) {
					//means the project has been saved
					buildNewCards(orderedCards);
				} else {
					//means the project reported one ore more errors after the submit
					boolean confirm = Window.confirm("Creating a new project, the web-forms will be cleaned, Confirm?");
					if (confirm)
						buildNewCards(orderedCards);
				}

			}
		});
	}
	
	private void purgeFileUploaded() {
		
		MetadataProfileFormBuilderServiceAsync.Util.getInstance().purgeFilesUploaded(new AsyncCallback<Integer>() {

			@Override
			public void onFailure(Throwable caught) {
				//silent
				
			}

			@Override
			public void onSuccess(Integer result) {
				GWT.log("Purged "+result+" file/s uploaded");
				
			}
		});
	}

}