ReadScheduleWorker.java

package pl.relationsystems.citynav.server.servlets;

import java.io.IOException;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import javax.jdo.JDOObjectNotFoundException;
import javax.jdo.PersistenceManager;
import javax.jdo.Query;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.xml.bind.JAXBContext;
import javax.xml.bind.JAXBException;
import javax.xml.bind.Unmarshaller;

import pl.relationsystems.citynav.parser.zdium.Dzien;
import pl.relationsystems.citynav.parser.zdium.Godz;
import pl.relationsystems.citynav.parser.zdium.Linia;
import pl.relationsystems.citynav.parser.zdium.Linie;
import pl.relationsystems.citynav.parser.zdium.Min;
import pl.relationsystems.citynav.parser.zdium.Przystanek;
import pl.relationsystems.citynav.parser.zdium.Tabliczka;
import pl.relationsystems.citynav.parser.zdium.Wariant;
import pl.relationsystems.citynav.server.model.DayTypeMapping;
import pl.relationsystems.citynav.server.model.Departure;
import pl.relationsystems.citynav.server.model.Hub;
import pl.relationsystems.citynav.server.model.Line;
import pl.relationsystems.citynav.server.model.Stop;
import pl.relationsystems.citynav.server.model.TransportTypeMapping;
import pl.relationsystems.citynav.server.model.Variant;
import pl.relationsystems.citynav.server.model.VariantStop;
import pl.relationsystems.citynav.server.model.Enums.DayType;
import pl.relationsystems.citynav.server.model.Enums.TransportType;
import pl.relationsystems.citynav.server.utils.PMF;

import com.google.appengine.api.datastore.Key;
import com.google.appengine.api.datastore.KeyFactory;

@SuppressWarnings("serial")
public class ReadScheduleWorker extends HttpServlet {

	// private static final String STOPOVERS_FILE = "/zdik/0023/0023.xml";

	public void doGet(HttpServletRequest req, HttpServletResponse resp)
			throws IOException {

		String fileName = null;

		String pline = req.getParameter("line");

		if (pline != null && pline.length() > 0) {
			fileName = "/zdik/" + pline + "/" + pline + ".xml";
		}

		resp.getWriter().println("Trying to read " + fileName);

		InputStream is = null;
		is = getServletContext().getResourceAsStream(fileName);
		if (is != null) {
			resp.getWriter().println("Looks ok");
			PersistenceManager pm = PMF.get().getPersistenceManager();
			try {

				JAXBContext jc = JAXBContext
						.newInstance("pl.relationsystems.citynav.parser.zdium");

				Unmarshaller u = jc.createUnmarshaller();

				Linie tlines = (Linie) u.unmarshal(is);
				Linia tlinia = tlines.getLinia();

				Key k = KeyFactory.createKey(Line.class.getSimpleName(), tlinia
						.getNazwa().toString());

				Line line;
				try {
					line = pm.getObjectById(Line.class, k);
				} catch (JDOObjectNotFoundException e) {
					line = new Line();
				}
				if (line == null) {
					line = new Line();
				}

				line.setLineId(tlinia.getNazwa().toString());
				line.setTransportType(getTransportTypeForString(pm, line
						.getLineId()));

				Query query = pm.newQuery(Variant.class);
				query.setFilter("line == lineParam");
				query.declareParameters("String lineParam");
				try {

					List<Variant> results = (List<Variant>) query.execute(line
							.getLineId());
					pm.deletePersistentAll(results);
				} finally {
					query.closeAll();
				}
				query = pm.newQuery(VariantStop.class);
				query.setFilter("line == lineParam");
				query.declareParameters("String lineParam");
				try {

					List<Variant> results = (List<Variant>) query.execute(line
							.getLineId());
					pm.deletePersistentAll(results);
				} finally {
					query.closeAll();
				}
				
				Map<String, List<Integer>> claimedTimes = new HashMap<String, List<Integer>>();

				Integer vcounter = 0;
				for (Wariant twariant : tlinia.getWariant()) {
					List<VariantStop> variantStops = new ArrayList<VariantStop>();
					Variant variant = new Variant();
					variant.setName(twariant.getNazwa());
					variant.setLine(line);
					variant.setNth(vcounter);
					pm.makePersistent(variant);

					resp.getWriter().println(variant.toString());

					Integer vscounter = 0;
					for (Przystanek tprzystanek : twariant.getPrzystanek()) {
						Tabliczka ttabliczka = tprzystanek.getTabliczka();

						if (ttabliczka == null)
							continue;

						Long id = null;
						try {
							String _id = tprzystanek.getId();
							_id = _id.split("-")[0];

							id = Long.decode(_id);

						} catch (Exception exception) {
						}
						VariantStop vs = new VariantStop();
						Stop s = Stop.retrieveByPk(id);
						if (s == null) {
							resp.getWriter().println(tprzystanek.toString());
							s = new Stop();
							s.setId(id);
							s.setDescription(tprzystanek.getUlica());
							s.setName(tprzystanek.getNazwa());
							s.setHub(Hub.retrieveOrCreate(s.getName())
									.getName());
							pm.makePersistent(s);
						}
						
						List<Integer> claimed = claimedTimes.get(id.toString());
						if(claimed==null)
						{
							claimed = new ArrayList<Integer>();
						}
						

						vs.setId(variant.getVariantId() + ":"
								+ vscounter.toString());
						vs.setNth(vscounter);
						vs.setLine(line);
						vs.setVariant(variant);

						vs.setStop(s);
						Hub hub = Hub.retrieveOrCreate(s.getHub());
						hub.setIsActive(true);
						vs.setHub(hub.getName());


						pm.makePersistent(hub);

						for (Dzien tdzien : ttabliczka.getDzien()) {
							List<Integer> pdeps = new ArrayList<Integer>();
							DayType dayType = DayTypeMapping.retrieveOrCreate(
									tdzien.getNazwa()).getType();

							for (Godz tgodzina : tdzien.getGodz()) {
								for (Min tmin : tgodzina.getMin()) {
									Integer t = Departure.getTime(tgodzina
											.getH().intValue(), tmin.getM()
											.intValue());
									if(claimed.contains(t)) continue;
									
									if (!pdeps.contains(t))
									{
										pdeps.add(t);
										claimed.add(t);
									}

								}
							}
							int[] ret = new int[pdeps.size()];
							int i = 0;
							for (Integer n : pdeps) {
								ret[i] = n;
								i++;
							}

							vs.setDepartures(dayType, ret);
						}
						
						claimedTimes.put(id.toString(), claimed);
						
						variantStops.add(vs);

						pm.makePersistent(vs);
						vscounter++;
					}
					vcounter++;
				}

				pm.makePersistent(line);

				resp.setContentType("text/plain");

			} catch (JAXBException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			} finally {
				pm.close();
			}

		} else {
			resp.getWriter().println("Nope");
		}

	}

	private TransportType getTransportTypeForString(PersistenceManager pm,
			String nazwa) {
		Key k = KeyFactory.createKey(
				TransportTypeMapping.class.getSimpleName(), nazwa);

		TransportTypeMapping mapping = null;
		try {
			mapping = pm.getObjectById(TransportTypeMapping.class, k);
		} catch (JDOObjectNotFoundException e) {
		}

		if (mapping == null) {
			TransportType type = TransportType.Unknown;
			try {
				Integer t = Integer.getInteger(nazwa);
				if (t != null) {
					if (t < 100) {
						type = TransportType.Tram;
					} else {
						type = TransportType.Bus;
					}
				}
				log(nazwa);

			} catch (Exception e) {
				if (nazwa.matches("[a-zA-Z]*")) {
					type = TransportType.Bus;
				}
			}

			mapping = new TransportTypeMapping();
			mapping.setKey(nazwa);
			mapping.setType(type);
			pm.makePersistent(mapping);
		}

		return mapping.getType();
	}
}