#region License
// MIT License
//
// Copyright (c) 2018 Denis Ivanov
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in all
// copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
// SOFTWARE.
#endregion

namespace Jsbeautifier
{
    using System;
    using System.Collections.Generic;
    using System.Globalization;
    using System.Linq;
    using System.Text.RegularExpressions;
    
    public class Beautifier
    {
        public Beautifier()
            : this(new BeautifierOptions())
        {
        }

        public Beautifier(BeautifierOptions opts)
        {
            Opts = opts;
            BlankState();
        }

        public BeautifierOptions Opts { get; set; }

        public BeautifierFlags Flags { get; set; }

        private List<BeautifierFlags> FlagStore { get; set; }

        private bool WantedNewline { get; set; }

        private bool JustAddedNewline { get; set; }

        private bool DoBlockJustClosed { get; set; }

        private string IndentString { get; set; }

        private string PreindentString { get; set; }

        private string LastWord { get; set; }

        private string LastType { get; set; }

        private string LastText { get; set; }

        private string LastLastText { get; set; }

        private string Input { get; set; }

        private List<string> Output { get; set; }

        private char[] Whitespace { get; set; }

        private string Wordchar { get; set; }

        private string Digits { get; set; }

        private string[] Punct { get; set; }

        private string[] LineStarters { get; set; }

        private int ParserPos { get; set; }

        private int NNewlines { get; set; }

        private void BlankState()
        {
            // internal flags
            Flags = new BeautifierFlags("BLOCK");
            FlagStore = new List<BeautifierFlags>();
            WantedNewline = false;
            JustAddedNewline = false;
            DoBlockJustClosed = false;

            if (Opts.IndentWithTabs)
            {
                IndentString = "\t";
            }
            else
            {
                IndentString = new string(Opts.IndentChar, (int)Opts.IndentSize);
            }

            PreindentString = "";
            LastWord = "";               // last TK_WORD seen
            LastType = "TK_START_EXPR";  // last token type
            LastText = "";               // last token text
            LastLastText = "";           // pre-last token text
            Input = null;
            Output = new List<string>(); // formatted javascript gets built here
            Whitespace = new[] { '\n', '\r', '\t', ' ' };
            Wordchar = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_$";
            Digits = "0123456789";
            Punct = "+ - * / % & ++ -- = += -= *= /= %= == === != !== > < >= <= >> << >>> >>>= >>= <<= && &= | || ! !! , : ? ^ ^= |= :: <?= <? ?> <%= <% %>".Split(' ');
            
            // Words which always should start on a new line
            LineStarters = "continue,try,throw,return,var,if,switch,case,default,for,while,break,function".Split(',');
            SetMode("BLOCK");
            ParserPos = 0;
        }

        private void SetMode(string mode)
        {
            var prev = new BeautifierFlags("BLOCK");
            
            if (Flags != null)
            {
                FlagStore.Add(Flags);
                prev = Flags;
            }

            Flags = new BeautifierFlags(mode);

            if (FlagStore.Count == 1)
            {
                Flags.IndentationLevel = 0;
            }
            else
            {
                Flags.IndentationLevel = prev.IndentationLevel;

                if (prev.VarLine && prev.VarLineReindented)
                {
                    Flags.IndentationLevel = Flags.IndentationLevel + 1;
                }
            }

            Flags.PreviousMode = prev.Mode;
        }

        public string Beautify(string s, BeautifierOptions opts = null)
        {
            if (opts != null)
            {
                Opts = opts;
            }

            BlankState();

            while (s.Length != 0 && (s[0] == ' ' || s[0] == '\t'))
            {
                PreindentString += s[0];
                s = s.Remove(0, 1);
            }

            Input = s;
            ParserPos = 0;
            while (true)
            {
                var token = GetNextToken();
                // print (token_text, token_type, self.flags.mode)
                var tokenText = token.Item1;
                var tokenType = token.Item2;

                if (tokenType == "TK_EOF")
                {
                    break;
                }

                var handlers = new Dictionary<string, Action<string>> {
                    { "TK_START_EXPR", HandleStartExpr }, 
                    { "TK_END_EXPR", HandleEndExpr },
                    { "TK_START_BLOCK", HandleStartBlock },
                    { "TK_END_BLOCK", HandleEndBlock },
                    { "TK_WORD", HandleWord },
                    { "TK_SEMICOLON", HandleSemicolon },
                    { "TK_STRING", HandleString },
                    { "TK_EQUALS", HandleEquals },
                    { "TK_OPERATOR", HandleOperator },
                    { "TK_COMMA", HandleComma },
                    { "TK_BLOCK_COMMENT", HandleBlockComment },
                    { "TK_INLINE_COMMENT", HandleInlineComment },
                    { "TK_COMMENT", HandleComment },
                    { "TK_DOT", HandleDot },
                    { "TK_UNKNOWN", HandleUnknown }
                };

                handlers[tokenType](tokenText);

                if (tokenType != "TK_INLINE_COMMENT")
                {
                    LastLastText = LastText;
                    LastType = tokenType;
                    LastText = tokenText;
                }
            }

            var regex = new Regex(@"[\n ]+$");

            var sweetCode = PreindentString + regex.Replace(string.Concat(Output), "", 1);
            return sweetCode;
        }
        
        private void TrimOutput(bool eatNewlines = false)
        {
            while (Output.Count != 0 &&
                (Output[Output.Count - 1] == " " ||
                Output[Output.Count - 1] == IndentString ||
                Output[Output.Count - 1] == PreindentString ||
                (eatNewlines && (Output[Output.Count - 1] == "\n" || Output[Output.Count - 1] == "\r"))))
            {
                Output.RemoveAt(Output.Count - 1);
            }
        }

        private bool IsSpecialWord(string s)
        {
            return s == "case" || s == "return" || s == "do" || s == "if" || s == "throw" || s == "else";
        }

        private bool IsArray(string mode)
        {
            return mode == "[EXPRESSION]" || mode == "[INDENTED-EXPRESSION]";
        }

        private bool IsExpression(string mode)
        {
            return mode == "[EXPRESSION]" ||
                mode == "[INDENTED-EXPRESSION]" ||
                mode == "(EXPRESSION)" ||
                mode == "(FOR-EXPRESSION)" ||
                mode == "(COND-EXPRESSION)";
        }

        private void AllowWrapOrPreservedNewline(string tokenText, bool forceLinwrap = false)
        {
            if (Opts.WrapLineLength > 0 && !forceLinwrap)
            {
                var startLine = Output.Count - 1;

                while (startLine >= 0)
                {
                    if (Output[startLine] == "\n")
                    {
                        break;
                    }

                    startLine--;
                }

                startLine++;

                if (startLine < Output.Count)
                {
                    var slice = new string[Output.Count - startLine];
                    Output.CopyTo(startLine, slice, 0, slice.Length);
                    var currentLine = string.Concat(slice);

                    if (currentLine.Length + tokenText.Length >= Opts.WrapLineLength)
                    {
                        forceLinwrap = true;
                    }
                }
            }

            if (!JustAddedNewline && ((Opts.PreserveNewlines && WantedNewline) || forceLinwrap))
            {
                AppendNewline(true, false);
                AppendIndentString();
                WantedNewline = false;
            }
        }
        
        private void AppendNewline(bool ignoreRepeated = true, bool resetStatementFlags = true)
        {
            if (Opts.KeepArrayIndentation && IsArray(Flags.Mode))
            {
                return;
            }

            if (resetStatementFlags)
            {
                Flags.IfLine = false;
                Flags.ChainExtraIndentation = 0;
            }

            TrimOutput();

            if (Output.Count == 0)
            {
                return;
            }

            if (Output[Output.Count - 1] != "\n" || !ignoreRepeated)
            {
                JustAddedNewline = true;
                Output.Add("\n");
            }

            if (!string.IsNullOrEmpty(PreindentString))
            {
                Output.Add(PreindentString);
            }

            foreach (var i in Enumerable.Range(0, Flags.IndentationLevel + Flags.ChainExtraIndentation))
            {
                AppendIndentString();
            }

            if (Flags.VarLine && Flags.VarLineReindented)
            {
                AppendIndentString();
            }
        }

        private void AppendIndentString()
        {
            if (LastText != "")
            {
                Output.Add(IndentString);
            }
        }

        private void Append(string s)
        {
            if (s == " ")
            {
                // do not add just a single space after the // comment, ever
                if (LastType == "TK_COMMENT")
                {
                    AppendNewline();
                    return;
                }

                // make sure only single space gets drawn
                if (Output.Count != 0 &&
                    Output[Output.Count - 1] != " " &&
                    Output[Output.Count - 1] != "\n" &&
                    Output[Output.Count - 1] != IndentString)
                {
                    Output.Add(" ");
                }
            }
            else
            {
                JustAddedNewline = false;
                Output.Add(s);
            }
        }

        private void Indent()
        {
            Flags.IndentationLevel = Flags.IndentationLevel + 1;
        }

        private void RemoveIndent()
        {
            if (Output.Count != 0 &&
                (Output[Output.Count - 1] == IndentString ||
                 Output[Output.Count - 1] == PreindentString))
            {
                Output.RemoveAt(Output.Count - 1);
            }
        }

        private void RestoreMode()
        {
            DoBlockJustClosed = Flags.Mode == "DO_BLOCK";
            
            if (FlagStore.Count > 0)
            {
                var mode = Flags.Mode;
                Flags = FlagStore[FlagStore.Count - 1];
                FlagStore.RemoveAt(FlagStore.Count - 1);
                Flags.PreviousMode = mode;
            }
        }

        private Tuple<string, string> GetNextToken()
        {
            NNewlines = 0;

            if (ParserPos >= Input.Length)
            {
                return new Tuple<string, string>("", "TK_EOF");
            }

            WantedNewline = false;
            var c = Input[ParserPos];
            ParserPos += 1;
            var keepWhitespace = Opts.KeepArrayIndentation && IsArray(Flags.Mode);

            if (keepWhitespace)
            {
                var whitespaceCount = 0;

                while (Whitespace.Contains(c))
                {
                    if (c == '\n')
                    {
                        TrimOutput();
                        Output.Add("\n");
                        JustAddedNewline = true;
                        whitespaceCount = 0;
                    }
                    else if (c == '\t')
                    {
                        whitespaceCount += 4;
                    }
                    else if (c == '\r')
                    {
                    }
                    else
                    {
                        whitespaceCount += 1;
                    }

                    if (ParserPos >= Input.Length)
                    {
                        return new Tuple<string, string>("", "TK_EOF");
                    }

                    c = Input[ParserPos];
                    ParserPos += 1;
                }

                if (JustAddedNewline)
                {
                    foreach (var i in Enumerable.Range(0, whitespaceCount))
                    {
                        Output.Add(" ");
                    }
                }
            }
            else //  not keep_whitespace
            {
                while (Whitespace.Contains(c))
                {
                    if (c == '\n')
                    {
                        if (Opts.MaxPreserveNewlines == 0 || Opts.MaxPreserveNewlines > NNewlines)
                        {
                            NNewlines += 1;
                        }
                    }

                    if (ParserPos >= Input.Length)
                    {
                        return new Tuple<string, string>("", "TK_EOF");
                    }

                    c = Input[ParserPos];
                    ParserPos += 1;
                }

                if (Opts.PreserveNewlines && NNewlines > 1)
                {
                    foreach (var i in Enumerable.Range(0, NNewlines))
                    {
                        AppendNewline(i == 0);
                        JustAddedNewline = true;
                    }
                }
                
                WantedNewline = NNewlines > 0;
            }

            var cc = c.ToString();

            if (Wordchar.Contains(c))
            {
                if (ParserPos < Input.Length)
                {
                    cc = c.ToString();
                    
                    while (Wordchar.Contains(Input[ParserPos]))
                    {
                        cc += Input[ParserPos];
                        ParserPos += 1;
                        if (ParserPos == Input.Length)
                            break;
                    }
                }
                
                // small and surprisingly unugly hack for 1E-10 representation
                if (ParserPos != Input.Length && "+-".Contains(Input[ParserPos]) && Regex.IsMatch(cc, "^[0-9]+[Ee]$"))
                {
                    var sign = Input[ParserPos];
                    ParserPos++;
                    var t = GetNextToken();
                    cc += sign + t.Item1;
                    return new Tuple<string, string>(cc, "TK_WORD");
                }

                if (cc == "in") // in is an operator, need to hack
                {
                    return new Tuple<string, string>(cc, "TK_OPERATOR");
                }

                if (WantedNewline
                    && LastType != "TK_OPERATOR"
                    && LastType != "TK_EQUALS"
                    && !Flags.IfLine
                    && (Opts.PreserveNewlines || LastText != "var"))
                {
                    AppendNewline();
                }

                return new Tuple<string, string>(cc, "TK_WORD");
            }

            if ("([".Contains(c))
            {
                return new Tuple<string, string>(c.ToString(), "TK_START_EXPR");
            }

            if (")]".Contains(c))
            {
                return new Tuple<string, string>(c.ToString(), "TK_END_EXPR");
            }

            if (c == '{')
            {
                return new Tuple<string, string>(c.ToString(), "TK_START_BLOCK");
            }

            if (c == '}')
            {
                return new Tuple<string, string>(c.ToString(), "TK_END_BLOCK");
            }

            if (c == ';')
            {
                return new Tuple<string, string>(c.ToString(), "TK_SEMICOLON");
            }

            if (c == '/')
            {
                var comment = "";
                var inlineComment = true;

                if (Input[ParserPos] == '*') // peek /* .. */ comment
                {
                    ParserPos += 1;
                    if (ParserPos < Input.Length)
                    {
                        while (!(Input[ParserPos] == '*' && ParserPos + 1 < Input.Length && Input[ParserPos + 1] == '/') &&
                            ParserPos < Input.Length)
                        {
                            c = Input[ParserPos];
                            comment += c;
                            
                            if ("\r\n".Contains(c))
                            {
                                inlineComment = false;
                            }

                            ParserPos += 1;

                            if (ParserPos >= Input.Length)
                            {
                                break;
                            }
                        }
                    }

                    ParserPos += 2;
                    
                    if (inlineComment && NNewlines == 0)
                    {
                        return new Tuple<string, string>("/*" + comment + "*/", "TK_INLINE_COMMENT");
                    }
                    
                    return new Tuple<string, string>("/*" + comment + "*/", "TK_BLOCK_COMMENT");
                }

                if (Input[ParserPos] == '/') // peek // comment
                {
                    comment = c.ToString();
                    while (!("\r\n").Contains(Input[ParserPos]))
                    {
                        comment += Input[ParserPos];
                        ParserPos += 1;
                        
                        if (ParserPos >= Input.Length)
                        {
                            break;
                        }
                    }

                    if (WantedNewline)
                    {
                        AppendNewline();
                    }
                    
                    return new Tuple<string, string>(comment, "TK_COMMENT");
                }
            }

            if (c == '\'' || c == '"' ||
                (c == '/' &&
                ((LastType == "TK_WORD" && IsSpecialWord(LastText)) ||
                (LastType == "TK_END_EXPR" && (Flags.PreviousMode == "(FOR-EXPRESSION)" || Flags.PreviousMode == "(COND-EXPRESSION)")) ||
                ((new[] { "TK_COMMENT", "TK_START_EXPR", "TK_START_BLOCK", "TK_END_BLOCK", "TK_OPERATOR", "TK_EQUALS", "TK_EOF", "TK_SEMICOLON", "TK_COMMA" }).Contains(LastType)))))
            {
                var sep = c;
                var esc = false;
                var esc1 = 0;
                var esc2 = 0;
                var resultingString = c.ToString();
                
                if (ParserPos < Input.Length)
                {
                    if (sep == '/')
                    {
                        // handle regexp
                        var inCharClass = false;
                        while (esc || inCharClass || Input[ParserPos] != sep)
                        {
                            resultingString += Input[ParserPos];
                            if (!esc)
                            {
                                esc = Input[ParserPos] == '\\';
                                if (Input[ParserPos] == '[')
                                {
                                    inCharClass = true;
                                }
                                else if (Input[ParserPos] == ']')
                                {
                                    inCharClass = false;
                                }
                            }
                            else
                            {
                                esc = false;
                            }
                            
                            ParserPos += 1;
                            if (ParserPos >= Input.Length)
                            {
                                // ncomplete regex when end-of-file reached
                                // bail out with what has received so far
                                return new Tuple<string, string>(resultingString, "TK_STRING");
                            }
                        }
                    }
                    else
                    {
                        // handle string
                        while (esc || Input[ParserPos] != sep)
                        {
                            resultingString += Input[ParserPos];
                            if (esc1 != 0 && esc1 >= esc2)
                            {
                                if (!int.TryParse(new string(resultingString.Skip(Math.Max(0, resultingString.Count() - esc2)).Take(esc2).ToArray()), NumberStyles.HexNumber, CultureInfo.CurrentCulture, out esc1))
                                    esc1 = 0;
                                if (esc1 != 0 && esc1 >= 0x20 && esc1 <= 0x7e)
                                {
                                    // FIXME
                                    resultingString = new string(resultingString.Take(2 + esc2).ToArray());
                                    
                                    if ((char) esc1 == sep || (char) esc1 == '\\')
                                    {
                                        resultingString += '\\';
                                    }
                                    
                                    resultingString += (char)esc1;
                                }
                                esc1 = 0;
                            }

                            if (esc1 != 0)
                            {
                                ++esc1;
                            }
                            else if (!esc)
                            {
                                esc = Input[ParserPos] == '\\';
                            }
                            else
                            {
                                esc = false;
                                // TODO
                                //if (/*this.Opts.UnescapeStrings*/false)
                                /*{
                                    if (this.Input[this.ParserPos] == 'x')
                                    {
                                        ++esc1;
                                        esc2 = 2;
                                    }
                                    else if (this.Input[this.ParserPos] == 'u')
                                    {
                                        ++esc1;
                                        esc2 = 4;
                                    }
                                }*/
                            }
                            
                            ParserPos += 1;
                            if (ParserPos >= Input.Length)
                            {
                                // incomplete string when end-of-file reached
                                // bail out with what has received so far
                                return new Tuple<string, string>(resultingString, "TK_STRING");
                            }
                        }
                    }
                }

                ParserPos += 1;
                resultingString += sep;
                if (sep == '/')
                {
                    // regexps may have modifiers /regexp/MOD, so fetch those too
                    while (ParserPos < Input.Length && Wordchar.Contains(Input[ParserPos]))
                    {
                        resultingString += Input[ParserPos];
                        ParserPos += 1;
                    }
                }
                return new Tuple<string, string>(resultingString, "TK_STRING");
            }

            if (c == '#')
            {
                var resultString = "";
                // she-bang
                if (Output.Count == 0 && Input.Length > 1 && Input[ParserPos] == '!')
                {
                    resultString = c.ToString();
                    while (ParserPos < Input.Length && c != '\n')
                    {
                        c = Input[ParserPos];
                        resultString += c;
                        ParserPos += 1;
                    }
                    Output.Add(resultString.Trim() + '\n');
                    AppendNewline();
                    return GetNextToken();
                }

                //  Spidermonkey-specific sharp variables for circular references
                // https://developer.mozilla.org/En/Sharp_variables_in_JavaScript
                // http://mxr.mozilla.org/mozilla-central/source/js/src/jsscan.cpp around line 1935
                var sharp = "#";

                if (ParserPos < Input.Length && Digits.Contains(Input[ParserPos]))
                {
                    while (true)
                    {
                        c = Input[ParserPos];
                        sharp += c;
                        ParserPos += 1;

                        if (ParserPos >= Input.Length || c == '#' || c == '=')
                        {
                            break;
                        }
                    }
                }

                if (c == '#' || ParserPos >= Input.Length)
                {
                    // pass
                }
                else if (Input[ParserPos] == '[' && Input[ParserPos + 1] == ']')
                {
                    sharp += "[]";
                    ParserPos += 2;
                }
                else if (Input[ParserPos] == '{' && Input[ParserPos + 1] == '}')
                {
                    sharp += "{}";
                    ParserPos += 2;
                }

                return new Tuple<string, string>(sharp, "TK_WORD");
            }

            if (c == '<' && Input.Substring(ParserPos - 1, Math.Min(4, Input.Length - ParserPos + 1)) == "<!--")
            {
                ParserPos += 3;
                var ss = "<!--";

                while (ParserPos < Input.Length && Input[ParserPos] != '\n')
                {
                    ss += Input[ParserPos];
                    ParserPos += 1;
                }

                Flags.InHtmlComment = true;
                return new Tuple<string, string>(ss, "TK_COMMENT");
            }

            if (c == '-' && Flags.InHtmlComment && Input.Substring(ParserPos - 1, 3) == "-->")
            {
                Flags.InHtmlComment = false;
                ParserPos += 2;

                if (WantedNewline)
                {
                    AppendNewline();
                }
                
                return new Tuple<string, string>("-->", "TK_COMMENT");
            }

            if (c == '.')
            {
                return new Tuple<string, string>(".", "TK_DOT");
            }

            if (Punct.Contains(c.ToString()))
            {
                var ss = c.ToString();
                while (ParserPos < Input.Length && Punct.Contains(ss + Input[ParserPos]))
                {
                    ss += Input[ParserPos];
                    ParserPos += 1;

                    if (ParserPos >= Input.Length)
                    {
                        break;
                    }
                }

                if (ss == "=")
                {
                    return new Tuple<string, string>("=", "TK_EQUALS");
                }

                if (ss == ",")
                {
                    return new Tuple<string, string>(",", "TK_COMMA");
                }

                return new Tuple<string, string>(ss, "TK_OPERATOR");
            }

            return new Tuple<string, string>(c.ToString(), "TK_UNKNOWN");
        }

        private void HandleStartExpr(string  tokenText)
        {
            if (tokenText == "[")
            {
                if (LastType == "TK_WORD" || LastText == ")")
                {
                    if (LineStarters.Contains(LastText))
                    {
                        Append(" ");
                    }

                    SetMode("(EXPRESSION)");
                    Append(tokenText);
                    return;
                }

                if (Flags.Mode == "[EXPRESSION]" || Flags.Mode == "[INDENTED-EXPRESSION]")
                {
                    if (LastLastText == "]" && LastText == ",")
                    {
                        // # ], [ goes to a new line
                        if (Flags.Mode == "[EXPRESSION]")
                        {
                            Flags.Mode = "[INDENTED-EXPRESSION]";
                            if (!Opts.KeepArrayIndentation)
                            {
                                Indent();
                            }
                        }

                        SetMode("[EXPRESSION]");

                        if (!Opts.KeepArrayIndentation)
                        {
                            AppendNewline();
                        }
                    }
                    else if (LastText == "[")
                    {
                        if (Flags.Mode == "[EXPRESSION]")
                        {
                            Flags.Mode = "[INDENTED-EXPRESSION]";

                            if (!Opts.KeepArrayIndentation)
                            {
                                Indent();
                            }
                        }
                        SetMode("[EXPRESSION]");

                        if (!Opts.KeepArrayIndentation)
                        {
                            AppendNewline();
                        }
                    }
                    else
                    {
                        SetMode("[EXPRESSION]");
                    }
                }
                else
                {
                    SetMode("[EXPRESSION]");
                }
            }
            else
            {
                if (LastText == "for")
                {
                    SetMode("(FOR-EXPRESSION)");
                }
                else if (LastText == "if" || LastText == "while")
                {
                    SetMode("(COND-EXPRESSION)");
                }
                else
                {
                    SetMode("(EXPRESSION)");
                }
            }

            if (LastText == ";" || LastType == "TK_START_BLOCK")
            {
                AppendNewline();
            }
            else if (LastType == "TK_END_EXPR" || LastType == "TK_START_EXPR" || LastType == "TK_END_BLOCK" || LastText == ".")
            {
                // do nothing on (( and )( and ][ and ]( and .(
                if (WantedNewline)
                {
                    AppendNewline();
                }
            }
            else if (LastType != "TK_WORD" && LastType != "TK_OPERATOR")
            {
                Append(" ");
            }
            else if (LastWord == "function" || LastWord == "typeof")
            {
                // function() vs function (), typeof() vs typeof ()
                if (Opts.JslintHappy)
                {
                    Append(" ");
                }
            }
            else if (LineStarters.Contains(LastText) || LastText == "catch")
            {
                Append(" ");
            }

            if (LastType == "TK_EQUALS" ||
                LastType == "TK_OPERATOR")
            {
                if (Flags.Mode != "OJBECT")
                {
                    AllowWrapOrPreservedNewline(tokenText);
                }
            }
            
            Append(tokenText);
        }

        private void HandleEndExpr(string tokenText)
        {
            if (tokenText == "]")
            {
                if (Opts.KeepArrayIndentation)
                {
                    if (LastText == "}")
                    {
                        RemoveIndent();
                        Append(tokenText);
                        RestoreMode();
                        return;
                    }
                }
                else if (Flags.Mode == "[INDENTED-EXPRESSION]")
                {
                    if (LastText == "]")
                    {
                        RestoreMode();
                        AppendNewline();
                        Append(tokenText);
                        return;
                    }
                }
            }
            RestoreMode();
            Append(tokenText);
        }

        private void HandleStartBlock(string tokenText)
        {
            if (LastWord == "do")
            {
                SetMode("DO_BLOCK");
            }
            else
            {
                SetMode("BLOCK");
            }

            if (Opts.BraceStyle == BraceStyle.Expand)
            {
                if (LastType != "TK_OPERATOR")
                {
                    if (LastType == "TK_EQUALS" || 
                        (IsSpecialWord(LastText) && LastText != "else"))
                    {
                        Append(" ");
                    }
                    else
                    {
                        AppendNewline();
                    }
                }
                Append(tokenText);
                Indent();
            }
            else
            {
                if (LastType != "TK_OPERATOR" && LastType != "TK_START_EXPR")
                {
                    if (LastType == "TK_START_BLOCK")
                    {
                        AppendNewline();
                    }
                    else
                    {
                        Append(" ");
                    }
                }
                else
                {
                    // if TK_OPERATOR or TK_START_EXPR
                    if (IsArray(Flags.PreviousMode) && LastText == ",")
                    {
                        if (LastLastText == "}")
                        {
                            Append(" ");
                        }
                        else
                        {
                            AppendNewline();
                        }
                    }
                }
                Indent();
                Append(tokenText);
            }
        }

        private void HandleEndBlock(string tokenText)
        {
            RestoreMode();
            if (Opts.BraceStyle == BraceStyle.Expand)
            {
                if (LastText != "{")
                {
                    AppendNewline();
                }
            }
            else
            {
                if (LastType == "TK_START_BLOCK")
                {
                    if (JustAddedNewline)
                    {
                        RemoveIndent();
                    }
                    else
                    {
                        TrimOutput();
                    }
                }
                else
                {
                    if (IsArray(Flags.Mode) && Opts.KeepArrayIndentation)
                    {
                        Opts.KeepArrayIndentation = false;
                        AppendNewline();
                        Opts.KeepArrayIndentation = true;
                    }
                    else
                    {
                        AppendNewline();
                    }
                }
            }
            Append(tokenText);
        }

        private void HandleWord(string tokenText)
        {
            if (DoBlockJustClosed)
            {
                Append(" ");
                Append(tokenText);
                Append(" ");
                DoBlockJustClosed = false;
                return;
            }
            if (tokenText == "function")
            {
                if (Flags.VarLine && LastText != "=")
                {
                    Flags.VarLineReindented = !Opts.KeepFunctionIndentation;
                }

                if ((JustAddedNewline || LastText == ";") && LastText != "{")
                {
                    // make sure there is a nice clean space of at least one blank line
                    // before a new function definition
                    var haveNewlines = NNewlines;
                    if (!JustAddedNewline)
                    {
                        haveNewlines = 0;
                    }

                    if (!Opts.PreserveNewlines)
                    {
                        haveNewlines = 1;
                    }

                    for (var i = 0; i < (2 - haveNewlines); ++i)
                    {
                        AppendNewline(false);
                    }
                }

                if ((LastText == "get" || LastText == "set" || LastText == "new") || LastType == "TK_WORD")
                {
                    Append(" ");
                }

                if (LastType == "TK_WORD")
                {
                    if (LastText == "get" || LastText == "set" || LastText == "new" || LastText == "return")
                    {
                        Append(" ");
                    }
                    else
                    {
                        AppendNewline();
                    }
                }
                else if (LastType == "TK_OPERATOR" || LastText == "=")
                {
                    // foo = function
                    Append(" ");
                }
                else if (IsExpression(Flags.Mode))
                {
                    // (function
                }
                else
                {
                    AppendNewline();
                }
                
                Append("function");
                LastWord = "function";
                return;
            }

            if (tokenText == "case" || (tokenText == "default" && Flags.InCaseStatement))
            {
                AppendNewline();
                if (Flags.CaseBody)
                {
                    RemoveIndent();
                    Flags.CaseBody = false;
                    Flags.IndentationLevel -= 1;
                }
                Append(tokenText);
                Flags.InCase = true;
                Flags.InCaseStatement = true;
                return;
            }

            var prefix = "NONE";

            if (LastType == "TK_END_BLOCK")
            {
                if (tokenText != "else" && tokenText != "catch" && tokenText != "finally")
                {
                    prefix = "NEWLINE";
                }
                else
                {
                    if (Opts.BraceStyle == BraceStyle.Expand || Opts.BraceStyle == BraceStyle.EndExpand)
                    {
                        prefix = "NEWLINE";
                    }
                    else
                    {
                        prefix = "SPACE";
                        Append(" ");
                    }
                }
            }
            else if (LastType == "TK_SEMICOLON" && (Flags.Mode == "BLOCK" || Flags.Mode == "DO_BLOCK"))
            {
                prefix = "NEWLINE";
            }
            else if (LastType == "TK_SEMICOLON" && IsExpression(Flags.Mode))
            {
                prefix = "SPACE";
            }
            else if (LastType == "TK_STRING")
            {
                prefix = "NEWLINE";
            }
            else if (LastType == "TK_WORD")
            {
                if (LastText == "else")
                {
                    // eat newlines between ...else *** some_op...
                    // won't preserve extra newlines in this place (if any), but don't care that much
                    TrimOutput(true);
                }
                prefix = "SPACE";
            }
            else if (LastType == "TK_START_BLOCK")
            {
                prefix = "NEWLINE";
            }
            else if (LastType == "TK_END_EXPR")
            {
                Append(" ");
                prefix = "NEWLINE";
            }

            if (Flags.IfLine && LastType == "TK_END_EXPR")
            {
                Flags.IfLine = false;
            }

            if (LastType == "TK_COMMA" ||
                LastType == "TK_START_EXPR" ||
                LastType == "TK_EQUALS" ||
                LastType == "TK_OPERATOR")
            {
                if (Flags.Mode != "OBJECT")
                {
                    AllowWrapOrPreservedNewline(tokenText);
                }
            }

            if (LineStarters.Contains(tokenText))
            {
                if (LastText == "else")
                {
                    prefix = "SPACE";
                }
                else
                {
                    prefix = "NEWLINE";
                }
            }

            if (tokenText == "else" || tokenText == "catch" || tokenText == "finally")
            {
                if (LastType != "TK_END_BLOCK" || Opts.BraceStyle == BraceStyle.Expand ||
                    Opts.BraceStyle == BraceStyle.EndExpand)
                {
                    AppendNewline();
                }
                else
                {
                    TrimOutput(true);
                    Append(" ");
                }
            }
            else if (prefix == "NEWLINE")
            {
                if (IsSpecialWord(LastText))
                {
                    // no newline between return nnn
                    Append(" ");
                }
                else if (LastType != "TK_END_EXPR")
                {
                    if ((LastType != "TK_START_EXPR" || tokenText != "var") && LastText != ":")
                    {
                        // no need to force newline on VAR -
                        // for (var x = 0...
                        if (tokenText == "if" && LastWord == "else" && LastText != "{")
                        {
                            Append(" ");
                        }
                        else
                        {
                            Flags.VarLine = false;
                            Flags.VarLineReindented = false;
                            AppendNewline();
                        }
                    }
                }
                else if (LineStarters.Contains(tokenText) && LastText != ")")
                {
                    Flags.VarLine = false;
                    Flags.VarLineReindented = false;
                    AppendNewline();
                }
            }
            else if (IsArray(Flags.Mode) && LastText == "," && LastLastText == "}")
            {
                AppendNewline(); //}, in lists get a newline
            }
            else if (prefix == "SPACE")
            {
                Append(" ");
            }

            Append(tokenText);
            LastWord = tokenText;

            if (tokenText == "var")
            {
                Flags.VarLine = true;
                Flags.VarLineReindented = false;
                Flags.VarLineTainted = false;
            }

            if (tokenText == "if")
            {
                Flags.IfLine = true;
            }

            if (tokenText == "else")
            {
                Flags.IfLine = false;
            }
        }

        private void HandleSemicolon(string tokenText)
        {
            Append(tokenText);
            Flags.VarLine = false;
            Flags.VarLineReindented = false;
            if (Flags.Mode == "OBJECT")
            {
                // OBJECT mode is weird and doesn't get reset too well.
                Flags.Mode = "BLOCK";
            }
        }

        private void HandleString(string tokenText)
        {
            if (LastType == "TK_END_EXPR" &&
                (Flags.PreviousMode == "(COND-EXPRESSION)" || Flags.PreviousMode == "(FOR-EXPRESSION)"))
            {
                Append(" ");
            }
            else if (LastType == "TK_WORD")
            {
                Append(" ");
            }
            else if (LastType == "TK_COMMA" || 
                     LastType == "TK_START_EXPR" || 
                     LastType == "TK_EQUALS" ||
                     LastType == "TK_OPERATOR")
            {
                if (Flags.Mode != "OBJECT")
                {
                    AllowWrapOrPreservedNewline(tokenText);
                }
            }
            else
            {
                AppendNewline();
            }

            Append(tokenText);
        }

        private void HandleEquals(string tokenText)
        {
            if (Flags.VarLine)
            {
                // just got an '=' in a var-line, different line breaking rules will apply
                Flags.VarLineTainted = true;
            }

            Append(" ");
            Append(tokenText);
            Append(" ");
        }

        private void HandleComma(string tokenText)
        {
            if (LastType == "TK_COMMENT")
            {
                AppendNewline();
            }

            if (Flags.VarLine)
            {
                if (IsExpression(Flags.Mode) || LastType == "TK_END_BLOCK")
                {
                    // do not break on comma, for ( var a = 1, b = 2
                    Flags.VarLineTainted = false;
                }
                if (Flags.VarLineTainted)
                {
                    Append(tokenText);
                    Flags.VarLineReindented = true;
                    Flags.VarLineTainted = false;
                    AppendNewline();
                    return;
                }
                else
                    Flags.VarLineTainted = false;
                Append(tokenText);
                Append(" ");
                return;
            }

            if (LastType == "TK_END_BLOCK" && Flags.Mode != "(EXPRESSION)")
            {
                Append(tokenText);
                if (Flags.Mode == "OBJECT" && LastText == "}")
                {
                    AppendNewline();
                }
                else
                {
                    Append(" ");
                }
            }
            else
            {
                if (Flags.Mode == "OBJECT")
                {
                    Append(tokenText);
                    AppendNewline();
                }
                else
                {
                    // EXPR or DO_BLOCK
                    Append(tokenText);
                    Append(" ");
                }
            }
        }

        private void HandleOperator(string tokenText)
        {
            var spaceBefore = true;
            var spaceAfter = true;

            if (IsSpecialWord(LastText))
            {
                // return had a special handling in TK_WORD
                Append(" ");
                Append(tokenText);
                return;
            }

            // hack for actionscript's import .*;
            if (tokenText == "*" && LastType == "TK_DOT" && !LastLastText.All(char.IsDigit))
            {
                Append(tokenText);
                return;
            }

            if (tokenText == ":" && Flags.InCase)
            {
                Flags.CaseBody = true;
                Indent();
                Append(tokenText);
                AppendNewline();
                Flags.InCase = true;
                return;
            }

            if (tokenText == "::")
            {
                // no spaces around the exotic namespacing syntax operator
                Append(tokenText);
                return;
            }

            if ((tokenText == "++" || tokenText == "--" || tokenText == "!") || (tokenText == "+" || tokenText == "-") &&
                ((LastType == "TK_START_BLOCK" || LastType == "TK_START_EXPR" || LastType == "TK_EQUALS" || LastType == "TK_OPERATOR") ||
                (LineStarters.Contains(LastText) || LastText == ",")))
            {
                spaceBefore = false;
                spaceAfter = false;

                if (LastText == ";" && IsExpression(Flags.Mode))
                {
                    // for (;; ++i)
                    // ^^
                    spaceBefore = true;
                }

                if (LastText == "TK_WORD" && LineStarters.Contains(LastText))
                {
                    spaceBefore = true;
                }

                if (Flags.Mode == "BLOCK" && (LastText == ";" || LastText == "{"))
                {
                    // { foo: --i }
                    // foo(): --bar
                    AppendNewline();
                }
            }
            else if (tokenText == ":")
            {
                if (Flags.TernaryDepth == 0)
                {
                    if (Flags.Mode == "BLOCK")
                    {
                        Flags.Mode = "OBJECT";
                    }
                    spaceBefore = false;
                }
                else
                {
                    Flags.TernaryDepth -= 1;
                }
            }
            else if (tokenText == "?")
            {
                Flags.TernaryDepth += 1;
            }

            if (spaceBefore)
            {
                Append(" ");
            }

            Append(tokenText);

            if (spaceAfter)
            {
                Append(" ");
            }
        }

        private void HandleBlockComment(string tokenText)
        {
            var lines = tokenText.Replace("\r", "").Split('\n');
            // all lines start with an asterisk? that's a proper box comment

            if (lines.Skip(1).Where(x => x.Trim() == "" || x.TrimStart()[0] != '*').All(string.IsNullOrEmpty))
            {
                AppendNewline();
                Append(lines[0]);
                foreach (var line in lines.Skip(1))
                {
                    AppendNewline();
                    Append(" " + line.Trim());
                }
            }
            else
            {
                // simple block comment: leave intact
                if (lines.Length > 1)
                {
                    // multiline comment starts on a new line
                    AppendNewline();
                }
                else
                {
                    // single line /* ... */ comment stays on the same line
                    Append(" ");
                }
                foreach (var line in lines)
                {
                    Append(line);
                    Append("\n");
                }
            }
            AppendNewline();
        }

        private void HandleInlineComment(string tokenText)
        {
            Append(" ");
            Append(tokenText);
            Append(" ");
        }

        private void HandleComment(string tokenText)
        {
            if (LastText == "," && !WantedNewline)
            {
                TrimOutput(true);
            }

            if (LastType != "TK_COMMENT")
            {
                if (WantedNewline)
                {
                    AppendNewline();
                }
                else
                {
                    Append(" ");
                }
            }

            Append(tokenText);
            AppendNewline();
        }

        private void HandleDot(string tokenText)
        {
            if (IsSpecialWord(LastText))
            {
                Append(" ");
            }
            else
            {
                AllowWrapOrPreservedNewline(tokenText, LastText == ")" && Opts.BreakChainedMethods);
            }
            
            Append(tokenText);
        }

        private void HandleUnknown(string tokenText)
        {
            Append(tokenText);
        }
    }
}