source: proiecte/ptvs/src/vnsim/vehicular/routePlan/cityRouting/Server.java @ 31

package vnsim.vehicular.routePlan.cityRouting;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.ArrayList;
import java.util.StringTokenizer;

import vnsim.map.object.Globals;

public class Server {
        // server is processing data x time faster
        public static final int kTimeCompression = 5;
        // threshold
        private static final double kCongestionThresh = 5.0;
        // congestion for every cross roads
        private ArrayList<CrossRoadCongestion> crCongestion;
        // list of segments with their actual congestion;
        private ArrayList<RoadSegmentCongestion> updatedCongestion;
        // true if lastWeek was generated or loaded
        private boolean isLastWeekSet;

        public Server() {
                crCongestion = new ArrayList<CrossRoadCongestion>();
                updatedCongestion = new ArrayList<RoadSegmentCongestion>();
                isLastWeekSet = false;
        }

        // mediate real time data and store it into lastWeek db
        private void updateLastWeekCongestions(int day, int hour) {
                if (hour == 0) { // store to the previews hour entry;
                        if (day > 0) {
                                day--;
                                hour = 23;
                        } else {
                                return;
                        }
                } else {
                        hour--;
                }
                for (int i = 0; i < crCongestion.size(); i++) {
                        crCongestion.get(i).updateLastWeekCongestion(day, hour);
                }
        }

        // make last week public by storing it in Globals.lastWeekCongestions
        private void publishLastWeekCongestions() {
                ArrayList<ArrayList<WeekCongestion>> lastWeekCongestions = new ArrayList<ArrayList<WeekCongestion>>();
                for (int i = 0; i < crCongestion.size(); i++) {
                        lastWeekCongestions.add(crCongestion.get(i).cloneLastWeek());
                }
                Globals.lastWeekCongestions = lastWeekCongestions;
                isLastWeekSet = true;
        }

        // set real time data
        public void setCongestion(int crossIndex, int segmentIndex, int crtTime,
                        Double congestion) {
                crCongestion.get(crossIndex).setCongestion(segmentIndex, congestion);
                if (isLastWeekSet) {
                        int time = crtTime / kTimeCompression; // secs
                        time = time / 3600; // hours
                        int hour = time % 24;
                        time = time / 24; // days
                        int day = time % 7;
                        Double lastCongestion = crCongestion.get(crossIndex)
                                        .getLastWeekCongestion(segmentIndex, day, hour);
                        RoadSegmentCongestion rsc = new RoadSegmentCongestion(crossIndex,
                                        segmentIndex, congestion);
                        if (isDifferent(congestion, lastCongestion)) {
                                RoadSegmentCongestion existingRSC = null;
                                for (int i = 0; i < updatedCongestion.size(); i++) {
                                        if (updatedCongestion.get(i).equals(rsc)) {
                                                existingRSC = updatedCongestion.get(i);
                                                break;
                                        }
                                }
                                if (existingRSC == null) { // entry does not exist -> add
                                        // congestion
                                        updatedCongestion.add(rsc);
                                        broadcastUpdatedCongestions();
                                } else {
                                        if (isDifferent(congestion, existingRSC.getCongestion())) {
                                                existingRSC.setCongestion(congestion);
                                                broadcastUpdatedCongestions();
                                        }
                                }
                        } else {
                                for (int i = 0; i < updatedCongestion.size(); i++) {
                                        if (updatedCongestion.get(i).equals(rsc)) {
                                                updatedCongestion.remove(i);
                                                broadcastUpdatedCongestions();
                                                break;
                                        }
                                }
                        }
                }
        }

        private boolean isDifferent(Double current, Double previous) {
                return (Math.abs(current - previous) > kCongestionThresh);
        }

        private void broadcastUpdatedCongestions() {
                ArrayList<RoadSegmentCongestion> toSend = new ArrayList<RoadSegmentCongestion>();
                for (int i = 0; i < updatedCongestion.size(); i++) {
                        toSend.add(updatedCongestion.get(i).clone());
                }
                IntersectionNode in;
                for (int i = 0; i < crCongestion.size(); i++) {
                        in = crCongestion.get(i).getIntersectionNode();
                        in.updateCongestions(toSend);
                }
        }

        // IntersectionNode subscribes to the server for server replies
        public int addIntersectionNode(IntersectionNode inode) {
                crCongestion.add(new CrossRoadCongestion(inode));
                return crCongestion.size() - 1;
        }

        // to be called after the Intersection nodes were registered to the server
        public void init() {
                if (!isLastWeekSet) {
                        isLastWeekSet = loadCongestions(null);
                        publishLastWeekCongestions();
                }
        }

        public void step(int crtTime) {
                if (crtTime % kTimeCompression != 0) {
                        return;
                }
                int time = crtTime / kTimeCompression; // seconds
                time = time / 3600; // hours
                int hour = time % 24;
                time = time / 24; // days
                int day = time % 7;
                time = crtTime / kTimeCompression;

                // for each hour
                if (time % 3600 == 0) {
                        updateLastWeekCongestions(day, hour);
                        updatedCongestion.clear();
                        broadcastUpdatedCongestions();
                }

                // for each week
                //if (time % 604800 == 0) {
                if (time % 86400 == 0) {
                        saveCongestions(null);
                        publishLastWeekCongestions();
                }
        }

        // save lastWeek congestion into filename file
        private boolean saveCongestions(String filename) {
                if (filename == null) {
                        filename = System.getProperty("user.home") + File.separatorChar + "maps" + 
                        File.separatorChar + "rt" + File.separatorChar + Globals.scenarioName + ".cng.txt";
                }
                BufferedWriter out = null;
                try {
                        out = new BufferedWriter(new FileWriter(filename));
                        String str;
                        StringTokenizer st;

                        out.write("crosses_nb " + crCongestion.size());
                        out.newLine();
                        for (int i = 0; i < crCongestion.size(); i++) {
                                out.write("cross " + i);
                                out.newLine();
                                str = crCongestion.get(i).toString();
                                st = new StringTokenizer(str, "\n");
                                while (st.hasMoreTokens()) {
                                        out.write(st.nextToken());
                                        out.newLine();
                                }
                        }
                        out.close();
                } catch (IOException e) {
                        System.out.println("Could not save congestion file " + filename);
                        return false;
                }
                return true;
        }

        // load lastWeek congestion from filename
        private boolean loadCongestions(String filename) {
                if (filename == null) {
                        filename = System.getProperty("user.home") + File.separatorChar + "maps" + 
                        File.separatorChar + "rt" + File.separatorChar + Globals.scenarioName + ".cng.txt";
                }
                BufferedReader in = null;
                try {
                        in = new BufferedReader(new FileReader(filename));
                        String line = "";
                        StringTokenizer st;

                        int crossIndex, segmentIndex, day, hour;
                        int crosses_nb, segments_nb;
                        Double congestion;

                        line = in.readLine();
                        while (line != null) {
                                st = new StringTokenizer(line, " ");
                                st.nextToken(); // crosses_nb
                                crosses_nb = Integer.parseInt(st.nextToken());
                                for (crossIndex = 0; crossIndex < crosses_nb; crossIndex++) {
                                        line = in.readLine(); // cross i
                                        line = in.readLine();
                                        st = new StringTokenizer(line, " ");
                                        st.nextToken(); // segments_nb;
                                        segments_nb = Integer.parseInt(st.nextToken());
                                        for (segmentIndex = 0; segmentIndex < segments_nb; segmentIndex++) {
                                                line = in.readLine(); // segment i
                                                for (day = 0; day < 7; day++) {
                                                        line = in.readLine();
                                                        st = new StringTokenizer(line, " ");
                                                        for (hour = 0; hour < 24; hour++) {
                                                                congestion = Double.parseDouble(st.nextToken());
                                                                crCongestion.get(crossIndex)
                                                                                .setLastWeekCongestion(segmentIndex,
                                                                                                day, hour, congestion);
                                                        }
                                                }
                                        }
                                }
                                line = in.readLine();
                        }
                        in.close();
                } catch (IOException e) {
                        System.out.println("Could not load congestion file " + filename);
                        return false;
                }
                return true;
        }
}