package org.gcube.portlets.admin.systemservicedefinition;

import java.io.IOException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Enumeration;
import java.util.UUID;

import javax.portlet.ActionRequest;
import javax.portlet.ActionResponse;
import javax.portlet.PortletException;
import javax.portlet.RenderRequest;
import javax.portlet.RenderResponse;
import javax.portlet.ResourceRequest;
import javax.portlet.ResourceResponse;
import javax.servlet.http.HttpServletRequest;

import org.gcube.portlets.admin.systemservicedefinition.definition.DefClientIdComparator;
import org.gcube.portlets.admin.systemservicedefinition.definition.DefDescriptionComparator;
import org.gcube.portlets.admin.systemservicedefinition.definition.DefinitionItem;
import org.gcube.portlets.admin.systemservicedefinition.event.CreateSSDEvent;
import org.gcube.portlets.admin.systemservicedefinition.event.CreateSSDEventPublisher;
import org.gcube.portlets.admin.systemservicedefinition.util.UserCredentials;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import com.liferay.portal.kernel.json.JSONArray;
import com.liferay.portal.kernel.json.JSONFactoryUtil;
import com.liferay.portal.kernel.json.JSONObject;
import com.liferay.portal.kernel.servlet.ServletResponseUtil;
import com.liferay.portal.kernel.servlet.SessionErrors;
import com.liferay.portal.kernel.servlet.SessionMessages;
import com.liferay.portal.kernel.util.ParamUtil;
import com.liferay.portal.util.PortalUtil;
import com.liferay.util.bridges.mvc.MVCPortlet;

/**
 * 
 * @author Giancarlo Panichi
 * 
 *         Portlet implementation class SystemServiceDefinition
 * 
 */
public class SystemServiceDefinition extends MVCPortlet {
	private static Logger logger = LoggerFactory.getLogger(SystemServiceDefinition.class);

	private void paramsInfo(ActionRequest actionRequest) {
		HttpServletRequest httpRequest = PortalUtil.getHttpServletRequest(actionRequest);
		paramsInfo(httpRequest);

	}

	private void paramsInfo(ResourceRequest resourceRequest) {
		HttpServletRequest httpRequest = PortalUtil.getHttpServletRequest(resourceRequest);
		paramsInfo(httpRequest);

	}

	private void paramsInfo(HttpServletRequest httpRequest) {

		HttpServletRequest hsrequest = PortalUtil.getOriginalServletRequest(httpRequest);
		String queryString = hsrequest.getQueryString();
		logger.debug("Query: " + queryString);

		logger.debug("Params Info");
		for (@SuppressWarnings("unchecked")
		Enumeration<String> e = (Enumeration<String>) httpRequest.getParameterNames(); e.hasMoreElements();) {
			String key = e.nextElement();
			String[] v = httpRequest.getParameterValues(key);
			ArrayList<String> values = new ArrayList<String>(Arrays.asList(v));
			StringBuilder parms = new StringBuilder();
			parms.append("Parameter: ");
			parms.append(key);
			parms.append(" - ");
			parms.append(values);
			logger.debug(parms.toString());
		}

	}

	@Override
	public void render(RenderRequest renderRequest, RenderResponse renderResponse)
			throws PortletException, IOException {
		// GroupManager gm = new LiferayGroupManager();
		try {
			UserCredentials userCredentials = SessionUtil.getUserCredentials(renderRequest);
			logger.debug("Render requested from user: {}", userCredentials);

			/*
			 * String mvcPath = renderRequest.getParameter("mvcPath");
			 * 
			 * if (mvcPath == null || mvcPath.isEmpty()) { mvcPath =
			 * "/html/systemservicedefinition/view.jsp"; } PortletRequestDispatcher
			 * dispatcher = getPortletContext().getRequestDispatcher(mvcPath);
			 * dispatcher.include(renderRequest, renderResponse);
			 */

			/*
			 * List<GCubeGroup> userGroups =
			 * gm.listGroupsByUser(userCredentials.getUserId()); List<String> userContexts =
			 * new ArrayList<String>(); for (GCubeGroup g : userGroups) { if
			 * (g.getGroupName().equals(PortalContext.getConfiguration().
			 * getInfrastructureName())) { String context =
			 * gm.getInfrastructureScope(g.getGroupId()); userContexts.add(context); } if
			 * (g.getParentGroupId() > 0) { String context =
			 * gm.getInfrastructureScope(g.getGroupId()); userContexts.add(context); } }
			 * renderRequest.setAttribute("userGroups", userGroups);
			 * renderRequest.setAttribute("userContexts", userContexts);
			 */
		} catch (Exception e) {
			logger.error(e.getLocalizedMessage(), e);
		}
		super.render(renderRequest, renderResponse);
	}

	@Override
	public void serveResource(ResourceRequest resourceRequest, ResourceResponse resourceResponse)
			throws IOException, PortletException {

		UserCredentials userCredentials;
		try {
			userCredentials = SessionUtil.getUserCredentials(resourceRequest);
		} catch (Exception e) {
			logger.error(e.getLocalizedMessage(), e);
			JSONObject jsonObject = JSONFactoryUtil.createJSONObject();
			jsonObject.put("success", false);
			jsonObject.put("comment", "Error retrieving user credentials: " + e.getLocalizedMessage());
			resourceResponse.getWriter().println(jsonObject);
			super.serveResource(resourceRequest, resourceResponse);
			return;
		}

		paramsInfo(resourceRequest);

		String opType = ParamUtil.getString(resourceRequest, "operationType", null);
		OperationType operationType = OperationType.getTypeFromString(opType);
		if (operationType == null) {
			logger.error("Invalid Operation Type Requested: null");
			JSONObject jsonObject = JSONFactoryUtil.createJSONObject();
			jsonObject.put("success", false);
			jsonObject.put("comment", "Invalid Operation Type Requested: null");
			resourceResponse.getWriter().println(jsonObject);
			super.serveResource(resourceRequest, resourceResponse);
			return;
		}

		switch (operationType) {
		case TableInteraction:
			tableInteraction(resourceRequest, resourceResponse, userCredentials);
			break;
		default:
			logger.error("Invalid Operation Type Requested: {}", operationType);
			JSONObject jsonObject = JSONFactoryUtil.createJSONObject();
			jsonObject.put("success", false);
			jsonObject.put("comment", "Invalid Operation Type Requested: " + operationType);
			resourceResponse.getWriter().println(jsonObject);
			super.serveResource(resourceRequest, resourceResponse);
			break;

		}
	}

	private void tableInteraction(ResourceRequest resourceRequest, ResourceResponse resourceResponse,
			UserCredentials userCredentials) throws IOException {

		String searchValue = ParamUtil.getString(resourceRequest, "search[value]");
		int start = ParamUtil.getInteger(resourceRequest, "start");
		int length = ParamUtil.getInteger(resourceRequest, "length");
		int draw = ParamUtil.getInteger(resourceRequest, "draw");
		int orderColumn = ParamUtil.getInteger(resourceRequest, "order[0][column]");
		String orderDirection = ParamUtil.getString(resourceRequest, "order[0][dir]");

		listItems(resourceRequest, resourceResponse, userCredentials, start, length, searchValue, draw, orderColumn,
				orderDirection);

	}

	private void listItems(ResourceRequest request, ResourceResponse resourceResponse, UserCredentials userCredentials,
			int start, int length, String searchValue, int draw,int orderColumn, String orderDirection) throws IOException {
		StringBuilder tableRequested = new StringBuilder();
		tableRequested.append("Table requested [start=");
		tableRequested.append(start);
		tableRequested.append(", lenght=");
		tableRequested.append(length);
		tableRequested.append(", searchValue=");
		tableRequested.append(searchValue);
		tableRequested.append(", draw=");
		tableRequested.append(draw);
		tableRequested.append(", orderColumn=");
		tableRequested.append(orderColumn);
		tableRequested.append(", orderDirection=");
		tableRequested.append(orderDirection);
		tableRequested.append("]");
		logger.debug(tableRequested.toString());
		
		
		//Create
		ArrayList<DefinitionItem> itemsList = new ArrayList<>();

		for (int i = 0; i < 10; i++) {
			DefinitionItem definitionItem = new DefinitionItem("client_id_" + i, "description_" + i, "xxxx_" + i);
			itemsList.add(definitionItem);

		}

		int count = itemsList.size();

		//Filter
		ArrayList<DefinitionItem> filteredItemsList = new ArrayList<>();
		if (searchValue != null && !searchValue.isEmpty()) {
			for (DefinitionItem definitionItem : itemsList) {
				if (definitionItem.getClientId().contains(searchValue)) {
					filteredItemsList.add(definitionItem);
				}
			}
			itemsList.clear();
			itemsList.addAll(filteredItemsList);
		}

		int recordsFiltered = itemsList.size();
		
		//Order
		reorderData(orderColumn, orderDirection, itemsList);
		
		//Create data Window
	    if (start > recordsFiltered) {
			start = recordsFiltered;
		}

		int limit = 0;
		if (start + length > recordsFiltered) {
			limit = recordsFiltered;
		} else {
			limit = start + length;
		}

		ArrayList<DefinitionItem> windowItemsList = new ArrayList<>();
		for (int i = start; i < limit; i++) {
			windowItemsList.add(itemsList.get(i));
		}

		JSONObject tableData = buildJSONResponse(windowItemsList, start, length, draw, count, recordsFiltered, request);
		ServletResponseUtil.write(PortalUtil.getHttpServletResponse(resourceResponse), tableData.toString());

	}

	private void reorderData(int orderColumn, String orderDirection, ArrayList<DefinitionItem> itemsList) {
		switch (orderColumn) {
		case 0:
			if(orderDirection!=null&&orderDirection.compareTo("asc")==0) {
				Collections.sort(itemsList, Collections.reverseOrder(new DefClientIdComparator()));
			} else {
				Collections.sort(itemsList, new DefClientIdComparator());
			}
			break;
		case 1:
			if(orderDirection!=null&&orderDirection.compareTo("asc")==0) {
				Collections.sort(itemsList, Collections.reverseOrder(new DefDescriptionComparator()));
			} else {
				Collections.sort(itemsList, new DefDescriptionComparator());
			}
			break;
		default:
			break;
		}
	}

	/**
	 * 
	 * @param itemsList
	 * @param start
	 * @param lenght
	 * @param draw
	 * @param count
	 * @param request
	 * @return the JSON response to the client
	 */
	private JSONObject buildJSONResponse(ArrayList<DefinitionItem> itemsList, int start, int lenght, int draw,
			int count, int recordsFiltered, ResourceRequest request) {
		JSONArray definitionsArray = JSONFactoryUtil.createJSONArray();
		for (DefinitionItem item : itemsList) {
			JSONObject definitionObject = JSONFactoryUtil.createJSONObject();
			definitionObject.put("ClientId", item.getClientId());
			definitionObject.put("Description", item.getDescription());
			definitionsArray.put(definitionObject);
		}

		JSONObject tableData = JSONFactoryUtil.createJSONObject();
		tableData.put("messages", "Read Done!");
		tableData.put("data", definitionsArray);
		tableData.put("start", start);
		tableData.put("lenght", lenght);
		tableData.put("draw", draw);
		tableData.put("recordsTotal", count);
		tableData.put("recordsFiltered", recordsFiltered);
		logger.debug("tableData:" + tableData.toString());
		return tableData;
	}

	public void createDefinition(ActionRequest actionRequest, ActionResponse actionResponse) throws Exception {
		@SuppressWarnings("unused")
		UserCredentials userCredentials;

		try {
			userCredentials = SessionUtil.getUserCredentials(actionRequest);
		} catch (Exception e) {
			logger.error(e.getLocalizedMessage(), e);
			// actionResponse.addProperty("message", "Error!");
			SessionErrors.add(actionRequest, "error-session");
			SessionMessages.add(actionRequest,
					PortalUtil.getPortletId(actionRequest) + SessionMessages.KEY_SUFFIX_HIDE_DEFAULT_ERROR_MESSAGE);
			actionResponse.setRenderParameter("jspPage", "/html/systemservicedefinition/view.jsp");
			return;
		}

		paramsInfo(actionRequest);

		String act = ParamUtil.getString(actionRequest, "act");
		if (act == null) {
			SessionErrors.add(actionRequest, "error-create-definition");
			SessionMessages.add(actionRequest,
					PortalUtil.getPortletId(actionRequest) + SessionMessages.KEY_SUFFIX_HIDE_DEFAULT_ERROR_MESSAGE);
			actionResponse.setRenderParameter("jspPage", "/html/systemservicedefinition/view.jsp");
			return;
		}
		switch (act) {
		case "submit":
			logger.debug("Submit Request");
			String clientId = ParamUtil.getString(actionRequest, "clientId");
			if (clientId == null || clientId.isEmpty()) {
				logger.error("Invalid client id: " + clientId);
				SessionErrors.add(actionRequest, "error-invalid-clientId");
				SessionMessages.add(actionRequest,
						PortalUtil.getPortletId(actionRequest) + SessionMessages.KEY_SUFFIX_HIDE_DEFAULT_ERROR_MESSAGE);
				PortalUtil.copyRequestParameters(actionRequest, actionResponse);
				actionResponse.setRenderParameter("jspPage", "/html/systemservicedefinition/ssd_create.jsp");
				break;
			}
			String description = ParamUtil.getString(actionRequest, "description");
			if (description == null || description.isEmpty()) {
				logger.error("Invalid description: " + description);
				SessionErrors.add(actionRequest, "error-invalid-description");
				SessionMessages.add(actionRequest,
						PortalUtil.getPortletId(actionRequest) + SessionMessages.KEY_SUFFIX_HIDE_DEFAULT_ERROR_MESSAGE);
				PortalUtil.copyRequestParameters(actionRequest, actionResponse);
				actionResponse.setRenderParameter("jspPage", "/html/systemservicedefinition/ssd_create.jsp");
				break;
			}
			logger.debug("Requested: [clientId={}, description={}]", clientId, description);
			String secret = UUID.randomUUID().toString();
			String encryptedSecret = null; // StringEncrypter.getEncrypter().encrypt(secret);
			DefinitionItem definitionItem = new DefinitionItem(clientId, description, secret);
			
			
			// publishCreateSSDEvent(definitionItem);
			SessionMessages.add(actionRequest, "success-definition-created");
			actionResponse.setRenderParameter("jspPage", "/html/systemservicedefinition/view.jsp");
			break;
		case "cancel":
			logger.debug("Cancel Request");
			SessionMessages.clear(actionRequest);
			actionResponse.setRenderParameter("jspPage", "/html/systemservicedefinition/view.jsp");
			break;
		default:
			logger.debug("Default");
			SessionErrors.add(actionRequest, "error-create-definition");
			SessionMessages.add(actionRequest,
					PortalUtil.getPortletId(actionRequest) + SessionMessages.KEY_SUFFIX_HIDE_DEFAULT_ERROR_MESSAGE);
			actionResponse.setRenderParameter("jspPage", "/html/systemservicedefinition/view.jsp");
			break;
		}

	}

	private void publishCreateSSDEvent(DefinitionItem definitionItem) {
		logger.debug("Trying to send the event to create System Service");
		CreateSSDEvent toSend = new CreateSSDEvent(definitionItem);
		new CreateSSDEventPublisher().publish(toSend);
		logger.info("Done send event " + toSend.getName() + " for " + toSend.getUser());
		try {
			Thread.sleep(2000);
		} catch (InterruptedException e) {

		}
	}

	public void editDefinition(ActionRequest actionRequest, ActionResponse actionResponse) throws Exception {
		@SuppressWarnings("unused")
		UserCredentials userCredentials;

		try {
			userCredentials = SessionUtil.getUserCredentials(actionRequest);
		} catch (Exception e) {
			logger.error(e.getLocalizedMessage(), e);
			SessionErrors.add(actionRequest, "error-session");
			SessionMessages.add(actionRequest,
					PortalUtil.getPortletId(actionRequest) + SessionMessages.KEY_SUFFIX_HIDE_DEFAULT_ERROR_MESSAGE);
			actionResponse.setRenderParameter("jspPage", "/html/systemservicedefinition/view.jsp");
			return;
		}

		paramsInfo(actionRequest);

		String act = ParamUtil.getString(actionRequest, "act");
		if (act == null) {
			SessionErrors.add(actionRequest, "error-edit-definition");
			SessionMessages.add(actionRequest,
					PortalUtil.getPortletId(actionRequest) + SessionMessages.KEY_SUFFIX_HIDE_DEFAULT_ERROR_MESSAGE);
			actionResponse.setRenderParameter("jspPage", "/html/systemservicedefinition/view.jsp");
			return;
		}
		switch (act) {
		case "submit":
			SessionMessages.add(actionRequest, "success-definition-updated");
			actionResponse.setRenderParameter("jspPage", "/html/systemservicedefinition/view.jsp");
			break;
		case "cancel":
			SessionMessages.clear(actionRequest);
			actionResponse.setRenderParameter("jspPage", "/html/systemservicedefinition/view.jsp");
			break;
		default:
			SessionErrors.add(actionRequest, "error-create-definition");
			SessionMessages.add(actionRequest,
					PortalUtil.getPortletId(actionRequest) + SessionMessages.KEY_SUFFIX_HIDE_DEFAULT_ERROR_MESSAGE);
			actionResponse.setRenderParameter("jspPage", "/html/systemservicedefinition/view.jsp");
			break;
		}

	}

	public void deleteDefinition(ActionRequest actionRequest, ActionResponse actionResponse) throws Exception {
		@SuppressWarnings("unused")
		UserCredentials userCredentials;

		try {
			userCredentials = SessionUtil.getUserCredentials(actionRequest);
		} catch (Exception e) {
			logger.error(e.getLocalizedMessage(), e);
			SessionErrors.add(actionRequest, "error-session");
			SessionMessages.add(actionRequest,
					PortalUtil.getPortletId(actionRequest) + SessionMessages.KEY_SUFFIX_HIDE_DEFAULT_ERROR_MESSAGE);
			actionResponse.setRenderParameter("jspPage", "/html/systemservicedefinition/view.jsp");
			return;
		}

		paramsInfo(actionRequest);

		SessionMessages.add(actionRequest, "success-definition-deleted");
		actionResponse.setRenderParameter("jspPage", "/html/systemservicedefinition/view.jsp");

		/*
		 * SessionErrors.add(actionRequest, "error-delete-definition");
		 * SessionMessages.add(actionRequest, PortalUtil.getPortletId(actionRequest) +
		 * SessionMessages.KEY_SUFFIX_HIDE_DEFAULT_ERROR_MESSAGE);
		 * actionResponse.setRenderParameter("jspPage",
		 * "/html/systemservicedefinition/view.jsp");
		 */

		/*
		 * String portletName = (String)actionRequest.getAttribute(WebKeys.PORTLET_ID);
		 * ThemeDisplay themeDisplay =
		 * (ThemeDisplay)actionRequest.getAttribute(WebKeys.THEME_DISPLAY);
		 * 
		 * PortletURL redirectURL =
		 * PortletURLFactoryUtil.create(PortalUtil.getHttpServletRequest(actionRequest),
		 * portletName,themeDisplay.getLayout().getPlid(), PortletRequest.RENDER_PHASE);
		 * redirectURL.setParameter("jspPage", "/registration.jsp");
		 * SessionErrors.add(actionRequest, "WRONG_FIRST_NAME_ERROR");
		 * actionResponse.sendRedirect(redirectURL.toString());
		 */

	}

	/*
	 * private void createDefinition(ResourceRequest resourceRequest,
	 * ResourceResponse resourceResponse, UserCredentials userCredentials) throws
	 * IOException, PortletException {
	 * 
	 * HttpServletRequest httpReq = PortalUtil
	 * .getOriginalServletRequest(PortalUtil.getHttpServletRequest(resourceRequest))
	 * ; JWTToken umaToken = null; try { umaToken = OIDCUmaUtil.getUMAToken(httpReq,
	 * userCredentials.getUsername(), userCredentials.getCurrentScope()); } catch
	 * (Exception e) { logger.error(e.getLocalizedMessage(), e); JSONObject
	 * jsonObject = JSONFactoryUtil.createJSONObject(); jsonObject.put("success",
	 * false); jsonObject.put("comment", e.getLocalizedMessage());
	 * resourceResponse.getWriter().println(jsonObject);
	 * super.serveResource(resourceRequest, resourceResponse); } String toReturn =
	 * umaToken.getAccessTokenString();
	 * resourceResponse.setContentType("application/json"); JSONObject jsonObject =
	 * JSONFactoryUtil.createJSONObject(); jsonObject.put("success", true);
	 * jsonObject.put("comment", toReturn);
	 * resourceResponse.getWriter().println(jsonObject);
	 * super.serveResource(resourceRequest, resourceResponse);
	 * 
	 * }
	 */

	/*
	 * if (isValidForm(firstName, lastName)) { String portletName =
	 * (String)actionRequest.getAttribute(WebKeys.PORTLET_ID); ThemeDisplay
	 * themeDisplay =
	 * (ThemeDisplay)actionRequest.getAttribute(WebKeys.THEME_DISPLAY);
	 * 
	 * PortletURL redirectURL =
	 * PortletURLFactoryUtil.create(PortalUtil.getHttpServletRequest(actionRequest),
	 * portletName,themeDisplay.getLayout().getPlid(), PortletRequest.RENDER_PHASE);
	 * redirectURL.setParameter("jspPage", "/registration.jsp");
	 * SessionErrors.add(actionRequest, "WRONG_FIRST_NAME_ERROR");
	 * actionResponse.sendRedirect(redirectURL.toString());
	 * 
	 * }else{ actionRequest.setAttribute("firstNameAtr", firstName);
	 * actionRequest.setAttribute("lastNameAtr", lastName);
	 * 
	 * actionResponse.setRenderParameter("jspPage", "/registration.jsp"); }
	 */

}