package timeflow.vis;

import java.awt.Color;
import java.awt.Rectangle;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;

import timeflow.data.db.Act;
import timeflow.data.db.ActDB;
import timeflow.data.db.ActList;
import timeflow.data.db.Field;
import timeflow.model.TFModel;
import timeflow.model.VirtualField;

public class VisualActFactory
{
        // create one VisualAct per Act

        private static java.util.List<VisualAct> create(ActList acts)
        {
                java.util.List<VisualAct> list = new ArrayList<VisualAct>();
                for (Act a : acts)
                {
                        VisualAct v = new TagVisualAct(a);
                        list.add(v);
                }
                return list;
        }

        // create one VisualAct per Act/tag combo.
        public static java.util.List<VisualAct> create(ActList acts, Field tagField, boolean multipleColors)
        {
                if (tagField == null || tagField.getType() == String.class)
                {
                        return create(acts);
                }
                java.util.List<VisualAct> list = new ArrayList<VisualAct>();
                for (Act a : acts)
                {
                        String[] tags = a.getTextList(tagField);
                        if (tags == null || tags.length < 2)
                        {
                                VisualAct v = new TagVisualAct(a);
                                if (tags != null && tags.length == 1)
                                {
                                        v.setTrackString(tags[0]);
                                }
                                list.add(v);
                        } else
                        {
                                for (String tag : tags)
                                {
                                        VisualAct v = multipleColors ? new TagVisualAct(a) : new VisualAct(a);
                                        v.setTrackString(tag);
                                        list.add(v);
                                }
                        }
                }
                return list;
        }

        public static Collection<VisualAct> makeEmFit(TFModel model, ArrayList<VisualAct> vacts, Rectangle bounds)
        {
                // Does everything fit? Because, if so, we're already good to go.
                int area = bounds.width * bounds.height;
                int room = area / 200;
                if (vacts.size() <= room)
                {
                        return vacts;
                }

                ArrayList<VisualAct> results = new ArrayList<VisualAct>();

                // OK. If:
                //     * there's room for more than one item, and  
                //     * there's more than one color in use,
                //
                // Then let's see how many colors there are. Maybe we can do one bubble per color.
                ActDB db = model.getDB();
                if (room > 1 && (db.getField(VirtualField.COLOR) != null || db.getField(VirtualField.TRACK) != null))
                {
                        HashMap<Color, ArrayList<VisualAct>> colorGroupings = new HashMap<Color, ArrayList<VisualAct>>();
                        for (VisualAct v : vacts)
                        {
                                Color c = v.color;
                                ArrayList<VisualAct> grouping = colorGroupings.get(c);
                                if (grouping == null)
                                {
                                        grouping = new ArrayList<VisualAct>();
                                        colorGroupings.put(c, grouping);
                                }
                                grouping.add(v);
                        }

                        if (colorGroupings.size() <= room) // Great! The colors fit. We now return one group VisualAct per color.
                        {
                                for (Color c : colorGroupings.keySet())
                                {
                                        ArrayList<VisualAct> grouping = colorGroupings.get(c);
                                        if (grouping.size() == 1)
                                        {
                                                results.add(grouping.get(0));
                                        } else if (grouping.size() > 1)
                                        {
                                                results.add(new GroupVisualAct(grouping, false, bounds));
                                        }
                                }
                                return results;
                        }
                }

                // OK, too bad, even that doesn't fit. We will just create one fat VisualAct
                // that descibes the aggregate. C'est la vie!

                results.add(new GroupVisualAct(vacts, true, bounds));
                return results;
        }
}