package atmsdriver.model;

import atmsdriver.model.Station.DIRECTION;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.PrintWriter;
import java.io.StringWriter;
import java.io.Writer;
import java.net.Socket;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
import java.util.Scanner;
import java.util.Set;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.transform.OutputKeys;
import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.dom.DOMSource;
import javax.xml.transform.stream.StreamResult;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import tmcsim.common.SimulationException;

/**
 * The Highways class aggregates all Highway instances within a geographic
 * region, and all of the FEPLines within an electronic detector network, in the
 * same geographic region. An instance of Highways.java comprises the underlying
 * model for the ATMSDriver application.
 *
 * Highways uses method writeToFEP() to communicate with the FEP Simulator. It
 * creates a socket client which sends the FEP Simulator a highways status
 * message over the socket. This message is sent in the format required by the
 * FEP Simulator.
 *
 * Currently, there is no driving logic within the highways class. It is only
 * done through an instance of the ConsoleDriver.java class. Eventually, it will
 * receive incident data (from exchange.xml or better yet, directly from the
 * TMCSimulator itself) and drive the highways using resident logic.
 *
 * @author John A. Torres
 */
final public class Highways
{

    final private String FEPHostName;
    final private int FEPPortNum;
    
    final private ArrayList<FEPLine> lines;
    final public ArrayList<Highway> highways;

    public Highways(String highwaysMapFileName, String FEPHostName, int FEPPortNum)
    {
        // load FEP Lines
        lines = loadLines(highwaysMapFileName);
        // configure and load highways
        this.highways = configureHighways();
        
        // write to FEP host and port number
        this.FEPHostName = FEPHostName;
        this.FEPPortNum = FEPPortNum;
    }

    private ArrayList<Highway> configureHighways()
    {
        System.out.println("Loading highways...");
        // The list of highways to return
        ArrayList<Highway> highways = new ArrayList<Highway>();
        
        // map of hwy number to its list of stations
        Map<Integer, ArrayList<Station>> highwayMap = new HashMap<>();
        
        // iterate through FEPLines and get data to add to the above map
        for (FEPLine line : lines)
        {
            // grab all stations from the current FEPLine
            ArrayList<Station> lineStations = (ArrayList<Station>) line.stations;
            // iterate through each station in the list of stations
            for (Station station : lineStations)
            {
                Integer hwyNum = station.routeNumber;
                
                // if the map does not contain an entry for the highway, create
                // a new entry (key/value pair) for the highway and instantiate
                // the empty list of stations
                if (!highwayMap.containsKey(hwyNum))
                {
                    ArrayList<Station> stnList = new ArrayList<>();
                    stnList.add(station);
                    highwayMap.put(hwyNum, stnList);
                } 
                // if the map does have an entry for the highway, add the current
                // station to its list of stations
                else
                {
                    highwayMap.get(hwyNum).add(station);
                }
            }
        }
        
        // get the set of highway numbers
        Set<Integer> hwyKeys = highwayMap.keySet();
        // get the highway number and associated stations and create a new hwy
        // and add the hwy to this.highways
        for (Integer hwyKey : hwyKeys)
        {
            ArrayList<Station> hwyStations = highwayMap.get(hwyKey);
            Collections.sort(hwyStations);
            System.out.println("Loaded highway " + hwyKey + "...");
            highways.add(new Highway(hwyKey,
                    hwyStations));
        }
        System.out.println("");
        return highways;
    }

    /**
     * Applies specified color to the specified highway stretch. Route number
     * and direction specify the highway. Postmile and range specify the stretch
     * of specified highway. Dot color is the color to be applied to the
     * stretch.
     *
     * @param routeNumber highway route number
     * @param direction highway direction
     * @param postmile origin postmile value
     * @param range range from origin postmile
     * @param dotColor the color to be applied to specified highway stretch
     */
    public void applyColorToHighwayStretch(Integer routeNumber, Station.DIRECTION direction,
            Double postmile, Double range, LoopDetector.DOTCOLOR dotColor)
    {
        System.out.println("Applying " + dotColor.name() + " dots to highway "
                + routeNumber + " " + direction.name() + " at postmile "
                + postmile + " with a range of " + range + " miles...");

        // Get the highway by route number
        Highway highway = getHighwayByRouteNumber(routeNumber);

        // start value for highway section, and end value for highway section
        // by postmile
        Double startPost;
        Double endPost;

        // postmiles increase from s to n and w to e
        // if the direction is south or west
        if (direction.equals(Station.DIRECTION.SOUTH) || direction.equals(Station.DIRECTION.WEST))
        {
            // add range value to startPost to get
            // the end postmile value of the highway section
            startPost = postmile;
            endPost = postmile + range;

            // iterate through the stations, if within the specified highway
            // stretch, update the station by direction and apply dot color
            for (Station station : highway.stations)
            {
                if (station.postmile >= startPost && station.postmile <= endPost)
                {
                    station.updateByDirection(direction, dotColor);
                }
            }
        } // if the direction is north or east 
        else
        {
            // subtract range value from startPost
            // to get the end postmile value of the highway section
            startPost = postmile;
            endPost = postmile - range;

            // iterate through the stations, if within the specified highway
            // section, update the station by direction and apply dot color
            for (Station station : highway.stations)
            {
                if (station.postmile <= startPost && station.postmile >= endPost)
                {
                    station.updateByDirection(direction, dotColor);
                }
            }
        }
        System.out.println("");
    }
    
    /**
     * Loads all FEPLines from the specified highways map file.
     * 
     * @param highwaysMapFileName
     * @return List of FEPLines
     */
    private ArrayList<FEPLine> loadLines(String highwaysMapFileName)
    {
        ArrayList<FEPLine> lines = new ArrayList<>();
        try
        {
            Scanner sc = new Scanner(new File(highwaysMapFileName));
            String firstLine = sc.nextLine();

            Scanner linesc = new Scanner(firstLine);
            int numLines = linesc.nextInt();
            linesc.close();

            for (int i = 0; i < numLines; i++)
            {
                lines.add(loadLine(sc));
            }
            sc.close();

        } catch (FileNotFoundException ex)
        {
            Logger.getLogger(Highways.class.getName()).log(Level.SEVERE, null, ex);
        }
        return lines;
    }
    
    /**
     * Loads a single FEP Line from the highways map file.
     * 
     * @param sc scanner at the current FEPLine line
     * @return FEPLine
     */
    private FEPLine loadLine(Scanner sc)
    {
        String line = sc.nextLine();
        Scanner scline = new Scanner(line);

        int lineNum = scline.nextInt();
        int count = scline.nextInt();
        int numStations = scline.nextInt();
        ArrayList<Station> stations = new ArrayList<>();
        for (int i = 0; i < numStations; i++)
        {
            stations.add(loadStation(sc, lineNum));
        }

        return new FEPLine(lineNum, stations, count);
    }
    
    /**
     * Loads a single Station from the highways map file
     * @param sc scanner at the current station line
     * @param lineNum the FEPLine number for the station
     * @return Station
     */
    private Station loadStation(Scanner sc, int lineNum)
    {
        String line = sc.nextLine();
        Scanner scline = new Scanner(line);
        int ldsID = scline.nextInt();
        int drop = scline.nextInt();
        int fwy = scline.nextInt();
        DIRECTION dir = DIRECTION.toDirection(scline.next());
        double postmile = scline.nextDouble();
        int numLoops = scline.nextInt();
        String location = getStationLoc(line);
        ArrayList<LoopDetector> loops = new ArrayList<>();
        for (int i = 0; i < numLoops; i++)
        {
            loops.add(loadLoop(sc));
        }

        return new Station(lineNum, ldsID, drop, location, loops, fwy, dir, postmile);
    }
    
    /**
     * Loads a single loop from the highways map file
     *
     * @param sc scanner at the current loop line
     * @return LoopDetector
     */
    private LoopDetector loadLoop(Scanner sc)
    {
        String line = sc.nextLine();
        Scanner scline = new Scanner(line);

        int loopID = scline.nextInt();
        int laneNum = scline.nextInt();
        String loopLoc = getLoopLoc(line); // NEED GET LOOPLOC
        scline.close();
        return new LoopDetector(loopID, loopLoc, laneNum);
    }

    /**
     * Scans the LoopDetector line and grabs the String location from the line.
     * 
     * @param line the line containing the location
     * @return A String loop location.
     */
    private String getLoopLoc(String line)
    {
        Scanner sc = new Scanner(line);
        sc.nextInt();
        sc.nextInt();

     // GRABS FROM CURRENT TO END OF LINE
        sc.useDelimiter("\\z");
        String loc = sc.next().trim();
        sc.close();
        return loc;
    }

    /**
     * Scans the Station line and grabs the String location from the line.
     * 
     * @param line the line containing the location
     * @return A String station location.
     */
    private String getStationLoc(String line)
    {
        Scanner scline = new Scanner(line);
        scline.nextInt();
        scline.nextInt();
        scline.nextInt();
        scline.next();
        scline.nextDouble();
        scline.nextInt();

        // GRABS FROM CURRENT TO END OF LINE
        scline.useDelimiter("\\z");
        String loc = scline.next().trim();
        scline.close();
        return loc;
    }
    
    /** 
     * Creates a socket client that writes the Highways data to the FEP Simulator.
     * 
     * @throws SimulationException 
     */
    public void writeToFEP() throws SimulationException
    {
        try
        {
            // Create the socket to the FEP Simulator
            Socket sock = new Socket(FEPHostName, FEPPortNum);
            PrintWriter out = new PrintWriter(sock.getOutputStream(), true);
            
            // Print the number of bytes the highways data message contains
            System.out.println("BYTES: " + this.toXML().toCharArray().length + 1);
            
            // Write the highways data over the socket
            out.println(this.toXML());
            
            // close the socket
            sock.close();
        } catch (IOException ex)
        {
            Logger.getLogger(Highways.class.getName()).log(Level.SEVERE, null, ex);
            System.out.println("Highway Model failed writing to FEPSim.");
            throw new SimulationException(SimulationException.BINDING);
        }
    }

    /**
     * Returns the highways metadata in condensed form. This function took the 
     * highways model and wrote it into condensed form. It is also useful for
     * testing.
     *
     * @return the highways meta data string
     */
    public String getHighwaysMeta()
    {
            StringBuilder build = new StringBuilder();
            build.append(lines.size());
            build.append("\n");
            for (FEPLine line : lines)
            {
                build.append(line.getLineMeta());
            }
            return build.toString();
    }

    /**
     * Returns the Highways model data in XML format.
     * 
     * @return highways data in XML format
     */
    public String toXML()
    {
        String xml = null;
        try
        {
            DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
            DocumentBuilder builder = factory.newDocumentBuilder();
            Document theDoc = builder.newDocument();

            Element networkElement = theDoc.createElement(XML_TAGS.NETWORK.tag);
            theDoc.appendChild(networkElement);

            for (FEPLine line : lines)
            {
                line.toXML(networkElement);
            }

            Transformer tf = TransformerFactory.newInstance().newTransformer();

            tf.setOutputProperty(OutputKeys.ENCODING, "UTF-8");
            tf.setOutputProperty(OutputKeys.INDENT, "yes");
            tf.setOutputProperty("{http://xml.apache.org/xslt}indent-amount", "2");

            Writer out = new StringWriter();
            tf.transform(new DOMSource(theDoc), new StreamResult(out));
            xml = out.toString();
            out.close();
        } catch (Exception ex)
        {
            Logger.getLogger(Highways.class.getName()).log(Level.SEVERE, null, ex);
        }
        return xml;

    }

    /**
     * Returns a highway by given highway number.
     * 
     * @param routeNum
     * @return Highway with specified route number
     */
    public Highway getHighwayByRouteNumber(Integer routeNum)
    {
        Highway returnHwy = null;
        for (Highway hwy : highways)
        {
            if (hwy.routeNumber.equals(routeNum))
            {
                returnHwy = hwy;
                break;
            }
        }
        return returnHwy;
    }

    /**
     * XML tags used in writeToXML()
     */
    private static enum XML_TAGS
    {

        NETWORK("Network");

        String tag;

        private XML_TAGS(String n)
        {
            tag = n;
        }
    }
}