package timeflow.vis.timeline;

import timeflow.data.db.*;
import timeflow.data.db.filter.*;
import timeflow.data.time.*;
import timeflow.model.*;
import timeflow.vis.*;

import java.util.*;
import java.awt.*;

/*
 * A VisualEncoding takes the info about which fields to translate to
 * which visual aspects, and applies that to particular Acts.
 */
public class TimelineVisuals
{

        private Map<String, TimelineTrack> trackTable = new HashMap<String, TimelineTrack>();
        ArrayList<TimelineTrack> trackList = new ArrayList<TimelineTrack>();
        private TimeScale timeScale = new TimeScale();
        private Rectangle bounds = new Rectangle();
        private boolean frameChanged;
        private int numShown = 0;
        private Interval globalInterval;

        public double scale = 1;
        
        public enum Layout
        {

                TIGHT, LOOSE, GRAPH
        };
        private Layout layoutStyle = Layout.TIGHT;
        private VisualEncoder encoder;
        private TFModel model;
        private int fullHeight;

        public int getFullHeight()
        {
                return fullHeight;
        }

        public TimelineVisuals(TFModel model)
        {
                this.model = model;
                encoder = new VisualEncoder(model);
        }

        public TimeScale getTimeScale()
        {
                return timeScale;
        }

        public Rectangle getBounds()
        {
                return bounds;
        }

        public void setBounds(int x, int y, int w, int h)
        {
                bounds.setBounds(x, y, w, h);
                timeScale.setLow(x);
                timeScale.setHigh(x + w);
                frameChanged = true;
        }

        public Layout getLayoutStyle()
        {
                return layoutStyle;
        }

        public void setLayoutStyle(Layout style)
        {
                layoutStyle = style;
                layout();
        }

        public Interval getFitToVisibleRange()
        {
                ActList acts = model.getActs();

                // add a little bit to the right so we can see labels...
                ActDB db = getModel().getDB();
                Field endField = db.getField(VirtualField.END);
                Interval i = null;
                if (endField == null)
                {
                        i = DBUtils.range(acts, VirtualField.START);
                } else
                {
                        i = DBUtils.range(acts, new Field[]
                                {
                                        db.getField(VirtualField.START), endField
                                });
                }
                if (i.length() == 0)
                {
                        i.expand(globalInterval.length() / 20);
                }
                i = i.subinterval(-.05, 1.1);
                i.intersection(globalInterval);
                return i;
        }

        public void fitToVisible()
        {
                Interval i = getFitToVisibleRange();
                setTimeBounds(i.start, i.end);
        }

        public void zoomOut()
        {
                setTimeBounds(globalInterval.start, globalInterval.end);
        }

        public void setTimeBounds(long first, long last)
        {
                timeScale.setDateRange(first, last);
                frameChanged = true;
                model.setViewInterval(new Interval(first, last));
        }

        public Interval getGlobalInterval()
        {
                if (globalInterval == null && model != null && model.getDB() != null)
                {
                        createGlobalInterval();
                }
                return globalInterval;
        }

        public void createGlobalInterval()
        {
                globalInterval = DBUtils.range(model.getDB().all(), VirtualField.START).subinterval(-.05, 1.1);
        }

        public Interval getViewInterval()
        {
                return timeScale.getInterval();
        }

        public java.util.List<VisualAct> getVisualActs()
        {
                return encoder.getVisualActs();
        }

        public void layoutIfChanged()
        {
                if (frameChanged)
                {
                        layout();
                }
        }

        public void init(boolean majorChange)
        {
                note(new TFEvent(majorChange ? TFEvent.Type.DATABASE_CHANGE : TFEvent.Type.ACT_CHANGE, null));
        }

        public void note(TFEvent e)
        {
                ActList all = null;
                if (e.type == TFEvent.Type.DATABASE_CHANGE)
                {
                        all = model.getDB().all();
                        createGlobalInterval();
                        Interval i = guessInitialViewInterval(all, globalInterval);
                        setTimeBounds(i.start, i.end);
                }
                if (e.affectsRowSet())
                {
                        all = model.getDB().all();
                        encoder.createVisualActs();
                        createGlobalInterval();
                } else
                {
                        encoder.createVisualActs();
                }
                Interval v = model.getViewInterval();
                if (v != null && v.start != timeScale.getInterval().start)
                {
                        timeScale.getInterval().translateTo(v.start);
                }
                updateVisuals();
        }

        private Interval guessInitialViewInterval(ActList acts, Interval fullRange)
        {
                if (acts.size() < 50)
                {
                        return fullRange.copy();
                }

                Interval best = null;
                int most = -1;
                double d = Math.max(.1, 50. / acts.size());
                d = Math.min(1. / 3, d);
                for (double x = 0; x < 1 - d; x += d / 4)
                {
                        Interval i = fullRange.subinterval(x, x + d);
                        TimeIntervalFilter f = new TimeIntervalFilter(i, getModel().getDB().getField(VirtualField.START));
                        int num = 0;
                        for (Act a : acts)
                        {
                                if (f.accept(a))
                                {
                                        num++;
                                }
                        }
                        if (num > most)
                        {
                                most = num;
                                best = i;
                        }
                }
                return best;
        }

        public void updateVisuals()
        {
                scale = 1;
                updateVisualEncoding();
                layout();
        }

        public TFModel getModel()
        {
                return model;
        }

        public int getNumTracks()
        {
                return trackList.size();
        }

        public double layout()
        {
                ActList acts = model.getActs();
                if (acts == null)
                {
                        return scale;
                }

                double labelHeight = 30;
                
                double min = bounds.height == 0 ? 0 : labelHeight / bounds.height;
                double cellH = (double)getModel().getDisplay().getInt("timeline.item.height.min") / bounds.height;
                
                double maxCount = 0;
                
                // Set the minimum scale
                for (TimelineTrack t : trackList)
                {
                        //double height = t.size() * scale / (double) numShown;

                        maxCount = Math.max(t.size(), maxCount);
                }

                scale = Math.min(cellH * numShown, scale);
                scale = Math.max(min * numShown / maxCount, scale);
                
                double top = 0;
                for (TimelineTrack t : trackList)
                {
                        double height = Math.max(min, t.size() * scale / (double) numShown);
                        t.layout(top, height, this);
                        top += height;
                }
                fullHeight = (int) (top * bounds.height);

                Collections.sort(trackList);
                frameChanged = false;
                
                return scale;
        }

        private void updateVisualEncoding()
        {
                java.util.List<VisualAct> acts = encoder.apply();

                // now arrange on tracks
                trackTable = new HashMap<String, TimelineTrack>();
                trackList = new ArrayList<TimelineTrack>();
                numShown = 0;
                for (VisualAct v : acts)
                {
                        if (!v.isVisible())
                        {
                                continue;
                        }
                        numShown++;
                        String s = v.getTrackString();
                        TimelineTrack t = trackTable.get(s);
                        if (t == null)
                        {
                                t = new TimelineTrack(s);
                                trackTable.put(s, t);
                                trackList.add(t);
                        }
                        t.add(v);
                        v.setTrack(t);
                }

                /*
                // the following code is no longer used, but could come in handy again one day...
                
                // If there is more than one "small" track, then we will coalesce them into
                // one bigger "miscellaneous" track.
                int minSize=numShown/30;//Math.max(3,numShown/30);
                ArrayList<TimelineTrack> small=new ArrayList<TimelineTrack>();
                for (TimelineTrack t: trackList)
                {
                if (t.size()<minSize)
                small.add(t);
                }
                if (small.size()>1)
                {
                // create a new Track for "miscellaneous."
                TimelineTrack misc=new TimelineTrack(Display.MISC_CODE);
                trackList.add(misc);
                trackTable.put(misc.label, misc);
                
                // remove the old tracks.
                for (TimelineTrack t:small)
                {
                trackList.remove(t);
                trackTable.remove(t.label);
                for (VisualAct v: t.visualActs)
                {
                v.setTrack(misc);
                misc.add(v);
                }
                }
                // sort miscellaneous items in time order.
                //Collections.sort(misc.visualActs);
                }
                 */

                for (TimelineTrack t : trackList)
                {
                        Collections.sort(t.visualActs);
                }
        }
}