/*******************************************************************************
 * Copyright (c) 2007 Michael Krkoska and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     Michael Krkoska - initial API and implementation
 *******************************************************************************/

package org.eclipse.jface.viewers;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

import org.eclipse.swt.SWT;
import org.eclipse.swt.graphics.Color;
import org.eclipse.swt.graphics.Font;
import org.eclipse.swt.graphics.GlyphMetrics;
import org.eclipse.swt.graphics.Image;
import org.eclipse.swt.graphics.TextLayout;
import org.eclipse.swt.graphics.TextStyle;
import org.eclipse.swt.widgets.Event;
import org.eclipse.swt.widgets.Listener;
import org.eclipse.swt.widgets.Table;
import org.eclipse.swt.widgets.TableColumn;
import org.eclipse.swt.widgets.TableItem;
import org.eclipse.swt.widgets.Tree;
import org.eclipse.swt.widgets.TreeColumn;
import org.eclipse.swt.widgets.TreeItem;


/**
 * A StyledLabelProvider which supports multiple lines per label. 
 * 
 * <p>
 * To set up a MultiLineLabelProvider and for your viewer's control, you must call
 * {@link MultiLineLabelProvider#setUpOwnerDraw(ColumnViewer)}
 * after adding all columns and add the MultiLineLabelProvider to the viewer.
 * </p>
 * @since 3.4
 * @author Michael Krkoska <michael.krkoska@gmail.com>
 */
public abstract class MultiLineLabelProvider extends StyledLabelProvider {

   public static void setUpOwnerDraw( final ColumnViewer viewer ) {
      StyledLabelProvider.setUpOwnerDraw(viewer);

      Listener l = new Listener() {

         public void handleEvent( Event event ) {
            IBaseLabelProvider provider = viewer.getLabelProvider();

            if ( provider instanceof MultiLineLabelProvider ) {
               ((MultiLineLabelProvider)provider).columnsResized(event);
            }
         }

      };
      if ( viewer.getControl() instanceof Table ) {
         Table table = (Table)viewer.getControl();
         TableColumn[] cols = table.getColumns();
         for ( int i = 0; i < cols.length; i++ ) {
            cols[i].addListener(SWT.Resize, l);
         }
      }
      else if ( viewer.getControl() instanceof Tree ) {
         Tree tree = (Tree)viewer.getControl();
         TreeColumn[] cols = tree.getColumns();
         for ( int i = 0; i < cols.length; i++ ) {
            cols[i].addListener(SWT.Resize, l);
         }
      }
   }

   private boolean wrapLines          = false;
   private int     measureHeightIndex = -1;
   private int     maxHeight          = 0;
   private int[]   knownColumnWidths;

   /**
    * Creates a new MultiLineLabelProvider.
    * 
    * @param style
    *           the style bits
    * @see StyledLabelProvider#CENTER_ITEMS_VERTICALLY
    * @see StyledLabelProvider#CENTER_TEXT_VERTICALLY
    */
   /* @see SWT#WRAP */
   public MultiLineLabelProvider( int style ) {
      super(style);
      if ( (SWT.WRAP & style) != 0 ) {
         // TODO Wrapping is deactivated as long as either Bug 130024 or Bug 148039 are still existing
         // wrapLines = true;
      }
   }

   protected TextLayout createTextLayout( Event event, String label, Image image, Font defaultFont, Color defaultBackground, Object element, int columnIndex ) {

      TextLayout layout = super.createTextLayout(event, label, image, defaultFont, defaultBackground, element, columnIndex);

      if ( centerTextVertically && image != null ) {
         int imageOffset = Math.max(0, label.indexOf(IMAGE_PLACEHOLDER));
         GlyphMetrics imageMetrics = layout.getStyle(imageOffset).metrics;

         if ( imageMetrics != null ) {
            int lineCount = layout.getLineCount();
            if ( lineCount > 1 ) {
               // do a different (unfortunately inferior) centering for multiline text
               // than in the single line case
               centerMultilineVertically(layout, defaultFont, imageMetrics, imageOffset);
            }
         }
      }

      if ( wrapLines ) {
         layout.setWidth(Math.max(getItemWidth(event), 16));
      }

      return layout;
   }

   protected void measure( Event event, Object element ) {
      super.measure(event, element);

      if ( measureHeightIndex == event.index ) {
         maxHeight = Math.max(event.getBounds().height, maxHeight);
      }
   }

   private void centerMultilineVertically( TextLayout layout, Font defaultFont, GlyphMetrics imageMetrics, int imageOffset ) {

      Font systemFont = layout.getDevice().getSystemFont();

      int maxFontHeight = 0;
      int lineIndex = layout.getLineIndex(imageOffset);
      int[] lineOffsets = layout.getLineOffsets();
      int lineStart = lineOffsets[lineIndex];
      int lineEnd = lineOffsets[lineIndex + 1] - 1;
      int oldEnd = -1;
      int[] ranges = layout.getRanges();
      TextStyle[] styles = layout.getStyles();
      List lineStyles = new ArrayList();

      for ( int i = 0, length = ranges.length; i < length; i += 2 ) {
         int start = ranges[i];
         int end = ranges[i + 1];

         if ( start > oldEnd + 1 ) {
            TextStyle style = new TextStyle(null, null, null);
            layout.setStyle(style, Math.max(oldEnd + 1, lineStart), Math.min(start - 1, lineEnd));
            lineStyles.add(style);
            Font font = getFirstNotNullFont(style.font, defaultFont, systemFont);
            maxFontHeight = Math.max(maxFontHeight, getFontHeight(font));
         }

         if ( start > lineEnd || end < lineStart ) {
            continue;
         }
         if ( start == imageOffset && end == imageOffset ) {
            oldEnd = end;
            continue;
         }

         TextStyle style = styles[i >> 1];
         if ( end > lineEnd ) {
            TextStyle clonedStyle = cloneStyle(style);
            layout.setStyle(clonedStyle, Math.max(start, lineStart), Math.min(end, lineEnd));
            lineStyles.add(clonedStyle);
            Font font = getFirstNotNullFont(style.font, defaultFont, systemFont);
            maxFontHeight = Math.max(maxFontHeight, getFontHeight(font));
         }
         else {
            lineStyles.add(style);
         }

         oldEnd = end;
      }
      if ( layout.getText().length() > oldEnd + 1 ) {
         TextStyle style = new TextStyle(null, null, null);
         layout.setStyle(style, Math.max(oldEnd + 1, lineStart), Math.min(layout.getText().length() - 1, lineEnd));
         lineStyles.add(style);
         Font font = getFirstNotNullFont(style.font, defaultFont, systemFont);
         maxFontHeight = Math.max(maxFontHeight, getFontHeight(font));
      }

      if ( imageMetrics.ascent > maxFontHeight ) {
         int height = imageMetrics.ascent;
         int space = (height - maxFontHeight);
         int rise = Math.round(space / 2f);
         for ( Iterator iterator = lineStyles.iterator(); iterator.hasNext(); ) {
            TextStyle style = (TextStyle)iterator.next();
            style.rise = rise;
         }
      }
   }

   private TextStyle cloneStyle( TextStyle style ) {
      TextStyle clone = new TextStyle(style.font, style.foreground, style.background);
      clone.rise = style.rise;
      clone.strikeout = style.strikeout;
      if ( style.metrics != null ) {
         clone.metrics = new GlyphMetrics(style.metrics.ascent, style.metrics.descent, style.metrics.width);
      }
      return clone;
   }

   private void columnsResized( Event event ) {
      if ( !wrapLines ) {
         return;
      }
      initKnownWidths(event);
      if ( event.widget instanceof TableColumn ) {
         TableColumn tc = (TableColumn)event.widget;
         int newWidth = tc.getWidth();
         if ( newWidth == knownColumnWidths[event.index] ) {
            return;
         }
         knownColumnWidths[event.index] = newWidth;
         int index = tc.getParent().indexOf(tc);
         measureHeightIndex = index;
         maxHeight = 0;
         tc.getParent().redraw();
         tc.getParent().update(); // trigger measure events for all visible items -> calculates maxHeight
         if ( maxHeight >= tc.getParent().getItemHeight() ) {
            return;
         }
         // TODO This is deactivated as long as either Bug 130024 or Bug 148039 are still existing
         // tc.getParent().setItemHeight(maxHeight);
         measureHeightIndex = -1;
         maxHeight = 0;
         tc.getParent().redraw();
         tc.getParent().update();
      }
      else if ( event.widget instanceof TreeColumn ) {
         TreeColumn tc = (TreeColumn)event.widget;
         int newWidth = tc.getWidth();
         if ( newWidth == knownColumnWidths[event.index] ) {
            return;
         }
         knownColumnWidths[event.index] = newWidth;
         int index = tc.getParent().indexOf(tc);
         measureHeightIndex = index;
         maxHeight = 0;
         tc.getParent().redraw();
         tc.getParent().update(); // trigger measure events for all visible items -> calculates maxHeight
         if ( maxHeight >= tc.getParent().getItemHeight() ) {
            return;
         }
         // TODO This is deactivated as long as either Bug 130024 or Bug 148039 are still existing
         // tc.getParent().setItemHeight(maxHeight);
         measureHeightIndex = -1;
         maxHeight = 0;
         tc.getParent().redraw();
         tc.getParent().update();
      }
   }

   private Font getFirstNotNullFont( Font f1, Font f2, Font f3 ) {
      if ( f1 != null ) {
         return f1;
      }
      if ( f2 != null ) {
         return f2;
      }
      return f3;
   }

   private int getItemWidth( Event event ) {
      if ( !wrapLines ) {
         return -1;
      }
      if ( event.item instanceof TableItem ) {
         return ((TableItem)event.item).getBounds(event.index).width;
      }
      if ( event.item instanceof TreeItem ) {
         return ((TreeItem)event.item).getBounds(event.index).width;
      }
      return -1;
   }

   private void initKnownWidths( Event event ) {
      if ( knownColumnWidths == null ) {
         if ( event.widget instanceof TableColumn ) {
            TableColumn tc = (TableColumn)event.widget;
            knownColumnWidths = new int[tc.getParent().getColumnCount()];
         }
         else if ( event.widget instanceof TreeColumn ) {
            TreeColumn tc = (TreeColumn)event.widget;
            knownColumnWidths = new int[tc.getParent().getColumnCount()];
         }
      }
   }
}