package de.iqser.portlets;
   
   import java.io.IOException;
   import java.util.ArrayList;
   import java.util.List;
   import java.util.Set;
   import java.util.SortedSet;
   import java.util.TreeSet;
   
  import javax.portlet.ActionRequest;
  import javax.portlet.ActionResponse;
  import javax.portlet.PortletContext;
  import javax.portlet.PortletException;
  import javax.portlet.PortletPreferences;
  import javax.portlet.PortletRequestDispatcher;
  import javax.portlet.RenderRequest;
  import javax.portlet.RenderResponse;
  import javax.portlet.WindowState;
  import javax.servlet.http.HttpServletRequest;
  import javax.servlet.http.HttpSession;
  
  import com.liferay.portal.kernel.log.Log;
  import com.liferay.portal.kernel.log.LogFactoryUtil;
  import com.liferay.portal.kernel.util.ParamUtil;
  import com.liferay.portal.util.PortalUtil;
  
  import de.iqser.beans.BreadcrumbBean;
  import de.iqser.beans.ContentBean;
  import de.iqser.portlets.IqserBasePortlet;
  import de.iqser.service.PortletIQserService;
  
  public class DisplayPortlet extends IqserBasePortlet {
  	
  	public final static String ALL_TYPES= "All types";
  	public final static String PARAM_ALL_TYPES= "PARAM_ALL_TYPES";
  	public final static String PARAM_CONTENT_LIST= "PARAM_CONTENT_LIST";
  	public final static String PARAM_CONTENT_TYPES= "PARAM_CONTENT_TYPES";
  	public final static String PARAM_CONTENT_TOTAL= "PARAM_CONTENT_TOTAL";
  	public final static String PARAM_RELATED_LEVEL= "PARAM_RELATED_LEVEL";
  	
  	public final static String PREF_MIN_SCORE= "min Score";
  	public final static String PREF_MAX_RESULTS= "max Results";
  	public final static String PREF_SCROLLBAR_HEIGHT= "listHeight";
  	public final static String PREF_SCROLLBAR_WIDTH= "listWidth";
  	
  	private static Log _ilog = LogFactoryUtil.getLog(DisplayPortlet.class);
  	
  	// Portlet init-Params
  	public void init() throws PortletException {
  		viewJSP = getInitParameter("view-jsp");
  		editJSP = getInitParameter("edit-jsp");
  		// helpJSP = getInitParameter("help-jsp");
  	}
  
  	public void doView(RenderRequest req, RenderResponse res)
  			throws IOException, PortletException {
  
  		res.setContentType("text/html");
  
  		PortletContext portletContext = getPortletContext();
  
  		String action = ParamUtil.getString(req, PARAM_ACTION);
  		String errorMessage= "";
  		
  		PortletRequestDispatcher reqDispatcher = null;
  		
  		reqDispatcher = portletContext.getRequestDispatcher(viewJSP);
  		int total= 0;
  		
  		// Check first if this is only a page event, not a new query.
  		// In such cases we can get the cached data from the session.
  		// Otherwise the portlets triggering a new query have removed the old session data.
  		HttpServletRequest servletRequest= PortalUtil.getHttpServletRequest(req);
  		HttpSession servletSession= servletRequest.getSession();
  		List<ContentBean> contentList= (List<ContentBean>) servletSession.getAttribute(DEIQSER_CACHED_DATA);
  		boolean noActionFound= true;
  		if( action != null && action.startsWith("ACTION")) {
  			noActionFound= false;
  		}
  		if(contentList != null && contentList.size() > 0 && noActionFound ) {
  			SortedSet<String> allTypes= PortletIQserService.getAlltypes(contentList);
  			// a page event or an event triggered elsewhere
  			// it may be necessary to apply a filter
  			Set<String> selectedTypes= (Set<String>) servletSession.getAttribute(DisplayPortlet.DEIQSER_SELECTED_TYPES);
  			if( selectedTypes != null && selectedTypes.size() > 0) {
  				// apply filter
  				if( _ilog.isInfoEnabled()) {
  					_ilog.info("A filter is applied after an event which is not a filter event");
  				}
  				if( !selectedTypes.contains(ALL_TYPES)) {
  					// filter content list from session
  					List<ContentBean> filteredList= new ArrayList<ContentBean>();
  					for( int index= 0; index < contentList.size(); index++) {
  						ContentBean contentBean= contentList.get(index);
  						String type= contentBean.getType();
  						if( selectedTypes.contains(type)) {
  							filteredList.add(contentBean);
  						}
  					}
 					total= PortletIQserService.total(filteredList);
 					req.setAttribute(PARAM_CONTENT_LIST, filteredList);
 				}
 				else {
 					// no filter, because the selected types contains string selecting all types
 					total= PortletIQserService.total(contentList);
 					req.setAttribute(PARAM_CONTENT_LIST, contentList);
 				}
 			}
 			else {
 				// no filter create a new default filter
 				total= PortletIQserService.total(contentList);
 				req.setAttribute(PARAM_CONTENT_LIST, contentList);
 			}
 			
 			req.setAttribute(PARAM_CONTENT_TOTAL, new Integer(total));
 			req.setAttribute(PARAM_CONTENT_TYPES, allTypes);
 			// req.setAttribute(PARAM_SELECTED_TYPES, selectedTypes);	// not necessary, filter.jsp gets this from session
 			reqDispatcher.include(req, res);
 			return;	// stop, we are sure that no action was called
 		}
 		
 		String searchInput= req.getParameter(IqserBasePortlet.PUBLIC_RENDER_PARAM_SEARCH_INPUT);
 		if( searchInput != null) {
 			searchInput= searchInput.trim();
 		}
 		else {
 			searchInput= "";	// if we set empty string "" into the PUBLIC_RENDER_PARAM_SEARCH_INPUT, we get null here!
 		}
 		
 		if( contentList == null && searchInput != null) {
 			// new results are fetched in a service class
 			if( searchInput.length() > 0) {			
 				PortletPreferences prefs= req.getPreferences();
 				String iqserWebserviceUrl= prefs.getValue(PREF_IQSER_WEBSERVICE, "");
 				String maxResultsStr= prefs.getValue(PREF_MAX_RESULTS, "");
 				contentList= PortletIQserService.searchIQSER(iqserWebserviceUrl, searchInput, maxResultsStr);
 				if( contentList == null ) {
 					errorMessage= "No connection to iQser Server!";
 					req.setAttribute(PARAM_ERROR_MESSAGE, errorMessage);
 					contentList= new ArrayList<ContentBean>();	// return empty list, because we cannot fetch data
 				}
 				else {
 					errorMessage= "";
 				}
 			}
 			else {
 				errorMessage= "Search input must not be empty!";
 				req.setAttribute(PARAM_ERROR_MESSAGE, errorMessage);
 				req.setAttribute(PARAM_SEARCH_INPUT, "");
 				contentList= new ArrayList<ContentBean>();	// return empty list, because we cannot fetch data
 			}
 			
 			// store data in session for later reference
 			servletSession.setAttribute(DEIQSER_CACHED_DATA, contentList); // contains a list without filter
 			servletSession.setAttribute(DEIQSER_SEARCH_FIELD, searchInput);
 		}
 		total= PortletIQserService.total(contentList);
 		if( searchInput == null ) {
 			searchInput= (String) servletSession.getAttribute(DEIQSER_SEARCH_FIELD);
 		}
 		
 		// we have the data, check if a filter was applied
 		if( action != null && action.startsWith(ACTION_FILTER)) {
 			Set<String> selectedTypes= new TreeSet<String>();
 			String allTypesSelected= req.getParameter(PARAM_ALL_TYPES);
 			// get selected types
 			if( allTypesSelected != null && allTypesSelected.equals("true")) {
 				// in the filter section the user has checked the check box for all types
 				selectedTypes.add(ALL_TYPES);
 				_ilog.info("Filter with all types");
 			}
 			else {
 				// get selected types
 				String[] selectedTypesArr= req.getParameterValues(PARAM_TYPES);
 				if( selectedTypesArr == null ) {
 					selectedTypesArr= new String[] { ALL_TYPES };	// should not happen
 				}
 				for( int index= 0; index < selectedTypesArr.length; index++) {
 					String type= selectedTypesArr[index];
 					selectedTypes.add(type);
 					_ilog.info("Filter with type : " + type);
 				}
 			}
 			// selectedTypes is filled as requested by the user
 
 			// store selected types in session to get them later in any case
 			servletSession.setAttribute(DEIQSER_SELECTED_TYPES, selectedTypes);
 			if( !selectedTypes.contains(ALL_TYPES)) {
 				// filter content list from session
 				List<ContentBean> filteredList= new ArrayList<ContentBean>();
 				for( int index= 0; index < contentList.size(); index++) {
 					ContentBean contentBean= contentList.get(index);
 					String type= contentBean.getType();
 					if( selectedTypes.contains(type)) {
 						filteredList.add(contentBean);
 					}
 				}
 				total= PortletIQserService.total(filteredList);
 				req.setAttribute(PARAM_CONTENT_LIST, filteredList);
 			}
 			else {
 				// no filter, because the selected types contains string selecting all types
 				req.setAttribute(PARAM_CONTENT_LIST, contentList);
 			}
 		
 			// get old search input from session
 			searchInput= (String) servletSession.getAttribute(DEIQSER_SEARCH_FIELD);
 		}	// if( action != null && action.startsWith(ACTION_FILTER
 		else if( action!= null && action.startsWith(ACTION_SHOW_RELATED)) {
 			// reset selectedTypes to all types
 			Set<String> selectedTypes= (Set<String>) servletSession.getAttribute(DisplayPortlet.DEIQSER_SELECTED_TYPES);
 			if( selectedTypes != null) {
 				servletSession.removeAttribute(DEIQSER_SELECTED_TYPES);
 			}
 			// we need new data
 			int contentId= ParamUtil.getInteger(req, PARAM_ID);
 			String title= req.getParameter(PARAM_TITLE);
 			PortletPreferences prefs= req.getPreferences();
 			String iqserWebserviceUrl= prefs.getValue(PREF_IQSER_WEBSERVICE, "");
 			String minScoreStr= prefs.getValue(PREF_MIN_SCORE, "");
 			contentList= PortletIQserService.searchIQSER_Related(iqserWebserviceUrl, contentId, minScoreStr);
 			servletSession.setAttribute(DEIQSER_CACHED_DATA, contentList);
 			total= PortletIQserService.total(contentList);
 			//searchInput="related content: id=" + contentId;
 			req.setAttribute(PARAM_CONTENT_LIST, contentList);
 			// store data
 			List<BreadcrumbBean> relatedList= (List<BreadcrumbBean>) servletSession.getAttribute(DEIQSER_RELATED_LIST);
 			if( relatedList == null) {
 				relatedList= new ArrayList<BreadcrumbBean>();
 			}
 			if( title != null) {
 				// add new selection to content list
 				// if title is null, the PARAM_ID was set from the bread crumb => do not add a reference
 				BreadcrumbBean bcBean= new BreadcrumbBean();
 				bcBean.setId(""+ contentId);
 				// if title is to large, use a substring
 				if( title.length() > 20) {
 					title= title.substring(0,20);
 					title= title + "...";
 				}
 				// to avoid that the title is broken in the html: substitute blanks with &nbsp;
 				title= title.replaceAll(" ", "&nbsp;");
 				bcBean.setDisplayName(title);
 				relatedList.add(bcBean);
 				servletSession.setAttribute(DEIQSER_RELATED_LIST, relatedList);
 			}
 			req.setAttribute(PARAM_RELATED_LIST, relatedList);
 			searchInput= (String) servletSession.getAttribute(DEIQSER_SEARCH_FIELD);
 		}
 		else if( action!= null && action.startsWith(ACTION_SHOW_BREADCRUMB)) {
 			// reset selectedTypes to all types
 			Set<String> selectedTypes= (Set<String>) servletSession.getAttribute(DisplayPortlet.DEIQSER_SELECTED_TYPES);
 			if( selectedTypes != null) {
 				servletSession.removeAttribute(DEIQSER_SELECTED_TYPES);
 			}
 			// we need new data
 			BreadcrumbBean bcBean= null;
 			int relatedLevel= ParamUtil.getInteger(req, PARAM_RELATED_LEVEL);
 			List<BreadcrumbBean> relatedList= (List<BreadcrumbBean>) servletSession.getAttribute(DEIQSER_RELATED_LIST);
 			if( relatedList == null ) {
 				// possible after a refresh is performed when new  portlets are deployed
 				relatedList= new ArrayList<BreadcrumbBean>();
 				servletSession.setAttribute(DEIQSER_RELATED_LIST, relatedList);
 			}
 			else {
 				// remove data > relatedLevel from stack
 
 				// list should be initialized by search or tree portlet
 				List<BreadcrumbBean> newList= new ArrayList<BreadcrumbBean>();
 				for( int index= 0; index <= relatedLevel; index++) {
 					bcBean= relatedList.get(index);
 					newList.add(bcBean);
 				}
 				servletSession.setAttribute(DEIQSER_RELATED_LIST, newList);
 			}
 			PortletPreferences prefs= req.getPreferences();
 			String iqserWebserviceUrl= prefs.getValue(PREF_IQSER_WEBSERVICE, "");	
 			if( relatedLevel == 0 && bcBean != null) {
 				// user selected link identifying original search input
 				searchInput= bcBean.getId();
 				String maxResultsStr= prefs.getValue(PREF_MAX_RESULTS, "");
 				contentList= PortletIQserService.searchIQSER(iqserWebserviceUrl, searchInput, maxResultsStr);
 			}
 			else if( bcBean != null) {
 				// user selected a link containing related data ==> get id identifying the content
 				String idStr= bcBean.getId();
 				int id= -1;
 				try {
 					id= (new Integer(idStr)).intValue();
 				}
 				catch( NumberFormatException e) {
 					_ilog.error("invalid related id " + idStr);
 				}
 				String minScoreStr= prefs.getValue(PREF_MIN_SCORE, "");
 				contentList= PortletIQserService.searchIQSER_Related(iqserWebserviceUrl, id, minScoreStr);
 			}
 			else {
 				// no valid bean
 				contentList= new ArrayList<ContentBean>();
 			}
 			servletSession.setAttribute(DEIQSER_CACHED_DATA, contentList);
 			total= PortletIQserService.total(contentList);
 			//searchInput="related content: id=" + contentId;
 			req.setAttribute(PARAM_CONTENT_LIST, contentList);			
 
 		}
 		else {
 			// no filter, return full list
 			req.setAttribute(PARAM_CONTENT_LIST, contentList);
 		}
 		req.setAttribute(PARAM_SEARCH_INPUT, searchInput);
 		req.setAttribute(PARAM_CONTENT_TOTAL, new Integer(total));
 		SortedSet<String> allTypes= PortletIQserService.getAlltypes(contentList);
 		req.setAttribute(PARAM_CONTENT_TYPES, allTypes);
 		
 		reqDispatcher.include(req, res);
 	}
 	
 	// processAction is located in BasePortlet
 	// If more is needed, this can override this method
 	// the helper methods processActionUpdatePrefs and processActionInsertPref
 	public void processAction(ActionRequest req,
 			ActionResponse res) throws PortletException, IOException {
 		super.processAction(req, res);
 		String action = req.getParameter(PARAM_ACTION);
 		if( action == null || !action.equals(ACTION_PREVIEW)) {
 			return;
 		}
 		
 		// we want a preview
 		String contentId= req.getParameter(IqserBasePortlet.PARAM_ID);	// from action.jsp
 		String contentType= req.getParameter(IqserBasePortlet.PARAM_CONTENT_TYPE);	// from action.jsp
 		String contentProvider= req.getParameter(IqserBasePortlet.PARAM_CONTENT_PROVIDER);	// from action.jsp
 		
 		res.setRenderParameter(PUBLIC_RENDER_PARAM_CONTENT_ID, contentId);
 		res.setRenderParameter(PUBLIC_RENDER_PARAM_CONTENT_TYPE, contentType);
 		res.setRenderParameter(PUBLIC_RENDER_PARAM_CONTENT_PROVIDER, contentProvider);
 	}
 
 }