/*
      Copyright 2009 Ramon Servadei
   
      Licensed under the Apache License, Version 2.0 (the "License");
      you may not use this file except in compliance with the License.
      You may obtain a copy of the License at
   
          http://www.apache.org/licenses/LICENSE-2.0
   
     Unless required by applicable law or agreed to in writing, software
     distributed under the License is distributed on an "AS IS" BASIS,
     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     See the License for the specific language governing permissions and
     limitations under the License.
   */
  package fulmine.ui;
  
  import java.awt.BorderLayout;
  import java.awt.Color;
  import java.awt.Component;
  import java.util.Collection;
  import java.util.Iterator;
  import java.util.List;
  import java.util.TimerTask;
  
  import javax.swing.JPanel;
  import javax.swing.JScrollPane;
  import javax.swing.JTabbedPane;
  import javax.swing.JTable;
  import javax.swing.SwingUtilities;
  import javax.swing.table.DefaultTableCellRenderer;
  import javax.swing.table.DefaultTableModel;
  import javax.swing.table.TableColumn;
  
  import org.apache.commons.logging.Log;
  
  import fulmine.context.IFulmineContext;
  import fulmine.event.IEvent;
  import fulmine.event.IEventSource;
  import fulmine.event.listener.IEventListener;
  import fulmine.model.container.IContainer.DataState;
  import fulmine.model.container.events.ContainerFieldAddedEvent;
  import fulmine.model.container.events.ContainerFieldRemovedEvent;
  import fulmine.model.container.events.ContainerStateChangeEvent;
  import fulmine.model.container.impl.Record;
  import fulmine.model.field.IField;
  import fulmine.util.Utils;
  import fulmine.util.collection.CollectionFactory;
  import fulmine.util.log.AsyncLog;
  import fulmine.util.reference.AutoCreatingStore;
  import fulmine.util.reference.IAutoCreatingStore;
  import fulmine.util.reference.IObjectBuilder;
  
  /**
   * A component that provides a read-only view of a record. All the
   * {@link IField}s of a {@link Record} are displayed as a series of key-value
   * pairs. As fields are added/removed, so too are the key-value pairs in the
   * panel. Multiple records are displayed in separate tabs.
   * <p>
   * The viewer itself is an {@link IEventListener} so can be used as the listener
   * for record subscriptions. It is thread safe for handling updates from the
   * {@link IFulmineContext} framework - they are spun off onto the AWT thread for
   * processing. If the viewer is used to subscribe to multiple records, each
   * record is shown in a separate tab.
   * <p>
   * This is intended as a demonstration class for building more sophisticated
   * record-based UIs based on the {@link IFulmineContext} framework.
   * <p>
   * Note: this does not remove records from the panel when they are destroyed, it
   * simply renders the fields as 'disabled'.
   * 
   * @author Ramon Servadei
   */
  public class RecordViewer extends JPanel implements IEventListener
  {
      private final static Log LOG = new AsyncLog(RecordViewer.class);
  
      private static final long serialVersionUID = 1L;
  
      /**
       * A panel that displays a single record. The fields are shown as a list.
       * 
       * @author Ramon Servadei
       */
      class RecordPanel extends JPanel implements IEventListener
      {
          private static final long serialVersionUID = 1L;
  
          /** Index of the value column */
          private static final int VALUE_COLUMN_INDEX = 1;
  
          /** The table model */
          private final DefaultTableModel model = new DefaultTableModel(1, 2);
  
          /** The table backing the panel view of a record */
          private final JTable table = new JTable(model);
  
          /**
           * Holds the field names being shown as rows in the table. The index of
          * each field is also row number for the field.
          */
         private final List<String> fieldNames = CollectionFactory.newList(1);
 
         /** Handles all the table update redraw logic */
         private final TableUpdateHandler updateHandler =
             new TableUpdateHandler();
 
         /** Indicates if the data being shown is live or stale */
         private boolean stale = false;
 
         /**
          * Applies background format changes to highlight data changes
          * 
          * @author Ramon Servadei
          */
         class UpdatingHighlightingRenderer extends DefaultTableCellRenderer
         {
 
             private static final long serialVersionUID = 1L;
 
             @SuppressWarnings("boxing")
             @Override
             public Component getTableCellRendererComponent(final JTable table,
                 Object value, boolean isSelected, boolean hasFocus,
                 final int row, int column)
             {
                 final int convertedColumn =
                     table.convertColumnIndexToModel(column);
                 final Iterator<Integer> iterator =
                     RecordPanel.this.updateHandler.getUpdated().get(row).iterator();
                 final Component renderer =
                     super.getTableCellRendererComponent(table, value,
                         isSelected, hasFocus, row, column);
                 renderer.setBackground(Color.white);
                 renderer.setForeground(Color.black);
                 if (RecordPanel.this.stale)
                 {
                     renderer.setForeground(Color.gray);
                 }
                 while (iterator.hasNext())
                 {
                     final Integer next = iterator.next();
                     if (next.equals(convertedColumn))
                     {
                         iterator.remove();
                         // NOTE: this is a quick an dirty solution - should
                         // really use a format object and interrogate the object
                         // to get the format to display - see RecordTable
                         renderer.setBackground(Color.CYAN);
                         TableUpdateHandler.updateTimer.schedule(new TimerTask()
                         {
                             @Override
                             public void run()
                             {
                                 SwingUtilities.invokeLater(new Runnable()
                                 {
                                     public void run()
                                     {
                                         // trigger another render update
                                         ((DefaultTableModel) table.getModel()).fireTableCellUpdated(
                                             row, convertedColumn);
                                     }
                                 });
                             }
                         }, 500);
                     }
                 }
                 return renderer;
             }
 
         }
 
         public RecordPanel()
         {
             super(true);
             init();
         }
 
         public RecordPanel(boolean isDoubleBuffered)
         {
             super(isDoubleBuffered);
             init();
         }
 
         private void init()
         {
             setLayout(new BorderLayout());
             this.table.setAutoResizeMode(JTable.AUTO_RESIZE_OFF);
             add(new JScrollPane(this.table));
             this.table.setEnabled(false);
             this.table.getTableHeader().getColumnModel().getColumn(0).setHeaderValue(
                 "field name");
             final TableColumn valueColumn =
                 this.table.getTableHeader().getColumnModel().getColumn(
                     VALUE_COLUMN_INDEX);
             valueColumn.setHeaderValue("field value");
             valueColumn.setCellRenderer(new UpdatingHighlightingRenderer());
         }
 
         public void addedAsListenerFor(IEventSource source)
         {
             // noop
         }
 
         public Class<? extends IEvent>[] getEventTypeFilter()
         {
             return RecordTable.eventFilter;
         }
 
         public void removedAsListenerFrom(IEventSource source)
         {
             // noop
         }
 
         public void update(final IEvent event)
         {
             /*
              * All update logic is done in the Swing thread to avoid concurrency
              * issues. This may be tuned to get better performance out of the UI
              * at a later time.
              */
             SwingUtilities.invokeLater(new Runnable()
             {
                 public void run()
                 {
                     if (event instanceof Record)
                     {
                         handle((Record) event);
                         return;
                     }
                     if (event instanceof ContainerStateChangeEvent)
                     {
                         handle((ContainerStateChangeEvent) event);
                         return;
                     }
                     if (event instanceof ContainerFieldAddedEvent)
                     {
                         handle((ContainerFieldAddedEvent) event);
                         return;
                     }
                     if (event instanceof ContainerFieldRemovedEvent)
                     {
                         handle((ContainerFieldRemovedEvent) event);
                         return;
                     }
                     if (LOG.isDebugEnabled())
                     {
                         LOG.debug("Unhandled event: "
                             + Utils.safeToString(event));
                     }
                 }
 
             });
         }
 
         /**
          * Handle a field removed from a container
          * 
          * @param event
          *            the event encapsulating the field removal
          */
         void handle(ContainerFieldRemovedEvent event)
         {
             removeField(event.getField());
         }
 
         /**
          * Handle a field added to a container
          * 
          * @param event
          *            the event encapsulating the field addition
          */
         void handle(ContainerFieldAddedEvent event)
         {
             addField(event.getField());
         }
 
         /**
          * An idempotent operation that adds a new field to the panel. If the
          * field already exists, this method does nothing.
          * 
          * @param field
          *            the field
          */
         private void addField(final IField field)
         {
             final String fieldName = getFieldId(field);
             if (!this.fieldNames.contains(fieldName))
             {
                 this.fieldNames.add(fieldName);
                 this.model.insertRow(fieldNames.size() - 1, new Object[] {
                     fieldName, field.getValueAsString() });
             }
         }
 
         /**
          * Remove a field
          * 
          * @param field
          */
         private void removeField(final IField field)
         {
             final String fieldName = getFieldId(field);
             if (this.fieldNames.contains(fieldName))
             {
                 final int index = this.fieldNames.indexOf(fieldName);
                 this.fieldNames.remove(index);
                 this.model.removeRow(index);
             }
         }
 
         private String getFieldId(final IField field)
         {
             /*
              * The address is too verbose, only problem is duplicate identities
              * but different types/domains are not handled now
              */
             // return field.getAddress();
             return field.getIdentity();
         }
 
         /**
          * Handle a record state change event.
          * 
          * @param event
          *            the record state change event
          */
         void handle(ContainerStateChangeEvent event)
         {
             // nothing to do
         }
 
         /**
          * Handle a change to a record
          * 
          * @param record
          *            the record
          */
         @SuppressWarnings("boxing")
         void handle(Record event)
         {
             final Collection<IField> changedFields = event.getChangedFields();
             for (IField field : changedFields)
             {
                 addField(field);
                 final int row = fieldNames.indexOf(getFieldId(field));
                 this.updateHandler.getUpdated().get(row).add(VALUE_COLUMN_INDEX);
                 this.model.setValueAt(field.getValueAsString(), row,
                     VALUE_COLUMN_INDEX);
             }
             if (event.getDataState() == DataState.STALE)
             {
                 this.stale = true;
             }
             else
             {
                 this.stale = false;
             }
         }
     }
 
     /** Holds the panel displaying each record, identified by its address */
     private final IAutoCreatingStore<String, RecordPanel> panels =
         new AutoCreatingStore<String, RecordPanel>(
             new IObjectBuilder<String, RecordPanel>()
             {
                 public RecordPanel create(String key)
                 {
                     final RecordPanel component = new RecordPanel();
                     RecordViewer.this.tabs.addTab(key, component);
                     return component;
                 }
             });
 
     private final JTabbedPane tabs;
 
     public RecordViewer()
     {
         super();
         setLayout(new BorderLayout());
         this.tabs = new JTabbedPane();
         add(this.tabs);
     }
 
     public void addedAsListenerFor(IEventSource source)
     {
         // noop
     }
 
     public Class<? extends IEvent>[] getEventTypeFilter()
     {
         return RecordTable.eventFilter;
     }
 
     public void removedAsListenerFrom(IEventSource source)
     {
         // noop
     }
 
     public void update(IEvent event)
     {
         final String source = event.getSource().getAddress();
         this.panels.get(source).update(event);
     }
 }