package src;
import java.io.File;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;

import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.DocumentBuilder;
import org.w3c.dom.Document;
import org.w3c.dom.NodeList;
import org.w3c.dom.Node;
import org.w3c.dom.Element;

public class Parser {
	private File inputFile;
	private Document xmlDocument;

	public Parser(String filename) {
		try {
			this.inputFile = new File(filename);
			DocumentBuilderFactory dbFactory = DocumentBuilderFactory.newInstance();
			DocumentBuilder dBuilder = dbFactory.newDocumentBuilder();
			xmlDocument = dBuilder.parse(this.inputFile);
			this.xmlDocument.getDocumentElement().normalize();
		} catch (Exception e) {

		}
	}

	public List<HashMap<String,Object>> parseCourses() {
		NodeList courseList = xmlDocument.getElementsByTagName("course");

		List<HashMap<String,Object>> courses = new ArrayList<HashMap<String,Object>>();
		for (int course = 0; course < courseList.getLength(); course++) {
			Node courseNode = courseList.item(course);
			Element courseNodeElement = (Element) courseNode;

			String courseName = courseNodeElement.getAttribute("name");
            String courseId = courseNodeElement.getAttribute("id");

            List<HashMap<String,Object>> groups = new ArrayList<HashMap<String,Object>>();
            NodeList children = courseNode.getChildNodes();
            for (int courseChild = 0; courseChild < children.getLength(); courseChild++) {
            	Node maybeGroupNode = children.item(courseChild);
            	if (maybeGroupNode.getNodeName().equalsIgnoreCase("group")) {
            		HashMap<String,Object> groupMap = parseGroup(maybeGroupNode);
            		groups.add(groupMap);
            	}
            }

            HashMap<String,Object> courseMap = new HashMap<String,Object>();
            courseMap.put("groups", groups);
    		courseMap.put("courseName", courseName);
            courseMap.put("courseId", courseId);
    		courses.add(courseMap);
		}

		return courses;
	}

	public HashMap<String,Object> parseGroup(Node groupNode) {
		Element groupNodeElement = (Element)groupNode;
		String groupTeacher = groupNodeElement.getAttribute("teacher");
		String groupNoStudent = groupNodeElement.getAttribute("number_of_students");
		String groupId = groupNodeElement.getAttribute("id");
		Boolean sameRoom = true;

		List<HashMap<String,Object>> sessions = new ArrayList<HashMap<String,Object>>();
		NodeList children = groupNode.getChildNodes();
		for (int sessionChild = 0; sessionChild < children.getLength(); sessionChild++) {
			Node maybeSessionNode = children.item(sessionChild);
			if(maybeSessionNode.getNodeName().equalsIgnoreCase("session")){
				HashMap<String,Object> sessionMap = parseSession(maybeSessionNode);
				if (!checkSameRoom(sessions, sessionMap)) {
					sameRoom = false;
				}

				sessions.add(sessionMap);
			}
		}

		HashMap<String,Object> groupMap = new HashMap<String,Object>();
		groupMap.put("groupTeacher", groupTeacher);
		groupMap.put("groupId", groupId);
		groupMap.put("groupNoStudent", Integer.parseInt(groupNoStudent.trim()));
		groupMap.put("sameRoom", sameRoom);
		groupMap.put("sessions", sessions);

		return groupMap;
	}

	private boolean checkSameRoom(List<HashMap<String,Object>> sessions, HashMap<String,Object> sessionMap) {
		boolean sameRoom = true;
		for (HashMap<String,Object> otherSession : sessions) {
			// passa pelas outras sessions, procurando por alguma com features diferentes
			if (sessionMap.get("roomFeaturesNeeded") != null) {
				if (otherSession.get("roomFeaturesNeeded") != null) {
					List<Integer> features = (List<Integer>)otherSession.get("roomFeaturesNeeded");
					boolean sameFeat = sameFeatures(features, (List<Integer>)sessionMap.get("roomFeaturesNeeded"));
					//System.out.println(features);
					//System.out.println((List<Integer>)sessionMap.get("roomFeaturesNeeded"));

					if (!sameFeat) {
						System.out.println("SAME ROOM : FALSE");
						sameRoom = false;
					}
				} else {
					sameRoom = false;
				}
			} else {
				if (otherSession.get("roomFeaturesNeeded") != null) {
					sameRoom = false;
				}
			}
		}

		return sameRoom;
	}

	public boolean sameFeatures(List<Integer> listA, List<Integer> listB) {
		if (listA.size() != listB.size()) {
			return false;
		}

		for (Integer a : listA) {
			if (!listB.contains(a)) {
				return false;
			}
		}

		return true;
	}

	public HashMap<String,Object> parseSession(Node sessionNode) {
		Element sessionNodeElement = (Element)sessionNode;

		String duration = sessionNodeElement.getAttribute("duration");
		String requiresBuildingId = sessionNodeElement.getAttribute("requires_building_id");
		String requiresRoomId = sessionNodeElement.getAttribute("requires_room_id");
		String startTime = sessionNodeElement.getAttribute("start_time");
		Integer weekDay = Integer.parseInt(sessionNodeElement.getAttribute("weekday"));

		if (!this.validateWeekDay(weekDay)) {
			throw new IllegalArgumentException("Weekday is invalid");
		}

		// aloca um hashmap com os dados da session
		HashMap<String,Object> sessionMap = new HashMap<String,Object>();
		if (!duration.isEmpty()) {
			String roomFeatures = sessionNodeElement.getAttribute("feature_ids");
			sessionMap.put("roomFeaturesNeeded", parseFeatures(roomFeatures));
		}

		if (duration != "") {
			sessionMap.put("duration", Integer.parseInt(duration));
		} else {
			sessionMap.put("duration", 0);
		}

		sessionMap.put("requiresBuildingId", requiresBuildingId);
		sessionMap.put("requiresRoomId", requiresRoomId);
		sessionMap.put("weekDay", weekDay);
		sessionMap.put("startTime", startTime);

		return sessionMap;
	}

	private ArrayList<Integer> parseFeatures(String featuresString) {
		ArrayList<Integer> featuresIds = new ArrayList<Integer>();
		for (String featureString : featuresString.split(",")) {
			if (!featureString.isEmpty()) {
				featuresIds.add(Integer.parseInt(featureString.trim()));
			}
		}

		return featuresIds;
	}

	private boolean validateWeekDay(Integer weekDay) {
		return (weekDay > 0 && weekDay < 6);
	}

	public List<HashMap<String,Object>> parseBuildings() {
		List<HashMap<String,Object>> buildings = new ArrayList<HashMap<String,Object>>();

        NodeList buildingList = this.xmlDocument.getElementsByTagName("building");
        for (int building = 0; building < buildingList.getLength(); building++){
        	Node buildingNode = buildingList.item(building);
        	buildings.add(parseBuilding(buildingNode));
        }

		return buildings;
	}

	public HashMap<String,Object> parseBuilding(Node buildingNode) {
		Element buildingNodeElement = (Element)buildingNode;
   	 	String buildingId = buildingNodeElement.getAttribute("id");

   	 	List<HashMap<String,Object>> rooms = new ArrayList<HashMap<String,Object>>();
		NodeList children = buildingNode.getChildNodes();
        for (int buildingChild = 0; buildingChild < children.getLength(); buildingChild++) {
        	Node maybeRoomNode = children.item(buildingChild);
        	if (maybeRoomNode.getNodeName().equalsIgnoreCase("room")) {
        		HashMap<String,Object> roomMap = parseRoom(maybeRoomNode);
        		if (roomMap.get("available") != "false") {
        			rooms.add(roomMap);
        		}
        	}
        }

   	 	HashMap<String,Object> buildingMap = new HashMap<String,Object>();
   	 	buildingMap.put("buildingId", buildingId);
   	 	buildingMap.put("rooms", rooms);

        return buildingMap;
	}

	public HashMap<String,Object> parseRoom(Node roomNode) {
		Element roomNodeElement = (Element)roomNode;
		String available = roomNodeElement.getAttribute("available_for_allocation");
		String roomId = roomNodeElement.getAttribute("id");
		String roomFeatures = roomNodeElement.getAttribute("feature_ids");
		String roomNoPlaces = roomNodeElement.getAttribute("number_of_places");

		ArrayList<Integer> roomFeaturesIds = parseFeatures(roomFeatures);
		HashMap<String,Object> roomMap = new HashMap<String,Object>();
		roomMap.put("roomId", roomId);
		roomMap.put("available", available);
		roomMap.put("roomFeatureIds", roomFeaturesIds);
		if (roomNoPlaces != "") {
			roomMap.put("roomNoPlaces", Integer.parseInt(roomNoPlaces));
		} else {
			roomMap.put("roomNoPlaces", 0);
		}

		return roomMap;
	}

}