/*
 *                 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.modules.search.types;


import java.io.*;
import java.text.MessageFormat;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.ResourceBundle;
import java.util.regex.Matcher;

import org.netbeans.modules.search.SearchDisplayer;

import org.openide.filesystems.FileObject;
import org.openide.loaders.DataObject;
import org.openide.nodes.AbstractNode;
import org.openide.nodes.Children;
import org.openide.nodes.Node;
import org.openide.util.actions.NodeAction;
import org.openide.util.actions.SystemAction;
import org.openide.util.HelpCtx;
import org.openide.util.NbBundle;
import org.openide.windows.OutputEvent;
import org.openide.windows.OutputListener;
import org.openide.xml.XMLUtil;


/**
 * Test DataObject primaryFile for line full-text match.
 *
 * @author  Petr Kuzel
 * @author  Marian Petras
 */
public class FullTextType extends TextType {

    private static final long serialVersionUID = 1L;
    //private static final long serialVersionUID = -8671182156199506714L;

    /**
     * Holds information about occurences of matching strings within individual
     * DataObjects.
     * 

     * Contains mappings
     * 

     * (DataObject) -> (list of occurences of matchings strings
     * withing the DataObject)
     * 
     * 

     */
    private transient Map detailsMap;

    /**
     * Maximum number of matches reported for one line.
     * It eliminates huge memory consumption for single letter searches on long lines.
     */
    private static final int MAX_REPORTED_OCCURENCES_ON_LINE = 5;

    /**
     * Maximum number of matches reported for one file.
     * It eliminates huge memory consumption for single letter searches in long files.
     */
    private static final int MAX_REPORTED_OCCURENCES_IN_FILE = 200;


    /** */
    public Object clone() {
        FullTextType clone = (FullTextType) super.clone();
        clone.detailsMap = new HashMap(20);
        return clone;
    }
    
    /** */
    public void destroy() {
        if (detailsMap != null) {
            detailsMap.clear();
        }
    }

    /** Gets details map. */
    private Map getDetailsMap() {
        if (detailsMap != null) {
            return detailsMap;
        }
        
        synchronized(this) {
            if (detailsMap == null) {
                detailsMap = new HashMap(20);
            }
        }
        
        return detailsMap;
    }
    
    /**
     */
    public boolean testDataObject(DataObject dobj) {
        InputStream is = null;
        LineNumberReader reader = null;
        try {
            String line = ""; //NOI18N

            // primary file of the DataObject
            FileObject fo = dobj.getPrimaryFile();
            if (fo == null) {
                return false;
            }
            // primary file content
            is = fo.getInputStream();
            reader = new LineNumberReader(new InputStreamReader(is));

            ArrayList txtDetails = new ArrayList(5);

            int fileCount = 0;
            while (fileCount < MAX_REPORTED_OCCURENCES_IN_FILE) {
                line = reader.readLine();
                if (line == null) {
                    break;
                }
                if (matchString != null) {
                    int lineNum = reader.getLineNumber(); // current line + 1
                    int markLen = matchString.length();

                    String stringToSearch = caseSensitive ? line
                                                          : line.toUpperCase();
                    int i = matchString(stringToSearch, 0);
                    int lineCount = 0;
                    while (i >= 0 && lineCount < MAX_REPORTED_OCCURENCES_ON_LINE) {
                        TextDetail det = new TextDetail(dobj);
                        det.setLine(lineNum);
                        det.setColumn(i + 1); // current column + 1
                        det.setLineText(line);
                        det.setMarkLength(markLen);
                        
                        txtDetails.add(det);

                        i = matchString(stringToSearch, i + 1);
                        lineCount ++;
                        fileCount++;
                    }
                } else if (matchRE(line)) {

                    // TODO detect all occurences as in above code 

                    TextDetail det = new TextDetail(dobj);
                    det.setLine(reader.getLineNumber());
                    det.setLineText(line);
                    Matcher matcher = getMatcher();
                    int start = matcher.start();
                    int len = matcher.end() - start;
                    det.setColumn(start +1);
                    det.setMarkLength(len);

                    txtDetails.add(det);
                    fileCount++;
                }
            }

            // TODO somehow notify user if MAX_REPORTED_OCCURENCES_IN_FILE or MAX_REPORTED_OCCURENCES_ON_LINE

            if (txtDetails.isEmpty()) {
                return false;
            }

            txtDetails.trimToSize();
            getDetailsMap().put(dobj, txtDetails);

            return true;
        } catch (FileNotFoundException fnfe) {
            return false;
        } catch (IOException ioe) {
            org.openide.ErrorManager.getDefault().notify(org.openide.ErrorManager.INFORMATIONAL, ioe);
            return false;
        } finally {
            if (reader != null) {
                try {
                    reader.close();
                    reader = null;
                    is = null;  //marks that the InputStream is closed
                } catch (IOException ex) {
                    org.openide.ErrorManager.getDefault().notify(
                            org.openide.ErrorManager.INFORMATIONAL, ex);
                    
                }
            }
            if (is != null) {
                try {
                    is.close();
                    is = null;
                } catch (IOException ex) {
                    org.openide.ErrorManager.getDefault().notify(
                            org.openide.ErrorManager.INFORMATIONAL, ex);
                }
            }
        }
    }
    

    /**
     * @param  resultObject  DataObject to create the nodes for
     * @return  DetailNodes representing the matches,
     *          or null if no matching string is known for the
     *          specified object
     * @see  DetailNode
     */
    public Node[] getDetails(Object resultObject) {
        List details = (List)getDetailsMap().get(resultObject);
        
        if(details == null)
            return null;

        List detailNodes = new ArrayList(details.size());
        
        for(Iterator it = details.iterator(); it.hasNext();) {
            
            TextDetail txtDetail = (TextDetail)it.next();
        
            Node detailNode = new DetailNode(txtDetail);
            detailNodes.add(detailNode);        
        }

        return (Node[])detailNodes.toArray(new Node[detailNodes.size()]);
    }

    /**
     * @param  node representing a DataObject with matches
     * @return  DetailNodes representing the matches,
     *          or null if the specified node does not represent
     *          a DataObject or if no matching string is known for
     *          the specified object
     */
    public Node[] getDetails(Node node) {
        DataObject dataObject = (DataObject)node.getCookie(DataObject.class);
        
        if(dataObject == null) 
            return null;
        
        return getDetails(dataObject);
    }

    
    
    /**
     * Node that represents information about one occurence of a matching
     * string.
     *
     * @see  TextDetail
     */
    private static class DetailNode extends AbstractNode
                                    implements OutputListener {
        
        /** Detail to represent. */
        private TextDetail txtDetail;

        
        /**
         * Constructs a node representing the specified information about
         * a matching string.
         *
         * @param  txtDetail  information to be represented by this node
         */
        public DetailNode(TextDetail txtDetail) {
            super(Children.LEAF);
            
            this.txtDetail = txtDetail;
            
            setDefaultAction(SystemAction.get(GotoDetailAction.class));
            setShortDescription(DetailNode.getShortDesc(txtDetail));
            setValue(SearchDisplayer.ATTR_OUTPUT_LINE,
                     DetailNode.getFullDesc(txtDetail));
        }

        
        /** */
        protected SystemAction[] createActions() {
            return new SystemAction[] {
                SystemAction.get(GotoDetailAction.class),
                SystemAction.get(ShowDetailAction.class)
            };
        }

        /** */
        public String getName() {
            return txtDetail.getLineText() + "      [" + DetailNode.getName(txtDetail) + "]";  // NOI18N
        }

        public String getHtmlDisplayName() {
            String colored;
            if (txtDetail.getMarkLength() > 0 && txtDetail.getColumn() > 0) {
                try {
                    StringBuffer bold = new StringBuffer();
                    String plain = txtDetail.getLineText();
                    int col0 =   txtDetail.getColumn() -1;  // base 0

                    bold.append(XMLUtil.toElementContent(plain.substring(0, col0)));  // NOI18N
                    bold.append("");  // NOi18N
                    int end = col0 + txtDetail.getMarkLength();
                    bold.append(XMLUtil.toElementContent(plain.substring(col0, end)));
                    bold.append(""); // NOi18N
                    if (txtDetail.getLineText().length() > end) {
                        bold.append(XMLUtil.toElementContent(plain.substring(end)));
                    }
                    colored = bold.toString();
                } catch (CharConversionException ex) {
                    return null;
                }
            } else {
                try {
                    colored = XMLUtil.toElementContent( txtDetail.getLineText());
                } catch (CharConversionException e) {
                    return null;
                }
            }

            try {
                return colored + "      [" + XMLUtil.toElementContent(DetailNode.getName(txtDetail)) + "]";  // NOI18N
            } catch (CharConversionException e) {
                return null;
            }
        }

        /** Displays the matching string in a text editor. */
        private void gotoDetail() {
            txtDetail.showDetail(TextDetail.DH_GOTO);
        }

        /** Show the text occurence. */
        private void showDetail() {
            txtDetail.showDetail(TextDetail.DH_SHOW);
        }

        /** Implements OutputListener interface method. */
        public void outputLineSelected (OutputEvent evt) {
            txtDetail.showDetail(TextDetail.DH_SHOW);
        }

        /** Implements OutputListener interface method. */        
        public void outputLineAction (OutputEvent evt) {
            txtDetail.showDetail(TextDetail.DH_GOTO);
        }

        /** Implements OutputListener interface method. */
        public void outputLineCleared (OutputEvent evt) {
            txtDetail.showDetail(TextDetail.DH_HIDE);
        }

        /**
         * Returns name of a node representing a TextDetail.
         *
         * @param  det  detailed information about location of a matching string
         * @return  name for the node
         */
        private static String getName(TextDetail det) {
            int line = det.getLine();
            int col = det.getColumn();
            
            ResourceBundle bundle = NbBundle.getBundle(FullTextType.class);
            if (col > 0) {
                
                /* position :