BggToolAnother/xyz.veronie.bgg.ui/src/xyz/veronie/bgg/result/BggApi.java

package xyz.veronie.bgg.result;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.StringReader;
import java.io.UnsupportedEncodingException;
import java.net.HttpURLConnection;
import java.net.MalformedURLException;
import java.net.URL;
import java.net.URLEncoder;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.Map.Entry;
import java.util.Set;

import javax.inject.Inject;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;

import org.eclipse.e4.core.di.annotations.Creatable;
import org.eclipse.e4.core.services.events.IEventBroker;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import org.xml.sax.InputSource;
import org.xml.sax.SAXException;

import xyz.veronie.bgg.types.EventConstants;
import xyz.veronie.bgg.types.FamilyType;
import xyz.veronie.bgg.types.FilterFlagState;
import xyz.veronie.bgg.types.SourceFilter;
import xyz.veronie.bgg.types.Subtype;
import xyz.veronie.bgg.types.UserFlag;

@Creatable
public class BggApi {

	@Inject private ResultConfigManager configManager;
	@Inject private IEventBroker eventBroker;
	
	public static String BASE_URL = "https://www.boardgamegeek.com/xmlapi2/";
	public static String USER = "user";
	public static String COLLECTION = "collection";
	public static String SEARCH = "search";
	public static String FAMILY = "family";
	public static String GEEKLIST = "geeklist";
	
	private static int RETRIES = 5;
	
	public ArrayList<Thing> getThings(SourceFilter source, Object id) {
		switch(source) {
		default:
		case BGG_USER:
			return getThingsForUser((String)id);
		case FAMILY:
			return getThingsForFamily((Integer)id);
		case GEEKLIST:
			return getThingsForGeeklist((Integer)id);
		}
	}
	
	/// retrieve a list of things from BGG with the given ids
	public ArrayList<Thing> getThings(Set<Integer> ids) {
		StringBuilder urlStr = new StringBuilder();
		urlStr.append(BASE_URL + "thing?id=");
		
		String sep = "";
		for (Integer integer : ids) {
			urlStr.append(sep + integer.toString());
			if(sep.isEmpty()) {
				sep = ",";
			}
		}
		
		return getThings(urlStr.toString());
	}
	

	public ArrayList<Thing> getThingsForUser(String user) throws IllegalArgumentException {
		ResultConfig resultConfig = configManager.getResultConfig();
		
		StringBuilder urlStr = new StringBuilder();
		urlStr.append(BASE_URL + COLLECTION 
				+ "?username=" + resultConfig.user
				+ "&subtype=" + resultConfig.subtype.toApiString() + "&");
		if(resultConfig.subtype == Subtype.BOARDGAME) {
			urlStr.append("excludesubtype=" + Subtype.BGEXPANSION.toApiString() + "&");
		}
		
		Iterator<Entry<UserFlag, FilterFlagState>> ufIterator 
			= resultConfig.userFlags.entrySet().iterator(); 
		  
		try {
			while(ufIterator.hasNext()) {
				Entry<UserFlag, FilterFlagState> elem = ufIterator.next(); 
				String apiString = elem.getKey().toApiString();
				FilterFlagState state = elem.getValue();
				if(state == FilterFlagState.IS) {
					urlStr.append(URLEncoder.encode(apiString, "UTF-8"));
					urlStr.append("=1&");
				} else if (state == FilterFlagState.ISNOT) {
					urlStr.append(URLEncoder.encode(apiString, "UTF-8"));
					urlStr.append("=0&");
				}
			}
		}
		catch (UnsupportedEncodingException e) {
			e.printStackTrace();
			return null;
		}

		return getThings(urlStr.toString());
	}
	
	public ArrayList<Thing> getThingsForGeeklist(int geeklistId) throws IllegalArgumentException {
		ResultConfig resultConfig = configManager.getResultConfig();
		
		StringBuilder urlStr = new StringBuilder();
		urlStr.append(BASE_URL + GEEKLIST + "/" + String.valueOf(resultConfig.geeklistId));

		return getThings(urlStr.toString());
	}
	
	public ArrayList<Thing> getThingsForFamily(int familyId) throws IllegalArgumentException {
		ResultConfig resultConfig = configManager.getResultConfig();
		
		StringBuilder urlStr = new StringBuilder();
		urlStr.append(BASE_URL + FAMILY + "?id=" + String.valueOf(resultConfig.familyId));

		if(resultConfig.familyType != FamilyType.ALL) {
			urlStr.append("?type=" + resultConfig.familyType);			
		}
		
		return getThings(urlStr.toString());
	}
	

	private ArrayList<Thing> getThings(String urlString) throws IllegalArgumentException {
		System.out.println("URL: " + urlString);
		
		try {
			int retry = 0;
			do {
				// send a GET request and check for ok...
				URL url = new URL(urlString);
				HttpURLConnection con = (HttpURLConnection) url.openConnection();
				con.setRequestMethod("GET");			
				int status = con.getResponseCode();
				if(status == HttpURLConnection.HTTP_ACCEPTED) {
					Thread.sleep(2000);
			        eventBroker.send(EventConstants.TOPIC_STATUS, "Waiting for server to prepare result...");
				}
				else if(status != HttpURLConnection.HTTP_OK) {
					eventBroker.send(EventConstants.TOPIC_STATUS, "Http Response: " + status);
					con.disconnect();
					return null;
				} else {
					// HTTP_OK, go on...		
					BufferedReader in = new BufferedReader(
							new InputStreamReader(con.getInputStream()));
					String inputLine;
					StringBuffer content = new StringBuffer();
					while ((inputLine = in.readLine()) != null) {
					    content.append(inputLine);
					}
					in.close();
					con.disconnect();
					
					// do something with the content
					System.out.println(content.toString());
					ArrayList<Thing> output = parseThingMetas(content.toString());

					output.sort((thing1, thing2) -> thing1.getMetaData().getName().compareTo(thing2.getMetaData().getName()));
					
					return output;
				}
				
				++retry;
			} while (retry < RETRIES);

		}
		catch (MalformedURLException e) {			
			eventBroker.send(EventConstants.TOPIC_STATUS, "[ERROR] Malformed URL: " + urlString);
			e.printStackTrace();
		} catch (IOException e) {
			eventBroker.send(EventConstants.TOPIC_STATUS, "[ERROR] Could not open connection for URL: " + urlString);
			e.printStackTrace();
		} catch (InterruptedException e) {
			// this will not happen, but we have to catch it anyways...
			e.printStackTrace();
		}
		
		return null;
	}

	
	
	private ArrayList<Thing> parseThingMetas(String content) throws IllegalArgumentException {
		ArrayList<Thing> things = new ArrayList<Thing>();
		
		DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
		try {
			
			DocumentBuilder builder = factory.newDocumentBuilder();
			InputSource is = new InputSource(new StringReader(content));
			is.setEncoding("UTF-8");
			Document doc = builder.parse(is);
			Element root = doc.getDocumentElement();
			
			checkForErrors(doc);
			
			// BGG XMLAPI2
			if(root.getTagName() == "items") {
				NodeList nList = doc.getElementsByTagName("item");
				for(int i = 0; i < nList.getLength(); i++) {
					Node nNode = nList.item(i);
					if (nNode.getNodeType() == Node.ELEMENT_NODE) {
						Element eElement = (Element) nNode;
						
						// thing when fetching by user
						if( eElement.hasAttribute("objecttype") 
								&& eElement.getAttribute("objecttype").equals("thing"))
						{
							Integer id = Integer.parseInt(eElement.getAttribute("objectid"));
							if(id != 0) {
								ThingMetaData tmd = new ThingMetaData(
										id,
										getValue(eElement, "name"),
										getValue(eElement, "image"),
										getValue(eElement, "thumbnail"),
										getValue(eElement, "comment"),
										Integer.parseInt(getValue(eElement, "numplays"))	
										);
								Thing thing =  new Thing(id, tmd);
								things.add(thing);
							}						
						} 
						// when fetching things by id, type is boardgame
						else if(eElement.hasAttribute("type") &&
							eElement.getAttribute("type").equals("boardgame")) 
						{
							Integer id = Integer.parseInt(eElement.getAttribute("id"));
							if(id != 0) {
								String name = "";
								NodeList nameList = eElement.getElementsByTagName("name");
								for(int n = 0; n < nameList.getLength(); n++) {
									Node nameNode = nameList.item(n);
									if (nNode.getNodeType() == Node.ELEMENT_NODE) {
										Element nameElement = (Element) nameNode;
										if(nameElement.hasAttribute("type") 
												&& nameElement.getAttribute("type").equals("primary")) 
										{
											name = nameElement.getAttribute("value");
											break;
										}
									}
								}
								
								ThingMetaData tmd = new ThingMetaData(
										id,
										name,
										getValue(eElement, "image"),
										getValue(eElement, "thumbnail"),
										getValue(eElement, "comment"),
										null
										);
								Thing thing =  new Thing(id, tmd);
								things.add(thing);
							}				
						}							
						// family has "type"
						else if(eElement.hasAttribute("type") 
								&& eElement.getAttribute("type").equals("boardgamefamily")) 
						{
							// get name and description
							StringBuilder fInfo = new StringBuilder();
							
							NodeList nListName = eElement.getElementsByTagName("name");
							if(nListName.getLength() > 0) {
								fInfo.append(nListName.item(0).getTextContent() + "\r\n");
							}

							NodeList nListDesc = doc.getElementsByTagName("description");
							if(nListDesc.getLength() > 0) {
								fInfo.append(nListDesc.item(0).getTextContent());
							}
							eventBroker.send(EventConstants.TOPIC_FAMILY_INFO, fInfo.toString());

							NodeList nLinks = eElement.getElementsByTagName("link");
							for(int l = 0; l < nLinks.getLength(); l++) {
								Node link = nLinks.item(l);
								if (link.getNodeType() == Node.ELEMENT_NODE) {
									Element eLink = (Element) link;
									Integer id = Integer.parseInt(eLink.getAttribute("id"));
									if(id != 0) {
										ThingMetaData tmd = new ThingMetaData(
												id,
												eLink.getAttribute("value"),
												"", "", "", null);
										Thing thing = new Thing(id, tmd);
										things.add(thing);
									}						
								}
							}
							
							// because of our input, there shouldn't be more than one family in the result
							// but do not iterate over items just to make sure
							break;
						}
					}
				}
			}
			// for geeklist result
			else if(root.getTagName() == "geeklist") {
				StringBuilder gInfo = new StringBuilder();
				
				NodeList nListTitle = doc.getElementsByTagName("title");
				if(nListTitle.getLength() > 0) {
					gInfo.append(nListTitle.item(0).getTextContent() + "\r\n");
				}

				NodeList nListDesc = doc.getElementsByTagName("description");
				if(nListDesc.getLength() > 0) {
					gInfo.append(nListDesc.item(0).getTextContent());
				}
				eventBroker.send(EventConstants.TOPIC_GEEKLIST_INFO, gInfo.toString());
				
				NodeList nList = doc.getElementsByTagName("item");
				for(int i = 0; i < nList.getLength(); i++) {
					Node nNode = nList.item(i);
					if (nNode.getNodeType() == Node.ELEMENT_NODE) {
						Element eElement = (Element) nNode;
						Integer id = Integer.parseInt(eElement.getAttribute("objectid"));
						if(id != 0) {
							ThingMetaData tmd = new ThingMetaData(
									id,
									eElement.getAttribute("objectname"), 
									"", "", "", null);
							Thing thing = new Thing(id, tmd);
							things.add(thing);
						}
					}
				}
			}

			return things;
			
		} catch (ParserConfigurationException e) {
			e.printStackTrace();
		} catch (SAXException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}
		
		
		
		return null;
	}


	private void checkForErrors(Document doc) throws IllegalArgumentException {
		NodeList nList = doc.getElementsByTagName("error");
		if(nList.getLength() > 0) {
			Element el = (Element)nList.item(0);
			String val = getValue(el, "message");
			if(val.equals("")) {
				val = el.getAttribute("message");
			}
			throw new IllegalArgumentException(val);
		}
	}


	private String getValue(Element eElement, String key) {
		Node node = eElement.getElementsByTagName(key).item(0);
		if(node == null) {
			return "";
		} else {
			return node.getTextContent();
		}        
	}
	
	
}