/*
 *                 Sun Public License Notice
 * 
 * The contents of this file are subject to the Sun Public License
 * Version 1.0 (the "License"). You may not use this file except in
 * compliance with the License. A copy of the License is available at
 * http://www.sun.com/
 * 
 * The Original Code is NetBeans. The Initial Developer of the Original
 * Code is Sun Microsystems, Inc. Portions Copyright 1997-2003 Sun
 * Microsystems, Inc. All Rights Reserved.
 */

package org.netbeans.editor;

import java.awt.Color;
import java.awt.Container;
import java.awt.Font;
import java.awt.FontMetrics;
import java.awt.Graphics;
import java.awt.Point;
import java.awt.Rectangle;
import java.awt.Shape;
import javax.swing.JComponent;
import javax.swing.event.DocumentEvent;
import javax.swing.text.AttributeSet;
import javax.swing.text.BadLocationException;
import javax.swing.text.Caret;
import javax.swing.text.Document;
import javax.swing.text.Element;
import javax.swing.text.JTextComponent;
import javax.swing.text.Position;
import javax.swing.text.View;
import javax.swing.text.ViewFactory;
import org.netbeans.editor.ext.ExtEditorUI;
import org.netbeans.editor.ext.ToolTipSupport;
import org.netbeans.editor.view.spi.LockView;

/**
 * View over collapsed area of the fold.
 * 

 * The collapsed area spans one or more lines and it is presented as three dots.
 *
 * @author Martin Roskanin
 */
class CollapsedView extends View implements SettingsChangeListener {

    private Position startPos;
    
    private Position endPos;
    
    private String foldDescription;

    private Font font;
    
    private Color foreColor;
    
    private Color backColor;
    
    
    /** Creates a new instance of CollapsedView */
    public CollapsedView(Element elem, Position startPos, Position endPos, String foldDescription) {
        super(elem);
        
        this.startPos = startPos;
        this.endPos = endPos;
        this.foldDescription = foldDescription;
        Settings.addSettingsChangeListener(this);
    }
    
    private JTextComponent getComponent() {
        return (JTextComponent)getContainer();
    }
    
    private BaseTextUI getBaseTextUI(){
        JTextComponent comp = getComponent();
        return (comp!=null)?(BaseTextUI)comp.getUI():null;
    }
    
    private EditorUI getEditorUI(){
        BaseTextUI btui = getBaseTextUI();
        return (btui!=null) ? btui.getEditorUI() : null;
    }
    
    public void insertUpdate(DocumentEvent e, Shape a, ViewFactory f) {
    }
    
    public void removeUpdate(DocumentEvent e, Shape a, ViewFactory f) {
    }
    
    public void changedUpdate(DocumentEvent e, Shape a, ViewFactory f) {
    }
    
    public Document getDocument() {
        View parent = getParent();
        return (parent == null) ?  null : parent.getDocument();
    }
    
    public int getStartOffset() {
        return startPos.getOffset();
    }
    
    public int getEndOffset() {
        return endPos.getOffset();
    }
    
    protected void forwardUpdate(DocumentEvent.ElementChange ec, 
				      DocumentEvent e, Shape a, ViewFactory f) {
    }
    
    protected void forwardUpdateToView(View v, DocumentEvent e, 
					   Shape a, ViewFactory f) {
    }
    
    public float getAlignment(int axis) {
	return 0f;
    }
    
    public float getPreferredSpan(int axis){
        switch (axis) {
            case Y_AXIS:
                return getEditorUI().getLineHeight();
            case X_AXIS:
                return getCollapsedFoldStringWidth();
        }
        return 1f;
    }

    
    private int getCollapsedFoldStringWidth() {
        JTextComponent comp = getComponent();
        if (comp==null) return 0;
        FontMetrics fm = FontMetricsCache.getFontMetrics(getColoringFont(), comp);
        if (fm==null) return 0;
        return fm.stringWidth(foldDescription);
    }
    
    public Shape modelToView(int pos, Shape a, Position.Bias b) throws BadLocationException {
        return new Rectangle(a.getBounds().x, a.getBounds().y, getCollapsedFoldStringWidth(), getEditorUI().getLineHeight());
    }
    
    public int viewToModel(float x, float y, Shape a, Position.Bias[] biasReturn) {
        return getStartOffset();
    }
    
    public void paint(Graphics g, Shape allocation){
        Rectangle allocRect = allocation.getBounds();
        g.setColor(getBackColor());
        int x = allocRect.x+2;
        int y = allocRect.y;
        int width = allocRect.width-1;
        int height = allocRect.height-1;
        g.fillRect(x, y, width, height);
        g.setColor(getForeColor());
        g.setFont(getColoringFont());
        g.drawRect(x, y, width, height);
        g.drawString(foldDescription, x, y + getEditorUI().getLineAscent()-1);
    }
    
    public int getNextVisualPositionFrom(int pos, Position.Bias b, Shape a, 
					 int direction, Position.Bias[] biasRet) 
      throws BadLocationException {
	biasRet[0] = Position.Bias.Forward;
	switch (direction) {
	case NORTH:
	case SOUTH:
	{
	    JTextComponent target = (JTextComponent) getContainer();
	    Caret c = (target != null) ? target.getCaret() : null;
	    // YECK! Ideally, the x location from the magic caret position
	    // would be passed in.
	    Point mcp;
	    if (c != null) {
		mcp = c.getMagicCaretPosition();
	    }
	    else {
		mcp = null;
	    }
	    int x;
	    if (mcp == null) {
		Rectangle loc = target.modelToView(pos);
		x = (loc == null) ? 0 : loc.x;
	    }
	    else {
		x = mcp.x;
	    }
	    if (direction == NORTH) {
		pos = Utilities.getPositionAbove(target, pos, x);
	    }
	    else {
		pos = Utilities.getPositionBelow(target, pos, x);
	    }
	}
	    break;
	case WEST:
	    if(pos == -1) {
		pos = Math.max(0, getStartOffset());
	    }
	    else {
                if (b == Position.Bias.Backward){
                    pos = Math.max(0, getStartOffset());
                }else{
                    pos = Math.max(0, getStartOffset() - 1);
                }
	    }
	    break;
	case EAST:
	    if(pos == -1) {
		pos = getStartOffset();
	    }
	    else {
		pos = Math.min(getEndOffset(), getDocument().getLength());
                //JTextComponent target = (JTextComponent) getContainer();
                //if (target!=null && Utilities.getRowEnd(target, pos) == pos) pos = Math.min(pos+1, getDocument().getLength());
	    }
	    break;
	default:
	    throw new IllegalArgumentException("Bad direction: " + direction); // NOI18N
	}
	return pos;
    }    

    private View getExpandedView(){
        Element parentElem = getElement().getParentElement();
        int sei = parentElem.getElementIndex(getStartOffset());
        int so = parentElem.getElement(sei).getStartOffset();
        
        int eei = parentElem.getElementIndex(getEndOffset());
        int eo = parentElem.getElement(eei).getEndOffset();
        
        LockView fakeView = new LockView(
        new DrawEngineFakeDocView(parentElem, so, eo, false)
        );
        RootView rootView = new RootView();
        rootView.setView(fakeView);
        return fakeView;
    }
    
    public String getToolTipText(float x, float y, Shape allocation){
        ToolTipSupport tts = ((ExtEditorUI)getEditorUI()).getToolTipSupport();
        JComponent toolTip = new FoldingToolTip(getExpandedView(), getEditorUI());
        tts.setToolTip(toolTip, PopupManager.ScrollBarBounds, PopupManager.BelowPreferred, -FoldingToolTip.BORDER_WIDTH, 0);
        return "";
    }
    
    public void settingsChange(SettingsChangeEvent evt) {
        if (evt == null || org.netbeans.editor.Utilities.getKitClass(getComponent()) != evt.getKitClass()) return;
        
        String defaultColoringName = SettingsNames.DEFAULT_COLORING+SettingsNames.COLORING_NAME_SUFFIX;
        String foldingColoringName = SettingsNames.CODE_FOLDING_COLORING+SettingsNames.COLORING_NAME_SUFFIX;
        EditorUI editorUI = getEditorUI();
        if (editorUI==null) return;
        Coloring foldingColoring = editorUI.getColoring(SettingsNames.CODE_FOLDING_COLORING);
        Coloring defaultColoring = editorUI.getDefaultColoring();
        
        Font foldingFont = null;
        Color foldingForeColor = null;
        Color foldingBackColor = null;
        if (foldingColoring!=null){
            foldingFont = foldingColoring.getFont();
            foldingForeColor = foldingColoring.getForeColor();
            foldingBackColor = foldingColoring.getBackColor();
        }
        
        if (defaultColoringName.equals(evt.getSettingName())){
            
            if (foldingForeColor == null){
                // inherited fore color
                Color tempColor = getDefaultForeColor();
                if (!tempColor.equals(foreColor)){
                    foreColor = tempColor;
                }
            }

            if (foldingBackColor == null){
                // inherited back color
                Color tempColor = getDefaultBackColor();
                if (!tempColor.equals(backColor)){
                    backColor = tempColor;
                }
            }
            
            // Font size change
            Font tempFont = getDefaultColoringFont();
            if (!tempFont.equals(font) && foldingFont==null){
                // if different font and foldingFont is inherited
                font = tempFont;
                //setPreferredSize(new Dimension(font.getSize(), component.getHeight()));
            }
            //repaint();
            
        }else if (foldingColoringName.equals(evt.getSettingName())){
            // Code folding coloring change
            if (foldingColoring == null) return;

            Color tempColor = foldingColoring.getForeColor();
            foreColor = (tempColor!=null) ? tempColor : getDefaultForeColor();
            
            tempColor = foldingColoring.getBackColor();
            backColor = (tempColor!=null) ? tempColor : getDefaultBackColor();
            
            if (foldingFont == null){ //inherit
                Font tempFont = getDefaultColoringFont();
                if (!tempFont.equals(font)){
                    font = tempFont;
                    //setPreferredSize(new Dimension(font.getSize(), component.getHeight()));
                }
            }else{
                if (!foldingFont.equals(font)){
                    font = foldingFont;
                    //setPreferredSize(new Dimension(font.getSize(), component.getHeight()));
                }
            }
            
            //repaint();
        }
    }
    
    private Font getDefaultColoringFont(){
        // font in folding coloring not available, get default (or inherited)
        EditorUI editorUI = getEditorUI();
        if (editorUI!=null){
            Coloring defaultColoring = editorUI.getDefaultColoring();
            if (defaultColoring!=null){
                if (defaultColoring.getFont() != null){
                    return defaultColoring.getFont(); 
                }
            }
        }
        return SettingsDefaults.defaultFont;
    }
    
    protected Font getColoringFont(){
        if (font != null) return font;
        EditorUI editorUI = getEditorUI();
        if (editorUI!=null){
            Coloring foldColoring = editorUI.getColoring(SettingsNames.CODE_FOLDING_COLORING);
            if (foldColoring != null){
                if (foldColoring.getFont()!=null){
                    font = foldColoring.getFont();
                    return font;
                }
            }
        }
        font = getDefaultColoringFont();
        return font;
    }
    
    protected Color getForeColor(){
        if (foreColor != null) return foreColor;
        EditorUI editorUI = getEditorUI();
        if (editorUI!=null){
            Coloring foldColoring = editorUI.getColoring(SettingsNames.CODE_FOLDING_COLORING);
            if (foldColoring != null && foldColoring.getForeColor()!=null){
                foreColor = foldColoring.getForeColor();
                return foreColor;
            }
        }
        foreColor = getDefaultForeColor();
        return foreColor;
    }
    
    private Color getDefaultForeColor(){
        EditorUI editorUI = getEditorUI();
        if (editorUI!=null){
            // font in folding coloring not available, get default (or inherited)
            Coloring defaultColoring = editorUI.getDefaultColoring();
            if (defaultColoring!=null && defaultColoring.getForeColor()!=null){
                return defaultColoring.getForeColor();
            }
        }
        return SettingsDefaults.defaultForeColor;
    }
    
    private Color getDefaultBackColor(){
        EditorUI editorUI = getEditorUI();
        if (editorUI!=null){
            // font in folding coloring not available, get default (or inherited)
            Coloring defaultColoring = editorUI.getDefaultColoring();
            if (defaultColoring!=null){
                return defaultColoring.getBackColor();
            }
        }
        return SettingsDefaults.defaultBackColor;
    }
    
    protected Color getBackColor(){
        if (backColor != null) return backColor;
        EditorUI editorUI = getEditorUI();
        if (editorUI!=null){
            Coloring foldColoring = editorUI.getColoring(SettingsNames.CODE_FOLDING_COLORING);
            if (foldColoring != null && foldColoring.getBackColor()!=null){
                backColor = foldColoring.getBackColor();
                return backColor;
            }
        }
        backColor = getDefaultBackColor();
        return backColor;
    }

    
    class RootView extends View {

        RootView() {
            super(null);
        }

        void setView(View v) {
            if (view != null) {
                // get rid of back reference so that the old
                // hierarchy can be garbage collected.
                view.setParent(null);
            }
            view = v;
            if (view != null) {
                view.setParent(this);
            }
        }

	/**
	 * Fetches the attributes to use when rendering.  At the root
	 * level there are no attributes.  If an attribute is resolved
	 * up the view hierarchy this is the end of the line.
	 */
        public AttributeSet getAttributes() {
	    return null;
	}

        /**
         * Determines the preferred span for this view along an axis.
         *
         * @param axis may be either X_AXIS or Y_AXIS
         * @return the span the view would like to be rendered into.
         *         Typically the view is told to render into the span
         *         that is returned, although there is no guarantee.
         *         The parent may choose to resize or break the view.
         */
        public float getPreferredSpan(int axis) {
            if (view != null) {
                return view.getPreferredSpan(axis);
            }
            return 10;
        }

        /**
         * Determines the minimum span for this view along an axis.
         *
         * @param axis may be either X_AXIS or Y_AXIS
         * @return the span the view would like to be rendered into.
         *         Typically the view is told to render into the span
         *         that is returned, although there is no guarantee.
         *         The parent may choose to resize or break the view.
         */
        public float getMinimumSpan(int axis) {
            if (view != null) {
                return view.getMinimumSpan(axis);
            }
            return 10;
        }

        /**
         * Determines the maximum span for this view along an axis.
         *
         * @param axis may be either X_AXIS or Y_AXIS
         * @return the span the view would like to be rendered into.
         *         Typically the view is told to render into the span
         *         that is returned, although there is no guarantee.
         *         The parent may choose to resize or break the view.
         */
        public float getMaximumSpan(int axis) {
	    return Integer.MAX_VALUE;
        }

        /**
         * Specifies that a preference has changed.
         * Child views can call this on the parent to indicate that
         * the preference has changed.  The root view routes this to
         * invalidate on the hosting component.
         * 

         * This can be called on a different thread from the
         * event dispatching thread and is basically unsafe to
         * propagate into the component.  To make this safe,
         * the operation is transferred over to the event dispatching 
         * thread for completion.  It is a design goal that all view
         * methods be safe to call without concern for concurrency,
         * and this behavior helps make that true.
         *
         * @param child the child view
         * @param width true if the width preference has changed
         * @param height true if the height preference has changed
         */ 
        public void preferenceChanged(View child, boolean width, boolean height) {
            
        }

        /**
         * Determines the desired alignment for this view along an axis.
         *
         * @param axis may be either X_AXIS or Y_AXIS
         * @return the desired alignment, where 0.0 indicates the origin
         *     and 1.0 the full span away from the origin
         */
        public float getAlignment(int axis) {
            if (view != null) {
                return view.getAlignment(axis);
            }
            return 0;
        }

        /**
         * Renders the view.
         *
         * @param g the graphics context
         * @param allocation the region to render into
         */
        public void paint(Graphics g, Shape allocation) {
            if (view != null) {
                Rectangle alloc = (allocation instanceof Rectangle) ?
		          (Rectangle)allocation : allocation.getBounds();
		setSize(alloc.width, alloc.height);
                view.paint(g, allocation);
            }
        }
        
        /**
         * Sets the view parent.
         *
         * @param parent the parent view
         */
        public void setParent(View parent) {
            throw new Error("Can't set parent on root view"); // NOI18N
        }

        /** 
         * Returns the number of views in this view.  Since
         * this view simply wraps the root of the view hierarchy
         * it has exactly one child.
         *
         * @return the number of views
         * @see #getView
         */
        public int getViewCount() {
            return 1;
        }

        /** 
         * Gets the n-th view in this container.
         *
         * @param n the number of the view to get
         * @return the view
         */
        public View getView(int n) {
            return view;
        }

	/**
	 * Returns the child view index representing the given position in
	 * the model.  This is implemented to return the index of the only
	 * child.
	 *
	 * @param pos the position >= 0
	 * @return  index of the view representing the given position, or 
	 *   -1 if no view represents that position
	 * @since 1.3
	 */
        public int getViewIndex(int pos, Position.Bias b) {
	    return 0;
	}
    
        /**
         * Fetches the allocation for the given child view. 
         * This enables finding out where various views
         * are located, without assuming the views store
         * their location.  This returns the given allocation
         * since this view simply acts as a gateway between
         * the view hierarchy and the associated component.
         *
         * @param index the index of the child
         * @param a  the allocation to this view.
         * @return the allocation to the child
         */
        public Shape getChildAllocation(int index, Shape a) {
            return a;
        }

        /**
         * Provides a mapping from the document model coordinate space
         * to the coordinate space of the view mapped to it.
         *
         * @param pos the position to convert
         * @param a the allocated region to render into
         * @return the bounding box of the given position
         */
        public Shape modelToView(int pos, Shape a, Position.Bias b) throws BadLocationException {
            if (view != null) {
                return view.modelToView(pos, a, b);
            }
            return null;
        }

	/**
	 * Provides a mapping from the document model coordinate space
	 * to the coordinate space of the view mapped to it.
	 *
	 * @param p0 the position to convert >= 0
	 * @param b0 the bias toward the previous character or the
	 *  next character represented by p0, in case the 
	 *  position is a boundary of two views. 
	 * @param p1 the position to convert >= 0
	 * @param b1 the bias toward the previous character or the
	 *  next character represented by p1, in case the 
	 *  position is a boundary of two views. 
	 * @param a the allocated region to render into
	 * @return the bounding box of the given position is returned
	 * @exception BadLocationException  if the given position does
	 *   not represent a valid location in the associated document
	 * @exception IllegalArgumentException for an invalid bias argument
	 * @see View#viewToModel
	 */
	public Shape modelToView(int p0, Position.Bias b0, int p1, Position.Bias b1, Shape a) throws BadLocationException {
	    if (view != null) {
		return view.modelToView(p0, b0, p1, b1, a);
	    }
	    return null;
	}

        /**
         * Provides a mapping from the view coordinate space to the logical
         * coordinate space of the model.
         *
         * @param x x coordinate of the view location to convert
         * @param y y coordinate of the view location to convert
         * @param a the allocated region to render into
         * @return the location within the model that best represents the
         *    given point in the view
         */
        public int viewToModel(float x, float y, Shape a, Position.Bias[] bias) {
            if (view != null) {
                int retValue = view.viewToModel(x, y, a, bias);
		return retValue;
            }
            return -1;
        }

        /**
         * Provides a way to determine the next visually represented model 
         * location that one might place a caret.  Some views may not be visible,
         * they might not be in the same order found in the model, or they just
         * might not allow access to some of the locations in the model.
         *
         * @param pos the position to convert >= 0
         * @param a the allocated region to render into
         * @param direction the direction from the current position that can
         *  be thought of as the arrow keys typically found on a keyboard.
         *  This may be SwingConstants.WEST, SwingConstants.EAST, 
         *  SwingConstants.NORTH, or SwingConstants.SOUTH.  
         * @return the location within the model that best represents the next
         *  location visual position.
         * @exception BadLocationException
         * @exception IllegalArgumentException for an invalid direction
         */
        public int getNextVisualPositionFrom(int pos, Position.Bias b, Shape a, 
                                             int direction,
                                             Position.Bias[] biasRet) 
            throws BadLocationException {
            if( view != null ) {
                int nextPos = view.getNextVisualPositionFrom(pos, b, a,
						     direction, biasRet);
		if(nextPos != -1) {
		    pos = nextPos;
		}
		else {
		    biasRet[0] = b;
		}
            } 
            return pos;
        }

        /**
         * Gives notification that something was inserted into the document
         * in a location that this view is responsible for.
         *
         * @param e the change information from the associated document
         * @param a the current allocation of the view
         * @param f the factory to use to rebuild if the view has children
         */
        public void insertUpdate(DocumentEvent e, Shape a, ViewFactory f) {
            if (view != null) {
                view.insertUpdate(e, a, f);
            }
        }
        
        /**
         * Gives notification that something was removed from the document
         * in a location that this view is responsible for.
         *
         * @param e the change information from the associated document
         * @param a the current allocation of the view
         * @param f the factory to use to rebuild if the view has children
         */
        public void removeUpdate(DocumentEvent e, Shape a, ViewFactory f) {
            if (view != null) {
                view.removeUpdate(e, a, f);
            }
        }

        /**
         * Gives notification from the document that attributes were changed
         * in a location that this view is responsible for.
         *
         * @param e the change information from the associated document
         * @param a the current allocation of the view
         * @param f the factory to use to rebuild if the view has children
         */
        public void changedUpdate(DocumentEvent e, Shape a, ViewFactory f) {
            if (view != null) {
                view.changedUpdate(e, a, f);
            }
        }

        /**
         * Returns the document model underlying the view.
         *
         * @return the model
         */
        public Document getDocument() {
            EditorUI editorUI = getEditorUI();
            return (editorUI==null) ? null : editorUI.getDocument();
        }
        
        /**
         * Returns the starting offset into the model for this view.
         *
         * @return the starting offset
         */
        public int getStartOffset() {
            if (view != null) {
                return view.getStartOffset();
            }
            return getElement().getStartOffset();
        }

        /**
         * Returns the ending offset into the model for this view.
         *
         * @return the ending offset
         */
        public int getEndOffset() {
            if (view != null) {
                return view.getEndOffset();
            }
            return getElement().getEndOffset();
        }

        /**
         * Gets the element that this view is mapped to.
         *
         * @return the view
         */
        public Element getElement() {
            if (view != null) {
                return view.getElement();
            }
            return view.getDocument().getDefaultRootElement();
        }

        /**
         * Breaks this view on the given axis at the given length.
         *
         * @param axis may be either X_AXIS or Y_AXIS
         * @param len specifies where a break is desired in the span
         * @param the current allocation of the view
         * @return the fragment of the view that represents the given span
         *   if the view can be broken, otherwise null
         */
        public View breakView(int axis, float len, Shape a) {
            throw new Error("Can't break root view"); // NOI18N
        }

        /**
         * Determines the resizability of the view along the
         * given axis.  A value of 0 or less is not resizable.
         *
         * @param axis may be either X_AXIS or Y_AXIS
         * @return the weight
         */
        public int getResizeWeight(int axis) {
            if (view != null) {
                return view.getResizeWeight(axis);
            }
            return 0;
        }

        /**
         * Sets the view size.
         *
         * @param width the width
         * @param height the height
         */
        public void setSize(float width, float height) {
            if (view != null) {
                view.setSize(width, height);
            }
        }

        /**
         * Fetches the container hosting the view.  This is useful for
         * things like scheduling a repaint, finding out the host 
         * components font, etc.  The default implementation
         * of this is to forward the query to the parent view.
         *
         * @return the container
         */
        public Container getContainer() {
            EditorUI editorUI = getEditorUI();
            return (editorUI==null) ? null : editorUI.getComponent();
        }
        
        /**
         * Fetches the factory to be used for building the
         * various view fragments that make up the view that
         * represents the model.  This is what determines
         * how the model will be represented.  This is implemented
         * to fetch the factory provided by the associated
         * EditorKit unless that is null, in which case this
         * simply returns the BasicTextUI itself which allows
         * subclasses to implement a simple factory directly without
         * creating extra objects.  
         *
         * @return the factory
         */
        public ViewFactory getViewFactory() {
            EditorUI editorUI = getEditorUI();
            if (editorUI!=null){
                BaseKit kit = Utilities.getKit(editorUI.getComponent());

                ViewFactory f = kit.getViewFactory();
                if (f != null) {
                    return f;
                }
            }
            return getBaseTextUI();
        }

        private View view;

    }
    
    
}