package atmsdriver.trafficeventseditor;

import tmcsim.highwaymodel.Highway;
import tmcsim.highwaymodel.Highways;
import tmcsim.highwaymodel.LoopDetector;
import tmcsim.highwaymodel.LoopDetector.DOTCOLOR;
import tmcsim.highwaymodel.Station;
import java.util.ArrayList;
import java.util.List;
import java.util.Observable;
import java.util.logging.Level;
import java.util.logging.Logger;
import tmcsim.common.SimulationException;

/**
 *
 * @author jtorres
 */
public class TimeFrames extends Observable
{
    public List<TimeFrame> frames;
    final public Highways highways;
    public Highway currentHighway;
    public TimeFrame currentTimeFrame;
    public Station currentStation;
    public LoopDetector currentLoopDetector;
    public TrafficLaneEvent currentTrafficLaneEvent;
    
    public TimeFrames()
    {
        frames = new ArrayList<>();
        highways = new Highways("./config/vds_data/postmile_coordinates.txt");
    }
    
    public void addTimeFrame(String time)
    {
        TimeFrame frame = new TimeFrame(time);
        frames.add(frame);
        
        setCurrentTimeFrame(this.frames.size() - 1);
        
        setChanged();
        notifyObservers("add frame");
    }
    
    public void addEventsToTimeFrame(int[] rows, DOTCOLOR dotcolor)
    {
        for(int row : rows)
        {
            TrafficLaneEvent event = new TrafficLaneEvent(currentHighway.routeNumber,
                    currentStation, currentStation.loops.get(row), dotcolor);
            currentTimeFrame.addEvent(event);
        }
        
        setChanged();
        notifyObservers("add event");
    }
    
    public void setCurrentHighway(int index)
    {
        currentHighway = highways.highways.get(index);
        currentStation = null;
        currentLoopDetector = null;
        
        setChanged();
        notifyObservers("select hwy");
    }
    
    public void setCurrentTimeFrame(int index)
    {
        currentTimeFrame = frames.get(index);
        
        setChanged();
        notifyObservers("select frame");
    }
    
    public void setCurrentStation(int index)
    {
        currentStation = currentHighway.stations.get(index);
        currentLoopDetector = null;
        
        setChanged();
        notifyObservers("select station");
    }
    
    public void setCurrentLoopDetector(int index)
    {
        currentLoopDetector = currentStation.loops.get(index);
        
        setChanged();
        notifyObservers("select loop");
    }

    public void setCurrentTrafficLaneEvent(int index)
    {
        currentTrafficLaneEvent = currentTimeFrame.events.get(index);
        
        setChanged();
        notifyObservers("select event");
    }
    
    int getCurrentTrafficEventIndex()
    {
        return currentTimeFrame.events.indexOf(currentTrafficLaneEvent);
    }
    
    int getCurrentTimeFrameIndex()
    {
        return frames.indexOf(currentTimeFrame);
    }

    int getCurrentHighwayIndex()
    {
        return highways.highways.indexOf(currentHighway);
    }

    public void deleteTrafficLaneEvent(int index)
    {
        currentTimeFrame.events.remove(index);
        
        if(currentTimeFrame.events.size() > 0)
        {
            if(index == 0)
            {
                currentTrafficLaneEvent = currentTimeFrame.events.get(0);
            }
            else
            {
                currentTrafficLaneEvent = currentTimeFrame.events.get(index - 1);
            }
        }
        else
        {
            currentTrafficLaneEvent = null;
        }
        
        setChanged();
        notifyObservers("delete event");
    }
    
    void deleteTimeFrame(int selectedIndex)
    {
        frames.remove(selectedIndex);
        
        if(frames.size() > 0)
        {
            if(selectedIndex == 0)
            {
                currentTimeFrame = frames.get(0);
            }
            else
            {
                currentTimeFrame = frames.get(selectedIndex - 1);
            }
        }
        else
        {
            currentTimeFrame = null;
        }
        
        setChanged();
        notifyObservers("delete frame");
    }

    void singlePreviewStation()
    {
        highways.reset();
        for(TrafficLaneEvent event : currentTimeFrame.events)
        {
            if(event.station.equals(currentStation))
            {
                highways.applyTrafficLaneEvent(event);
            }
        }
        writeToFEP();
    }

    void singlePreviewHighways()
    {
        highways.reset();
        for(TrafficLaneEvent event : currentTimeFrame.events)
        {
            highways.applyTrafficLaneEvent(event);
        }
        writeToFEP();
    }
    
    void writeToFEP()
    {
            highways.toJson();
    }

    void cumulativePreviewStation()
    {
        highways.reset();
        for(TimeFrame tf : frames)
        {
            for(TrafficLaneEvent e : tf.events)
            {
                if(e.station.equals(currentStation))
                {
                    highways.applyTrafficLaneEvent(e);
                }
            }
            
            if(tf.equals(currentTimeFrame))
                break;
        }
        writeToFEP();
    }

    void cumulativePreviewHighways()
    {
        highways.reset();
        for(TimeFrame tf : frames)
        {
            for(TrafficLaneEvent e : tf.events)
            {
                highways.applyTrafficLaneEvent(e);
            }
   
            if(tf.equals(currentTimeFrame))
                break;
        }
        writeToFEP();
    }
}