package timeflow.vis.calendar;

import timeflow.data.time.*;
import timeflow.model.Display;
import timeflow.vis.*;

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

public class Grid
{

        TimeUnit rowUnit, columnUnit;
        RoughTime startRow, endRow;
        Interval interval;
        HashMap<Long, GridCell> cells;
        int[] screenGridX;
        int cellHeight = 80, cellWidth, numCols, numRows;
        Rectangle bounds = new Rectangle();
        int dy;
        static final DateFormat dayOfWeek = new SimpleDateFormat("EEE");
        static final DateFormat month = new SimpleDateFormat("MMM d");
        static final String[] day =
        {
                "SUN", "MON", "TUES", "WED", "THURS", "FRI", "SAT"
        };

        Grid(TimeUnit rowUnit, TimeUnit columnUnit, Interval interval)
        {
                this.rowUnit = rowUnit;
                this.columnUnit = columnUnit;
                numCols = columnUnit.numUnitsIn(rowUnit);
                setInterval(interval);
        }

        public void setDY(int dy)
        {
                this.dy = dy;
        }

        public int getCalendarHeight()
        {
                return bounds.height + bounds.y + 20;
        }

        public RoughTime getTime(int x, int y)
        {
                y += dy;
                if (!bounds.contains(x, y))
                {
                        return null;
                }

                // find grid coordinates.
                int gridX = (x - bounds.x) / cellWidth;
                int gridY = (y - bounds.y) / cellHeight;

                return startRow.plus(rowUnit, gridY).plus(columnUnit, gridX);
        }

        public double getScrollFraction()
        {
                double x = (getFirstDrawnTime().getTime() - startRow.getTime()) / (double) (endRow.getTime() - startRow.getTime());
                if (x < 0)
                {
                        return 0;
                }
                if (x > 1)
                {
                        return 1;
                }
                return x;
        }

        public RoughTime getFirstDrawnTime()
        {
                int gridY = (dy - bounds.y) / cellHeight;

                return startRow.plus(rowUnit, gridY);
        }

        private Point getGridCorner(long timestamp)
        {
                int diff = (int) columnUnit.difference(timestamp, startRow.getTime());
                int gridX = diff % numCols;
                int gridY = diff / numCols;
                return new Point(gridX, gridY);
        }

        public Rectangle getCell(long timestamp)
        {
                Point p = getGridCorner(timestamp);
                return new Rectangle(bounds.x + p.x * cellWidth, bounds.y + p.y * cellHeight - dy,
                        cellWidth, cellHeight);
        }

        void setInterval(Interval interval)
        {
                this.interval = interval;
                startRow = rowUnit.roundDown(interval.start);
                endRow = rowUnit.roundDown(interval.end);
                numRows = 1 + (int) (rowUnit.difference(endRow.getTime(), startRow.getTime()));

                // the next line fixes a problem with multi-century data sets.
                // it works, but there's probably a better way to do this :-)
                if (numRows > 50 && rowUnit.getRoughSize() >= TimeUnit.YEAR.getRoughSize())
                {
                        numRows++;
                }
        }

        void makeCells(java.util.List<VisualAct> visualActs)
        {
                cells = new HashMap<Long, GridCell>();
                for (VisualAct v : visualActs)
                {
                        if (v.getStart() == null)
                        {
                                continue;
                        }
                        long timestamp = v.getStart().getTime();
                        RoughTime timeKey = columnUnit.roundDown(timestamp);
                        GridCell cell = cells.get(timeKey.getTime());
                        if (cell == null)
                        {
                                cell = new GridCell(timeKey);
                                cells.put(timeKey.getTime(), cell);
                                Point p = getGridCorner(timestamp);
                                cell.gridX = p.x;
                                cell.gridY = p.y;
                        }
                        cell.visualActs.add(v);
                }
        }

        void render(Graphics2D g, Display display, Rectangle screenBounds, CalendarVisuals visuals,
                Collection<Mouseover> objectLocations)
        {
                g.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
                int left = 110, right = 20;
                int padY = 50;
                boolean shouldLabel = visuals.drawStyle == CalendarVisuals.DrawStyle.LABEL;

                cellWidth = (screenBounds.width - left - right) / numCols;

                boolean fitTight = visuals.fitStyle == CalendarVisuals.FitStyle.TIGHT;
                int idealHeight = fitTight ? 12 : Display.CALENDAR_CELL_HEIGHT;
                cellHeight = Math.max(idealHeight, (screenBounds.height - padY - 10) / numRows);
                this.bounds.setBounds(left, padY, numCols * cellWidth, numRows * cellHeight);

                g.setColor(new Color(240, 240, 240));//Color.white);
                g.fill(screenBounds);
                g.setColor(new Color(245, 245, 245));
                g.drawRect(bounds.x, bounds.y - dy, bounds.width, bounds.height);
                g.setFont(display.bold());

                // draw vertical grid lines.
                Color gridColor = new Color(220, 220, 220);

                for (int i = 0; i <= numCols; i++)
                {
                        int x = bounds.x + i * cellWidth;
                        g.setColor(gridColor);
                        g.drawLine(x, bounds.y - dy, x, bounds.y + bounds.height - dy);
                        if (rowUnit == TimeUnit.WEEK && i < 7)
                        {
                                g.setColor(Color.gray);
                                g.drawString(day[i], x, bounds.y - dy - 6);
                        }
                }

                // horizontal grid lines.
                RoughTime labelTime = startRow.copy();
                int lastLabelY = -100;
                int lastYear = -1000000;
                FontMetrics fm = display.boldFontMetrics();
                int skipped = 0;
                for (int i = 0; i < numRows; i++)
                {
                        int y = bounds.y + i * cellHeight;
                        if (y - dy > -50)
                        {
                                if (skipped > 0)
                                {
                                        rowUnit.addTo(labelTime, skipped);
                                        skipped = 0;
                                }
                                g.setColor(gridColor);
                                g.drawLine(bounds.x, y - dy, bounds.x + bounds.width, y - dy);
                                if (y - lastLabelY > 30 || lastLabelY < 0)
                                {
                                        String label = null;
                                        if (rowUnit == TimeUnit.WEEK)
                                        {
                                                int year = TimeUtils.cal(labelTime.getTime()).get(Calendar.YEAR);
                                                if (year != lastYear)
                                                {
                                                        label = labelTime.format();
                                                } else
                                                {
                                                        label = month.format(labelTime.toDate());
                                                }
                                                lastYear = year;
                                        } else
                                        {
                                                label = labelTime.format();
                                        }
                                        g.setColor(Color.gray);
                                        g.drawString(label, bounds.x - fm.stringWidth(label) - 15, y + 15 - dy);
                                        lastLabelY = y;
                                }
                                if (y - dy > screenBounds.height)
                                {
                                        break;
                                }

                                // now draw, in gray, the labels for each of the boxes.
                                if (!fitTight)
                                {
                                        RoughTime gridLabel = labelTime.copy();
                                        int labelH = 13;
                                        for (int j = 0; j < numCols; j++)
                                        {

                                                g.setColor(Color.gray);
                                                g.setFont(display.bold());
                                                String label = columnUnit.format(gridLabel.toDate());
                                                g.drawString(label, bounds.x + j * cellWidth + 3, y - dy + labelH);
                                                columnUnit.addTo(gridLabel);
                                        }
                                }
                                rowUnit.addTo(labelTime);
                        } else
                        {
                                skipped++;
                        }
                }

                // draw a frame around the whole thing.
                g.setColor(Color.darkGray);
                g.drawRect(bounds.x, bounds.y - dy, bounds.width, bounds.height);

                // draw backgrounds
                for (GridCell cell : cells.values())
                {
                        // are any visible?
                        boolean visible = false;
                        for (VisualAct v : cell.visualActs)
                        {
                                if (v.isVisible())
                                {
                                        visible = true;
                                        break;
                                }
                        }
                        int cx = bounds.x + cell.gridX * cellWidth;
                        int cy = bounds.y + cell.gridY * cellHeight - dy;

                        if (cy < screenBounds.y - 50 || cy > screenBounds.y + screenBounds.height + 50)
                        {
                                continue;
                        }

                        // label top of cell.
                        int labelH = 0;
                        g.setColor(new Color(240, 240, 240));

                        if (visible)
                        {
                                g.setColor(Color.white);
                                g.fillRect(cx + 1, cy + 1, cellWidth - 1, cellHeight - 1);
                        }
                        if (cellHeight > 42)
                        {
                                labelH = 13;
                                g.setColor(Color.darkGray);
                                g.setFont(display.bold());
                                String label = columnUnit.format(cell.time.toDate());
                                g.drawString(label, cx + 3, cy + labelH);
                        }

                }



                // draw items.
                int mx = 10, my = shouldLabel ? 18 : 10;
                for (GridCell cell : cells.values())
                {

                        int cx = bounds.x + cell.gridX * cellWidth;
                        int cy = bounds.y + cell.gridY * cellHeight - dy;

                        if (cy < screenBounds.y - 50 || cy > screenBounds.y + screenBounds.height + 50)
                        {
                                continue;
                        }

                        // label top of cell.
                        int labelH = cellHeight > 42 ? 13 : 0;

                        // now draw the items in the cell.
                        // old, non-aggregation code:

                        // START AGGREGATION CODE

                        ArrayList<VisualAct> visibleActs = new ArrayList<VisualAct>();
                        for (VisualAct v : cell.visualActs)
                        {
                                if (v.isVisible())
                                {
                                        visibleActs.add(v);
                                }
                        }
                        Iterator<VisualAct> vacts =
                                VisualActFactory.makeEmFit(visuals.model, visibleActs, new Rectangle(cx, cy, cellWidth, cellHeight)).iterator();

                        // END AGGREGATION CODE

                        int leftX = 6;
                        int cdx = leftX;
                        int topDotY = Math.min(labelH + 16, cellHeight / 2);
                        int cdy = topDotY;
                        while (vacts.hasNext())
                        {
                                VisualAct v = vacts.next();
                                if (!v.isVisible())
                                {
                                        continue;
                                }

                                // set x,y, room to right.
                                int x = cx + cdx;
                                int y = cy + cdy;

                                int space = cellWidth - 20;
                                v.setX(x);
                                v.setY(y);
                                v.setSpaceToRight(space);
                                Mouseover o = v.draw(g, new Rectangle(cx + 1, cy + labelH + 1, cellWidth - 2, cellHeight - 2 - labelH),
                                        bounds, display, shouldLabel, false);
                                if (o != null)
                                {
                                        objectLocations.add(o);
                                }

                                // go to next location. if we're labeling, we do this vertically.
                                // otherwise, left-to-right, then top-to-bottom.

                                if (shouldLabel)
                                {
                                        cdy += my;
                                        if (cdy > cellHeight - 2 - my)
                                        {
                                                g.drawString("...", x, y + my);
                                                break;
                                        }
                                } else
                                {
                                        cdx += mx;
                                        if (cdx > cellWidth - mx / 2 - 2 && vacts.hasNext())
                                        {
                                                cdx = leftX;
                                                cdy += my;
                                                if (cdy > cellHeight - my / 2)
                                                {
                                                        break;
                                                }
                                        }
                                }
                        }
                }
        }
}