/*
-----------------------------------------------------------------------
--          			CHESS core plugin							 --
--                                                                   --
--                    Copyright (C) 2016                             --
--                 University of Padova, ITALY                       --
--                                                                   --
-- Authors: Alessandro Zovi          azovi@math.unipd.it             --
--          Laura Baracchi           laura.baracchi@intecs.it        --
--          Stefano Puri             stefano.puri@intecs.it          --
--                                                                   --
-- All rights reserved. This program and the accompanying materials  --
-- are made available under the terms of the Eclipse Public License  --
-- v1.0 which accompanies this distribution, and is available at     --
-- http://www.eclipse.org/legal/epl-v20.html                         --
-----------------------------------------------------------------------
*/

package org.polarsys.chess.core.internal.views;

import static org.polarsys.chess.core.internal.views.permissions.EntryId.ANY;
import static org.polarsys.chess.core.internal.views.permissions.EntryId.NONE;
import static org.polarsys.chess.core.internal.views.permissions.EntryId.anyEntry;

import java.io.File;
import java.net.URI;
import java.net.URL;
import java.util.HashMap;

import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;

import org.eclipse.core.runtime.FileLocator;
import org.eclipse.core.runtime.Path;
import org.polarsys.chess.chessmlprofile.Core.Domain;
import org.polarsys.chess.core.Activator;
import org.polarsys.chess.core.internal.views.permissions.EntryId;
import org.polarsys.chess.core.internal.views.permissions.PermissionEntry;
import org.polarsys.chess.core.internal.views.permissions.PermissionList;
import org.polarsys.chess.core.profiles.CHESSProfileManager;
import org.polarsys.chess.core.util.CHESSProjectSupport;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import org.xml.sax.SAXException;
import org.xml.sax.SAXParseException;

/**
 * This class parses the permissions.xml file and create the permissions structure.
 */
public class ViewPermissions {
	
	/** The permissions. */
	public static HashMap<String, HashMap<String, PermissionList>> permissions = new HashMap<String, HashMap<String, PermissionList>>();	
	
	/** The component view PL. */
	static PermissionList componentViewPL;
	
	/** The extra functional view PL. */
	static PermissionList extraFunctionalViewPL;
	
	/** The deployment view PL. */
	static PermissionList deploymentViewPL;
	
	/** The analysis view PL. */
	static PermissionList analysisViewPL;
	
	/** The requirement view PL. */
	static PermissionList requirementViewPL;
	
	/** The RT analysis view view PL. */
	static PermissionList RTAnalysisViewViewPL;
	
	/** The Dependability analysis view PL. */
	static PermissionList DependabilityAnalysisViewPL;
	
	/** The Dependability view PL. */
	static PermissionList DependabilityViewPL;
	
	/** The System view PL. */
	static PermissionList SystemViewPL;
	
	/** The PSM view. */
	static PermissionList PSMView;
	
	/** The allow all. */
	static PermissionEntry allowAll = new PermissionEntry(anyEntry, false, true, true, Domain.CROSS_DOMAIN);
	
	/**
	 * Initialize lists.
	 */
	public static void initializeLists(){
		/*componentViewPL = new PermissionList();
		extraFunctionalViewPL = new PermissionList();
		deploymentViewPL = new PermissionList();
		analysisViewPL = new PermissionList();
		requirementViewPL = new PermissionList();
		RTAnalysisViewViewPL = new PermissionList();
		DependabilityAnalysisViewPL = new PermissionList();
		DependabilityViewPL = new PermissionList();
		SystemViewPL = new PermissionList();
		PSMView = new PermissionList();*/
		
//		permissions.put(CHESSProfileManager.COMPONENT_VIEW,
//				ViewPermissions.componentViewPL);
//		permissions.put(CHESSProfileManager.EXTRAFUNCTIONAL_VIEW,
//				ViewPermissions.extraFunctionalViewPL);
//		permissions.put(CHESSProfileManager.ANALYSIS_VIEW,
//				ViewPermissions.analysisViewPL);
//		permissions.put(CHESSProfileManager.DEPLOYMENT_VIEW,
//				ViewPermissions.deploymentViewPL);
//		permissions.put(CHESSProfileManager.REQUIREMENT_VIEW,
//				ViewPermissions.requirementViewPL);
//		permissions.put(CHESSProfileManager.RT_ANALYSIS_VIEW,
//				ViewPermissions.RTAnalysisViewViewPL);
//		permissions.put(CHESSProfileManager.DEPENDABILITY_ANALYSIS_VIEW,
//				ViewPermissions.DependabilityAnalysisViewPL);
		
		permissions.put(CHESSProfileManager.COMPONENT_VIEW,
				new HashMap<String, PermissionList>());
		permissions.put(CHESSProfileManager.EXTRAFUNCTIONAL_VIEW,
				new HashMap<String, PermissionList>());
		permissions.put(CHESSProfileManager.ANALYSIS_VIEW,
				new HashMap<String, PermissionList>());
		permissions.put(CHESSProfileManager.DEPLOYMENT_VIEW,
				new HashMap<String, PermissionList>());
		permissions.put(CHESSProfileManager.REQUIREMENT_VIEW,
				new HashMap<String, PermissionList>());
		permissions.put(CHESSProfileManager.RT_ANALYSIS_VIEW,
				new HashMap<String, PermissionList>());
		permissions.put(CHESSProfileManager.DEPENDABILITY_ANALYSIS_VIEW,
				new HashMap<String, PermissionList>());
		permissions.put(CHESSProfileManager.DEPENDABILITY_VIEW,
				new HashMap<String, PermissionList>());
		permissions.put(CHESSProfileManager.RAILWAY_VIEW,
				new HashMap<String, PermissionList>());
		permissions.put(CHESSProfileManager.SYSTEM_VIEW,
				new HashMap<String, PermissionList>());
		permissions.put(CHESSProfileManager.PSM_VIEW,
				new HashMap<String, PermissionList>());
	}	
	
	static{
		initializeLists();
		CHESSProjectSupport.printlnToCHESSConsole("Load permissions...");
		readXMLPermissions();
		CHESSProjectSupport.printlnToCHESSConsole("Permissions loaded.");
//		//The allowAll policy should last until a list of actual permission is specified
//		componentViewPL.add(allowAll);
//		extraFunctionalViewPL.add(allowAll);
//		deploymentViewPL.add(allowAll);
//		analysisViewPL.add(allowAll);
//		requirementViewPL.add(allowAll);
//		RTAnalysisViewViewPL.add(allowAll);
//		DependabilityAnalysisViewPL.add(allowAll);
//		
//		//Examples
//		componentViewPL.add(new PermissionEntry(new EntryId("Package", ANY, ANY), true, true, true));
//		componentViewPL.add(new PermissionEntry(new EntryId(ANY, ANY, ANY), true, true, true));
//		componentViewPL.add(new PermissionEntry(new EntryId(ANY, ANY, "Operation"), true, true, true));
//		componentViewPL.add(new PermissionEntry(new EntryId(ANY, ANY, "Property"), true, true, true));
//		componentViewPL.add(new PermissionEntry( new EntryId(ANY, "CHRtSpecification", "relativePriority"), true, false, true));
	}
	
	
	/**
	 * Read XML permissions.
	 */
	public static void readXMLPermissions(){
	    try {

	    	URL url = FileLocator.find(Activator.getDefault().getBundle(), new Path("permissions.xml"), null);
	    	url = FileLocator.toFileURL(url);
	    	URI uri = new URI(url.getProtocol(), url.getHost(), url.getPath(), null);
            DocumentBuilderFactory docBuilderFactory = DocumentBuilderFactory.newInstance();
            DocumentBuilder docBuilder = docBuilderFactory.newDocumentBuilder();
            Document doc = docBuilder.parse (new File(uri));

            // normalize text representation
            doc.getDocumentElement ().normalize ();
            NodeList listOfViews = doc.getElementsByTagName("view");

            for(int s=0; s<listOfViews.getLength() ; s++){
                Node view = listOfViews.item(s);
                if(view.getNodeType() == Node.ELEMENT_NODE){
                    parseViewNode(view);
                }
            }

		} catch (SAXParseException err) {
			System.out.println("** Parsing error" + ", line "
					+ err.getLineNumber() + ", uri " + err.getSystemId());
			System.out.println(' ' + err.getMessage());
			
			CHESSProjectSupport.printlnToCHESSConsole("** Parsing error" + ", line "
					+ err.getLineNumber() + ", uri " + err.getSystemId());
			CHESSProjectSupport.printlnToCHESSConsole(' ' + err.getMessage());

		} catch (SAXException e) {
			Exception x = e.getException();
			((x == null) ? e : x).printStackTrace(CHESSProjectSupport.CHESS_CONSOLE_STREAM);
			((x == null) ? e : x).printStackTrace();
		} catch (Throwable t) {
			t.printStackTrace(CHESSProjectSupport.CHESS_CONSOLE_STREAM);
			t.printStackTrace();
		}
	}


	/**
	 * Parses the view node.
	 *
	 * @param view the view
	 */
	private static void parseViewNode(Node view) {
		
		NodeList permList = ((Element)view).getElementsByTagName("diagram");
		String viewName = ((Element)view).getAttribute("name");
		for (int i=0; i<permList.getLength(); i++){
			Node dg = permList.item(i);
			if(dg.getNodeType() == Node.ELEMENT_NODE){
				PermissionList list = parseDiagramNode(dg);
//				PermissionEntry p = createPermission((Element) perm);
//				permissions.get(((Element)view).getAttribute("name")).add(p);
				
				String dgName = ((Element)dg).getAttribute("name");
				addDiagramPermissions(viewName, dgName, list);
			}
		}
//		NodeList permList = ((Element)view).getElementsByTagName("perm");
//		for (int i=0; i<permList.getLength(); i++){
//			Node perm = permList.item(i);
//			if(perm.getNodeType() == Node.ELEMENT_NODE){
//				PermissionEntry p = createPermission((Element) perm);
//				permissions.get(((Element)view).getAttribute("name")).add(p);
//			}
//		}
	}
	
	/**
	 * Adds the diagram permissions.
	 *
	 * @param view the view
	 * @param dg the dg
	 * @param list the list
	 */
	private static void addDiagramPermissions(String view, String dg,
			PermissionList list) {
		permissions.get(view).put(dg, list);
	}


	/**
	 * Parses the diagram node.
	 *
	 * @param dg the dg
	 * @return the permission list
	 */
	private static PermissionList parseDiagramNode(Node dg) {
		NodeList permList = ((Element)dg).getElementsByTagName("perm");
		PermissionList list = new PermissionList();
		for (int i=0; i<permList.getLength(); i++){
			Node perm = permList.item(i);
			if(perm.getNodeType() == Node.ELEMENT_NODE){
				PermissionEntry p = createPermission((Element) perm);
				list.add(p);
//				permissions.get(((Element)view).getAttribute("name")).add(p);
			}
		}
		return list;
	}

	/**
	 * Creates the permission.
	 *
	 * @param perm the perm
	 * @return the permission entry
	 */
	private static PermissionEntry createPermission(Element perm) {
		String id1 = parseIdValue(perm.getAttribute(EntryId.TYPE_ATR));
		String id2 = parseIdValue(perm.getAttribute(EntryId.STEREOTYPE_ATR));
		String id3 = parseIdValue(perm.getAttribute(EntryId.FEATURE_ATR));
		EntryId id = new EntryId(id1, id2, id3);
		boolean o = parsePermissionRight(perm.getAttribute(PermissionEntry.OWNER_ATR));
		boolean w = parsePermissionRight(perm.getAttribute(PermissionEntry.WRITE_ATR));
		boolean v = parsePermissionRight(perm.getAttribute(PermissionEntry.VISIBLE_ATR));
		
		Domain d = parseDomain(perm.getAttribute(PermissionEntry.DOMAIN_ATR));		
		
		return new PermissionEntry(id, o, w, v, d);
	}

	/**
	 * Parses the permission right.
	 *
	 * @param attr the attr
	 * @return true, if successful
	 */
	private static boolean parsePermissionRight(String attr) {
		if (attr.equalsIgnoreCase("true"))
			return true;
		// if (attr.isEmpty() || attr.equalsIgnoreCase("false"))
		return false;
	}

	/**
	 * Parses the domain.
	 *
	 * @param attr the attr
	 * @return the domain
	 */
	private static Domain parseDomain(String attr) {	
		
		if (attr.equalsIgnoreCase(Domain.AUTOMOTIVE.getName()))
			return Domain.AUTOMOTIVE;
		if (attr.equalsIgnoreCase(Domain.AVIONICS.getName()))
			return Domain.AVIONICS;
		if (attr.equalsIgnoreCase(Domain.CROSS_DOMAIN.getName()))
			return Domain.CROSS_DOMAIN;
		if (attr.equalsIgnoreCase(Domain.MEDICAL.getName()))
			return Domain.MEDICAL;
		if (attr.equalsIgnoreCase(Domain.PETROLEUM.getName()))
			return Domain.PETROLEUM;
		if (attr.equalsIgnoreCase(Domain.SPACE.getName()))
			return Domain.SPACE;
		if (attr.equalsIgnoreCase(Domain.TELECOM.getName()))
			return Domain.TELECOM;
		// Default domain is CROSS_DOMAIN
		return Domain.CROSS_DOMAIN;
	}
	
	/**
	 * Parses the id value.
	 *
	 * @param attr the attr
	 * @return the string
	 */
	private static String parseIdValue(String attr) {
		if (attr.equals("-"))
			return NONE;
		if (attr.isEmpty() || attr.equals("*"))
			return ANY;
		return attr;
	}
}