/*
 * Copyright (c) 1998 Tal Davidson. All rights reserved.
 *
 * JSLineBreaker 0.4.0
 * by Tal Davidson (davidsont@bigfoot.com)
 *
 * JSLineBreaker 0.4.0 is distributed under the "Artistic Licence" detailed below:
 *
 *
 *                           The ``Artistic License''
 *
 * Preamble
 * The intent of this document is to state the conditions under which a Package may
 * be copied, such that the Copyright Holder maintains some semblance of artistic
 * control over the development of the package, while giving the users of the
 * package the right to use and distribute the Package in a more-or-less customary
 * fashion, plus the right to make reasonable modifications.
 *
 * Definitions
 *     ``Package'' refers to the collection of files distributed by the Copyright
 *     Holder, and derivatives of that collection of files created through textual
 *     modification.
 *     ``Standard Version'' refers to such a Package if it has not been modified,
 *     or has been modified in accordance with the wishes of the Copyright Holder
 *     as specified below.
 *     ``Copyright Holder'' is whoever is named in the copyright or copyrights for
 *     the package.
 *     ``You'' is you, if you're thinking about copying or distributing this
 *     Package.
 *     ``Reasonable copying fee'' is whatever you can justify on the basis of media
 *     cost, duplication charges, time of people involved, and so on. (You will not
 *     be required to justify it to the Copyright Holder, but only to the computing
 *     community at large as a market that must bear the fee.)
 *     ``Freely Available'' means that no fee is charged for the item itself,
 *     though there may be fees involved in handling the item. It also means that
 *     recipients of the item may redistribute it under the same conditions they
 *     received it.
 *
 *     1. You may make and give away verbatim copies of the source form of the
 *        Standard Version of this Package without restriction, provided that you
 *        duplicate all of the original copyright notices and associated disclaimers.
 *     2. You may apply bug fixes, portability fixes and other modifications derived
 *        from the Public Domain or from the Copyright Holder. A Package modified in
 *        such a way shall still be considered the Standard Version.
 *     3. You may otherwise modify your copy of this Package in any way, provided that
 *        you insert a prominent notice in each changed file stating how and when you
 *        changed that file, and provided that you do at least ONE of the following:
 *         a. place your modifications in the Public Domain or otherwise make them
 *            Freely Available, such as by posting said modifications to Usenet or an
 *            equivalent medium, or placing the modifications on a major archive site
 *            such as uunet.uu.net, or by allowing the Copyright Holder to include
 *            your modifications in the Standard Version of the Package.
 *         b. use the modified Package only within your corporation or organization.
 *         c. rename any non-standard executables so the names do not conflict with
 *            standard executables, which must also be provided, and provide a
 *            separate manual page for each non-standard executable that clearly
 *            documents how it differs from the Standard Version.
 *         d. make other distribution arrangements with the Copyright Holder.
 *     4. You may distribute the programs of this Package in object code or executable
 *        form, provided that you do at least ONE of the following:
 *         a. distribute a Standard Version of the executables and library files,
 *            together with instructions (in the manual page or equivalent) on where
 *            to get the Standard Version.
 *         b. accompany the distribution with the machine-readable source of the
 *            Package with your modifications.
 *         c. give non-standard executables non-standard names, and clearly document
 *            the differences in manual pages (or equivalent), together with
 *            instructions on where to get the Standard Version.
 *         d. make other distribution arrangements with the Copyright Holder.
 *     5. You may charge a reasonable copying fee for any distribution of this
 *        Package. You may charge any fee you choose for support of this Package. You
 *        may not charge a fee for this Package itself. However, you may distribute
 *        this Package in aggregate with other (possibly commercial) programs as part
 *        of a larger (possibly commercial) software distribution provided that you do
 *        not advertise this Package as a product of your own. You may embed this
 *        Package's interpreter within an executable of yours (by linking); this shall
 *        be construed as a mere form of aggregation, provided that the complete
 *        Standard Version of the interpreter is so embedded.
 *     6. The scripts and library files supplied as input to or produced as output
 *        from the programs of this Package do not automatically fall under the
 *        copyright of this Package, but belong to whomever generated them, and may be
 *        sold commercially, and may be aggregated with this Package. If such scripts
 *        or library files are aggregated with this Package via the so-called "undump"
 *        or "unexec" methods of producing a binary executable image, then
 *        distribution of such an image shall neither be construed as a distribution
 *        of this Package nor shall it fall under the restrictions of Paragraphs 3 and
 *        4, provided that you do not represent such an executable image as a Standard
 *        Version of this Package.
 *     7. C subroutines (or comparably compiled subroutines in other languages)
 *        supplied by you and linked into this Package in order to emulate subroutines
 *        and variables of the language defined by this Package shall not be
 *        considered part of this Package, but are the equivalent of input as in
 *        Paragraph 6, provided these subroutines do not change the language in any
 *        way that would cause it to fail the regression tests for the language.
 *     8. Aggregation of this Package with a commercial distribution is always
 *        permitted provided that the use of this Package is embedded; that is, when
 *        no overt attempt is made to make this Package's interfaces visible to the
 *        end user of the commercial distribution. Such use shall not be construed as
 *        a distribution of this Package.
 *     9. The name of the Copyright Holder may not be used to endorse or promote
 *        products derived from this software without specific prior written
 *        permission.
 *        THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED
 *        WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
 *        MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 * The End
 */

import java.util.*;

class JSLineBreaker
{
    private static final int BEFORE = 0;
    private static final int AFTER = 1;

    private String prefs[] = {
        "().", "()", ").", "+=", "-=", "*=", "/=", "%=", "^=", "||", "&&", "==", "!=", ">=", "<=",
        "(", ")", "[", "]", "?", ":", ",", ";", "=", "<", ">", "+", "-", "*", "/", "&", "|", /*"!",*/ "^"
    };
    private static Hashtable prefTable;
    static
    {
        prefTable = new Hashtable();
        prefTable.put("()", new Integer(80/*35*/)); // () appears here so that it will not be cut in the middle...

        prefTable.put("().", new Integer(90)); // () appears here so that it will not be cut in the middle...
        prefTable.put(").", new Integer(90)); // () appears here so that it will not be cut in the middle...

        prefTable.put("(", new Integer(80));//<--
        prefTable.put(")", new Integer(80));
        prefTable.put("[", new Integer(80));
        prefTable.put("]", new Integer(80));
        prefTable.put(",", new Integer(10));
        prefTable.put(";", new Integer(5));


        prefTable.put("=", new Integer(20));
        prefTable.put("+=", new Integer(20));
        prefTable.put("-=", new Integer(20));
        prefTable.put("*=", new Integer(20));
        prefTable.put("/=", new Integer(20));
        prefTable.put("|=", new Integer(20));
        prefTable.put("&=", new Integer(20));
        prefTable.put("^=", new Integer(20));

        prefTable.put("?", new Integer(25));
        prefTable.put(":", new Integer(25));

        prefTable.put("||", new Integer(30));
        prefTable.put("&&", new Integer(30));

        prefTable.put("==", new Integer(40));
        prefTable.put("!=", new Integer(40));
        prefTable.put(">=", new Integer(40));
        prefTable.put("<=", new Integer(40));
        prefTable.put(">", new Integer(40));
        prefTable.put("<", new Integer(40));

        prefTable.put("+", new Integer(50));
        prefTable.put("-", new Integer(50));
        prefTable.put("*", new Integer(60));
        prefTable.put("/", new Integer(60));
        prefTable.put("%", new Integer(60));
        //prefTable.put("!", new Integer(70));
        prefTable.put("&", new Integer(70));
        prefTable.put("|", new Integer(70));
        prefTable.put("^", new Integer(70));
    }


    private Vector brokenLineVector;
    private StringBuffer wsBuffer;
    private char quoteChar;
    private boolean isInQuote;
    private boolean isInComment;
    private boolean isNestedConnection = true;
    private boolean isCut;
    private boolean isLineComment; // true when the current character is in a // comment (such as this line ...)
    private int parenDepth;
    private int breakDepth;
    private int preferredLineLength = 70;
    private int lineLengthDeviation = 5;




    JSLineBreaker()
    {
        init();
    }

    void init()
    {
        brokenLineVector = new Vector();

        parenDepth = 0;
        breakDepth = 0; // <------ 2

        isInQuote = false;
        isInComment = false;
        isCut = false;
        isLineComment = false;
        wsBuffer = new StringBuffer();

    }

    void setPreferredLineLength(int length)
    {
        preferredLineLength = length;
    }

    void setLineLengthDeviation(int dev)
    {
        lineLengthDeviation = dev;
    }

    void setNestedConnection(boolean nest)
    {
        isNestedConnection = nest;
    }

    void breakLine(String line)
    {
        StringBuffer outBuffer = new StringBuffer();
        Stack lineBreakStack = new Stack();
        String previousAfterCut = "";
         boolean isSpecialChar = false;
        char ch = ' ';       // the current character
        char prevCh = 0;
        int i;
        int ws;
        int regBreak = 0;
        int wsBreak = 0;
        int chosenBreak = 0;
        int BufLength;
        int bufferStart = 0;

//System.out.println("line length: " + line.length() + " line: " + line );
        if ( line.trim().length() == 0)
        {
            brokenLineVector.addElement("");
            return;
        }

        ch = line.charAt(0);
        ws = 0;

        if (!isLineComment)
            isCut = false;
        isLineComment = false;

        if (!isCut)
        {
        wsBuffer = new StringBuffer();

        while ( (ch == ' ' || ch == '\t') && ws='a' &&prevCh<='z')
                                    || (prevCh>='A' &&prevCh<='Z')
                                    || (prevCh>='0' &&prevCh<='9')
                                    || (prevCh=='.'))
                                breakType = AFTER;
                            else
                                breakType = BEFORE;
                        else
                            breakType = AFTER;
                    }

                    if (key.length() > 1)
                    {
                        outBuffer.append(key.substring(1));
                        i += key.length() - 1;
                    }
                    registerLineBreak(lineBreakStack,
                            new LineBreak(key, outBuffer.length()+bufferStart, breakDepth, breakType));

                    breakDepth = parenDepth;

                    break;
                }
            }


            int bufLength = outBuffer.length() + wsBuffer.length() + previousAfterCut.length() + (isCut ? 8 : 0);

            LineBreak curBreak = null;
            if (bufLength > preferredLineLength && i < line.length() - lineLengthDeviation)
            {
                while (!lineBreakStack.isEmpty())
                {
                    curBreak = (LineBreak) lineBreakStack.elementAt(0);
                    if (curBreak.breakWhere-bufferStart < 1) // <-----
                    {
                        curBreak = null;
                        lineBreakStack.removeElementAt(0);
                    }
                    else
                        break;
                }
                if (curBreak != null)
                    lineBreakStack.removeElementAt(0);
            }

            if (curBreak != null) // in future, think of: && line.length()>i+10) (that was used in the past...)
            {
                int cutWhere = curBreak.breakWhere - bufferStart - (curBreak.breakType == BEFORE ? curBreak.breakStr.length() : 0);
                if (cutWhere < 8)
                    continue;
                StringBuffer brokenLineBuffer = new StringBuffer();
                String outString = outBuffer.toString();
                String beforeCut = outString.substring(0, cutWhere);

                //brokenLineBuffer.append(wsBuffer);

                /*
                if (isCut)
                    brokenLineBuffer.append("        ");
                brokenLineBuffer.append(beforeCut);
                brokenLineVector.addElement(brokenLineBuffer.toString());
                */
                brokenLineBuffer.append(beforeCut);
                addBrokenLine(wsBuffer.toString(), brokenLineBuffer.toString(), curBreak, breakDepth, isCut);

                //previousAfterCut = outString.substring(cutWhere);
                bufferStart += cutWhere;
                outBuffer = new StringBuffer(outString.substring(cutWhere));

                //lineBreakStack = new Stack();
                isCut = true;
            }
        }

        // at end of line:
        StringBuffer brokenLineBuffer = new StringBuffer();
        //brokenLineBuffer.append(wsBuffer);
        /*
        if (isCut)
            brokenLineBuffer.append("        ");
        brokenLineBuffer.append(outBuffer);
        brokenLineVector.addElement(brokenLineBuffer.toString());
        */
        brokenLineBuffer.append(outBuffer);
        addBrokenLine(wsBuffer.toString(), brokenLineBuffer.toString(), null, breakDepth, isCut);

    }

    private void registerLineBreak(Stack lineBreakStack, LineBreak newBreak)
    {
        LineBreak lastBreak;
        while (!lineBreakStack.isEmpty())
        {
            lastBreak = (LineBreak) lineBreakStack.peek();
            if (compare(lastBreak, newBreak) < 0)
                lineBreakStack.pop();
            else
                break;
        }
        lineBreakStack.push(newBreak);
        //newBreak.dump();

 /*       System.out.println("for " + newBreak.breakStr);
        for (int s=0; s 0)
        {
            String previousBrokenLine = (String) brokenLineVector.lastElement();
            if (brokenLine.length() + previousBrokenLine.length() <= preferredLineLength + lineLengthDeviation
                    || brokenLine.startsWith("{"))
            {
                if (lineBreak == null ||
                        (isNestedConnection && !",".equals(previousLineBreak.breakStr)) ||
                        (lineBreak.breakDepth < previousLineBreak.breakDepth) || //dfds
                        (lineBreak.breakDepth == previousLineBreak.breakDepth &&
                        ((!isNestedConnection && !",".equals(previousLineBreak.breakStr)) ||
                             ",".equals(lineBreak.breakStr) || ";".equals(lineBreak.breakStr) ||
                             ")".equals(lineBreak.breakStr) || "]".equals(lineBreak.breakStr)))
                   )
                {
                    brokenLineVector.setElementAt( (previousBrokenLine + " " + brokenLine),
                            brokenLineVector.size()-1);
                    isLineAppended = true;
                }
            }
        }

        if (!isLineAppended)
        {
            if (isCut &&
                    !(previousLineBreak != null && ",".equals(previousLineBreak.breakStr) &&
                    previousLineBreak.breakDepth == 0))
                brokenLine = "        " + brokenLine;
            brokenLine = whiteSpace + brokenLine;
            brokenLineVector.addElement(brokenLine);
        }

        previousLineBreak = lineBreak;
    }

    private int compare(LineBreak br1, LineBreak br2)
    {
        if (br1.breakDepth < br2.breakDepth)
                return 1;
            else if (br1.breakDepth > br2.breakDepth)
                return -1;

        int ord1 = ((Integer) prefTable.get(br1.breakStr)).intValue();
        int ord2 = ((Integer) prefTable.get(br2.breakStr)).intValue();
        if (ord1 < ord2)
            return 1;
        else
            return -1;


    }

    boolean hasMoreBrokenLines()
    {
        return brokenLineVector.size() > 0;
    }

    String nextBrokenLine()
    {
        String nextLine;

        if (hasMoreBrokenLines())
        {
            nextLine = (String) brokenLineVector.firstElement();
            brokenLineVector.removeElementAt(0);
        }
        else
            return nextLine = "";

        return nextLine;
    }


    class LineBreak
    {
        String breakStr;
        int breakWhere;
        int breakDepth;
        int breakType;

        LineBreak(String str, int wh, int dp, int tp)
        {
            breakStr = str;
            breakWhere = wh;
            breakDepth = dp;
            breakType = tp;
        }

        void dump()
        {
            System.out.println("LB: str="+breakStr+" wh="+breakWhere+" dep="+breakDepth+" tp="+breakType);
        }
    }

}