// $gleason: trafficmon/BWChart.java,v 1.36 2003/10/27 04:32:08 clash Exp $

// Property of Joseph Gleason
// Copyright 2003


package cc.glsn.trafficmon;

import java.sql.ResultSet;
import java.util.Calendar;
import java.util.Iterator;
import java.util.SortedMap;
import java.util.TreeMap;
import java.util.TreeSet;

import cc.glsn.ConfigFile;
import cc.glsn.DBConnMgr;
import cc.glsn.SQLConnection;



public class BWChart
{


    private TreeMap BWMap;    
    private String ChartName;
    private DBConnMgr DBCM;
    private ConfigFile Settings;
    private TreeSet MonthsOnHand;


    public BWChart(String chartname, ConfigFile settings) throws Exception
    {
    	ChartName=chartname;
        Settings=settings;
        
        BWMap=new TreeMap();
        MonthsOnHand=new TreeSet();
        
        DBCM=new DBConnMgr(Settings);

    }




    public void Update(int TimeStamp, double Bin, double Bout) throws java.sql.SQLException
    {
        BWSpot S=new BWSpot();
        S.TimeStamp=TimeStamp;
        S.Bin=Bin;
        S.Bout=Bout;
        
        char Q=34;
        
        SQLConnection SQLC=DBCM.getConn();
        
        ResultSet RS=SQLC.SingleUpdatableQuery("select * from trafficspots where linkid=" + Q + ChartName + Q + " and timestamp=" + TimeStamp);
        
        boolean Insert=false;
        if (RS.first())
        {
        	Insert=false;
        }
        else
        {
        	Insert=true;
        	RS.moveToInsertRow();
        	RS.updateString("linkid", ChartName);
        	RS.updateLong("timestamp",TimeStamp);
        	
        }
        RS.updateDouble("traffin",Bin);
        RS.updateDouble("traffout",Bout);
        
        if (Insert)
        {
        	RS.insertRow();
        }
        else
        {
        	RS.updateRow();
        }
        
        DBCM.relConn(SQLC);
        
        


    }
    
    private BWSpot ResultToSpot(ResultSet R) throws java.sql.SQLException
    {
    	BWSpot S=new BWSpot();
    	
    	
    	S.TimeStamp=R.getInt("TimeStamp");
    	S.Bin=R.getDouble("traffin");
    	S.Bout=R.getDouble("traffout");
    	
    	return S;
    
    }
    

    public BWSpot getCurrentBW() throws java.sql.SQLException
    {
    	char Q=34;
    	
        SQLConnection SQLC=DBCM.getConn();
        
        long CurrT=System.currentTimeMillis()/1000;
        CurrT=CurrT-3600;
        
        
        ResultSet RS=SQLC.SingleUpdatableQuery("select * from trafficspots where linkid=" + Q + ChartName + Q + 
        "and timestamp>" + CurrT + " order by timestamp desc limit 1");
        
        RS.first();
        
        BWSpot S=ResultToSpot(RS);
        
        DBCM.relConn(SQLC);

        return S;

    }
    
    private void readMonthFromDB(int Year, int Month) throws java.sql.SQLException
    {
        int SOM=getStartOfMonth(Year,Month);
        int EOM=getEndOfMonth(Year,Month);
        char Q=34;
        
        int OnHand=Year*100 + Month;
        MonthsOnHand.add(new Integer(OnHand));
        
        
        SQLConnection SQLC=DBCM.getConn();
        
        ResultSet RS=SQLC.SingleQuery("select * from trafficspots where linkid=" + Q + ChartName + Q + 
        "and timestamp>=" + SOM + " and timestamp<=" + EOM);
        
        while (RS.next())
        {
        	BWSpot S=ResultToSpot(RS);
        	BWMap.put(new Integer(S.TimeStamp),S);
        
        }
        
        
        DBCM.relConn(SQLC);
    	
    
    }
    
    
    public void Print()
    {
        Iterator I=BWMap.values().iterator();
        
        while (I.hasNext())
        {
        
            BWSpot S=(BWSpot)I.next();
            System.out.println("" + S.TimeStamp + " " + S.Bin + " B/s " + S.Bout + " B/s");
            
        }
    
    }
    
    
    private TreeSet getMonthData(int Direction) throws java.sql.SQLException 
    {
    
    
        Calendar Now=Calendar.getInstance();
        return getMonthData(Now.get(Calendar.YEAR),Now.get(Calendar.MONTH),Direction);
    
    }
    
    private int getStartOfMonth(int Year, int Month) throws java.sql.SQLException
    {
    	Calendar StartOfMonthC=Calendar.getInstance();
    	
    	StartOfMonthC.set(Calendar.YEAR,Year);
        StartOfMonthC.set(Calendar.MONTH,Month);
        StartOfMonthC.set(Calendar.DAY_OF_MONTH,1);
        StartOfMonthC.set(Calendar.HOUR_OF_DAY,0);
        StartOfMonthC.set(Calendar.MINUTE,0);
        StartOfMonthC.set(Calendar.SECOND,0);
        StartOfMonthC.set(Calendar.MILLISECOND,0);
        
        int S=new Long(StartOfMonthC.getTimeInMillis()/1000).intValue();    	
        
        return S;
        
        
    
    }
    
    private int getEndOfMonth(int Year, int Month) throws java.sql.SQLException
    {
        Calendar EndOfMonthC=Calendar.getInstance();
        EndOfMonthC.set(Calendar.MONTH,Month+1);
        EndOfMonthC.set(Calendar.DAY_OF_MONTH,1);
        EndOfMonthC.set(Calendar.HOUR_OF_DAY,0);
        EndOfMonthC.set(Calendar.MINUTE,0);
        EndOfMonthC.set(Calendar.SECOND,0);
        EndOfMonthC.set(Calendar.MILLISECOND,0);
        
        int E=new Long(EndOfMonthC.getTimeInMillis()/1000).intValue();
        return E;
    
    }
    
    private TreeSet getMonthData(int Year, int Month, int Direction) throws java.sql.SQLException
    {
        int OnHand=Year*100+Month;
        if (!MonthsOnHand.contains(new Integer(OnHand)))
        {
        	readMonthFromDB(Year,Month);
        }
        
        
        int SOM=getStartOfMonth(Year,Month);
        int EOM=getEndOfMonth(Year,Month);

        

        
        int MonthValues=(EOM-SOM) / (5*60);

            
        TreeSet MonthData=new TreeSet();
        
        SortedMap SubMap=BWMap.subMap(new Integer(SOM),new Integer(EOM));
        
        int FirstTime;
        int LastTime;
        if (SubMap.size()>0)
        {

            FirstTime=((Integer)SubMap.firstKey()).intValue();
            LastTime=((Integer)SubMap.lastKey()).intValue();
            
        }
        else
        {
            FirstTime=EOM;
            LastTime=SOM;
        }
        
        System.out.println("FirstTime for month: " + FirstTime);
        System.out.println("LastTime for month: " + LastTime);
        
        
        int ExtrapolatedValues=0;
        int EmptyValues=0;
        
        for (int t=SOM; t<EOM; t=t+300)
        {
            if ((t >= FirstTime) && (t <= LastTime))
            {
                boolean Done=false;
                int SearchWidth=0;
                while (!Done)
                {
                    int ST=t-(SearchWidth*300);
                    int ET=t+300+(SearchWidth*300);

                    int Spots=BWMap.subMap(new Integer(ST),new Integer(ET)).size();
                    if (Spots>0)
                    {
                        Iterator I=BWMap.subMap(new Integer(ST),new Integer(ET)).values().iterator();
                        double Total=0.0;
                        
                        while (I.hasNext())
                        {
                            BWSpot S=(BWSpot)I.next();
                            Total+=S.getDir(Direction);
                        }
                        
                        BWData BD=new BWData(Total/Spots,t);
                        MonthData.add(BD);
                        
                        Done=true;
                    }
                
                        
                    if (!Done) SearchWidth++;
                }
                
                if (SearchWidth>0) ExtrapolatedValues++;
                
                
            
            }
            else
            {
                BWData BD=new BWData(0,t);
                MonthData.add(BD);
                EmptyValues++;
            }
            
        
        }
   
        System.out.println("Data for: " + Year + "-" + (Month+1));
        System.out.println("Total Values For Complete Month: " + MonthValues);
        System.out.println("Missing values extrapolated from nearby averages: " + ExtrapolatedValues);
        System.out.println("Missing values assumed to be zero (usually future values): " + EmptyValues);
        System.out.println("Number of values on hand: " + MonthData.size());
        System.out.println("Total values in memory: " + BWMap.size());

   
        return MonthData;
    
    }
    
    public void PrintNthSpread(int S, int E, int Direction)  throws java.sql.SQLException
    {
        Calendar Now=Calendar.getInstance();
        PrintNthSpread(S,E,Direction,Now.get(Calendar.YEAR),Now.get(Calendar.MONTH));
    }
    
    public void PrintNthSpread(int S, int E, int Direction, int Year, int Month)  throws java.sql.SQLException
    {
        Converter Conv=new Converter();
        
        TreeSet MonthData=getMonthData(Year, Month, Direction);
        
        for (int i=S; i<=E; i++)
        {
            double D;
            if (i==S)
            {
                D=getNth(i,(TreeSet)MonthData.clone());
            }
            else
            {
                D=getNth(i,(TreeSet)MonthData.clone());
            }
            System.out.print("" + i + "th percentile: ");
            System.out.println(Conv.ConvString(D));

            
        
        }
    
    }
    
    public double getNth(int N, TreeSet MonthData)
    {
        
        
        int RemoveValues=new Double(new Double((100.0-N)/100.0).doubleValue() * new Double(MonthData.size()).doubleValue()).intValue();
        
        BWData Res;
        BWData BD;
        
        if (MonthData.size() > RemoveValues)
        {
            
            for (int i=0; i<RemoveValues; i++)
            {
                BD=(BWData)MonthData.last();
                //System.out.println("Removing: " + BD.T + " " + BD.B); 
                MonthData.remove(BD);
                
            }
            
        
            Res=(BWData)MonthData.last();
        }
        else
        {
            Res=(BWData)MonthData.first();
        }
        
        
        return Res.B;
    
    }


    
    //Used for Nth percentile only

    class BWData implements Comparable
    {
        double B;
        int T;
        int Spots;
        
        BWData(double b, int t)
        {
            B=b;
            T=t;
            Spots=1;
        }
        
        
        
        
        public int compareTo(Object O) throws ClassCastException 
        {
            if (O instanceof BWData)
            {
                BWData O2=(BWData)O;
                
                if (B < O2.B) return -2;
                if (B > O2.B) return 2;
                if (T < O2.T) return -1;
                if (T > O2.T) return 1;
                
                return 0;
            
            }
            
            throw(new ClassCastException("Cannot compare to BWDATA to " + O.getClass().getName()));
        
        }
        
        public boolean equals(Object O)
        {
            if ((O instanceof BWData) && (compareTo(O)==0)) return true;
            return false;
        
        }
    
    }
    
    /*private void UpdateVersion()
    {
        if (BWMap.get(BWMap.firstKey()) instanceof com.fireduck.trafficmon.BWSpot)
        {
            TreeMap newBWMap=new TreeMap();

            Iterator I=BWMap.values().iterator();
            
            BWMap=newBWMap;
            
            while (I.hasNext())
            {
                com.fireduck.trafficmon.BWSpot S=(com.fireduck.trafficmon.BWSpot)I.next();
                
                Update(S.TimeStamp,S.Bin,S.Bout);
            
            }

        
        }
        
    
    }*/

}