using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Collections;
using System.Text.RegularExpressions;

namespace DevelopAssistant.Format
{
    public class JSBeautifyOptions
    {
        public int? indent_size { get; set; }
        public char? indent_char { get; set; }
        public int? indent_level { get; set; }
        public bool? preserve_newlines { get; set; }
    }
    public class JSBeautify
    {
        private StringBuilder output;
        private string indent_string;
        private int indent_level;
        private string token_text;
        private Stack<string> modes;
        private string current_mode;
        private int opt_indent_size;
        private char opt_indent_char;
        private int opt_indent_level;
        private bool opt_preserve_newlines;
        private bool if_line_flag;
        private bool do_block_just_closed;
        private string input;

        private void trim_output()
        {
            while ((output.Length>0) && ((output[output.Length-1]==' ')||(output[output.Length-1].ToString()==indent_string)))
            {
                output.Remove(output.Length-1,1);
            }
        }
        
        private void print_newline(bool? ignore_repeated)
        {
            ignore_repeated = ignore_repeated ?? true;

            if_line_flag = false;
            trim_output();

            if (output.Length == 0)
                return;

            if ((output[output.Length - 1] != '\n') || !ignore_repeated.Value)
            {
                output.Append(Environment.NewLine);
            }

            for (var i = 0; i < indent_level; i++)
            {
                output.Append(indent_string);
            }
        }

        private void print_space()
        {
            var last_output = " ";
            if (output.Length > 0)
                last_output = output[output.Length - 1].ToString();
            if ((last_output != " ") && (last_output != "\n") && (last_output != indent_string))
            {
                output.Append(' ');
            }
        }
 
        private void print_token()
        {
            output.Append(token_text);
        }

        private void indent()
        {
            indent_level++;
        }

        private void unindent()
        {
            if (indent_level > 0)
                indent_level--;
        }

        private void remove_indent()
        {
            if ((output.Length>0) && (output[output.Length-1].ToString()==indent_string))
            {
                output.Remove(output.Length-1,1);
            }
        }

        private void set_mode(string mode)
        {
            modes.Push(current_mode);
            current_mode = mode;
        }

        private void restore_mode()
        {
            do_block_just_closed = (current_mode == "DO_BLOCK");
            current_mode = modes.Pop();
        }

        private bool in_array(object what, ArrayList arr)
        {
            return arr.Contains(what);
        
        }

        private bool is_ternary_op()
        {
            int level = 0;
            int colon_count = 0;
            for (var i = output.Length - 1; i >= 0; i--)
            {
                switch (output[i])
                {
                    case ':':
                        if (level == 0)
                            colon_count++;
                        break;
                    case '?':
                        if (level == 0)
                        {
                            if (colon_count == 0)
                            {
                                return true;
                            }
                            else
                            {
                                colon_count--;
                            }
                        }
                        break;
                    case '{':
                        if (level == 0) return false;
                        level--;
                        break;
                    case '(':
                    case '[':
                        level--;
                        break;
                    case ')':
                    case ']':
                    case '}':
                        level++;
                        break;
                }
            }
            return false;
        }

        private string whitespace;
        private string wordchar;
        private int parser_pos;
        private string last_type;
        private string last_text;
        private string digits;
        private string[] punct;
        private string prefix;
        private string[] get_next_token(ref int parser_pos)
        {
            var n_newlines = 0;

            if (parser_pos >= input.Length)
            {
                return new string[] { "", "TK_EOF" };
            }

            string c = input[parser_pos].ToString();
            parser_pos++;

            while (whitespace.Contains(c))
            {
                if (parser_pos >= input.Length)
                {
                    return new string[] { "", "TK_EOF" };
                }

                if (c == "\n")
                    n_newlines++;

                c = input[parser_pos].ToString();
                parser_pos++;
            }

            var wanted_newline = false;

            if (opt_preserve_newlines)
            {
                if (n_newlines > 1)
                {
                    for (var i = 0; i < 2; i++)
                    {
                        print_newline(i == 0);
                    }
                }
                wanted_newline = (n_newlines == 1);

            }

            if (wordchar.Contains(c))
            {
                if (parser_pos < input.Length)
                {
                    while (wordchar.Contains(input[parser_pos]))
                    {
                        c += input[parser_pos];
                        parser_pos++;
                        if (parser_pos == input.Length)
                            break;
                    }
                }
            
            
                if ((parser_pos!=input.Length) && (Regex.IsMatch(c,"^[0-9]+[Ee]$")) && ((input[parser_pos] == '-') || (input[parser_pos]=='+')))
                {
                    var sign = input[parser_pos];
                    parser_pos++;

                    var t = get_next_token(ref parser_pos);
                    c += sign + t[0];
                    return new string[] { c, "TK_WORD" };
                }

                if (c == "in")
                {
                    return new string[] { c, "TK_OPERATOR" };
                }

                if (wanted_newline && last_type != "TK_OPERATOR" && !if_line_flag)
                {
                    print_newline(null);
                }
                return new string[] { c, "TK_WORD" };

            }

            if ((c == "(") || (c == "["))
                return new string[] {c,"TK_START_EXPR"};

            if (c == ")" || c == "]") {
                return new string[] {c, "TK_END_EXPR"};
            }

            if (c == "{") {
                return new string[] {c, "TK_START_BLOCK"};
            }

            if (c == "}") {
                return new string[] {c, "TK_END_BLOCK"};
            }

            if (c == ";") {
                return new string[] {c, "TK_SEMICOLON"};
            }

            if (c=="/") {
                var comment = "";
                if (input[parser_pos]=='*') {
                    parser_pos++;
                    if (parser_pos<input.Length){
                        while (!((input[parser_pos]=='*') && (input[parser_pos+1]>'\0') && (input[parser_pos+1]=='/') && (parser_pos<input.Length)))
                        {
                            comment+=input[parser_pos];
                            parser_pos++;
                            if (parser_pos>=input.Length) {
                                break;
                            }
                        }
                    }
                
                    parser_pos+=2;
                    return new string[] { "/*"+comment+"*/", "TK_BLOCK_COMMENT"};
                }   

                if (input[parser_pos]=='/') {
                    comment = c;
                    while ((input[parser_pos]!='\x0d') && (input[parser_pos]!='\x0a')) {
                        comment+=input[parser_pos];
                        parser_pos++;
                        if (parser_pos>=input.Length){
                            break;
                        }
                    }

                    parser_pos++;
                    if (wanted_newline){
                        print_newline(null);
                    }
                    return new string[] {comment,"TK_COMMENT"};

                }
            }

            if ( (c=="'") || (c=="\"")  || ((c=="/")
                    && ((last_type=="TK_WORD" && last_text=="return") || ((last_type=="TK_START_EXPR")  || (last_type=="TK_START_BLOCK") || (last_type=="TK_END_BLOCK")
                            || (last_type=="TK_OPERATOR") || (last_type=="TK_EOF") || (last_type=="TK_SEMICOLON"))))
                ) {
                var sep = c;
                var esc = false;
                var resulting_string = c;

                if (parser_pos<input.Length) {
                    if (sep=="/") {
                        var in_char_class=false;
                        while ((esc) || (in_char_class) || (input[parser_pos].ToString()!=sep)) {
                            resulting_string+=input[parser_pos];
                            if (!esc) {
                                esc = input[parser_pos]=='\\';
                                if (input[parser_pos]=='['){
                                    in_char_class=true;
                                }
                                else if (input[parser_pos]==']') {
                                    in_char_class=false;
                                }
                            }
                            else {
                                esc=false;
                            }
                            parser_pos++;
                            if (parser_pos>=input.Length) {
                                return new string[] { resulting_string, "TK_STRING"};
                            }
                        } 
                    }
                    else {
                        while ((esc) || (input[parser_pos].ToString()!=sep)) {
                            resulting_string += input[parser_pos];
                            if (!esc) {
                                esc = input[parser_pos]=='\\';
                            } else {
                                esc=false;
                            }
                            parser_pos++;
                            if (parser_pos>=input.Length){
                                return new string[] {resulting_string,"TK_STRING"};
                            }
                        }
                    }
                }

                parser_pos += 1;

                resulting_string += sep;

                if (sep == "/") {
                    // regexps may have modifiers /regexp/MOD , so fetch those, too
                    while ((parser_pos < input.Length) && (wordchar.Contains(input[parser_pos]))) {
                        resulting_string += input[parser_pos];
                        parser_pos += 1;
                    }
                }
                return new string []  {resulting_string, "TK_STRING"};


            }

            if (c == "#") {
                var sharp = "#";
                if ((parser_pos < input.Length) && (digits.Contains(input[parser_pos]))) {
                    do {
                        c = input[parser_pos].ToString();
                        sharp += c;
                        parser_pos += 1;
                    } while ((parser_pos < input.Length ) && (c != "#") && (c != "="));
                    if (c == "#") {
                        return new string[] {sharp, "TK_WORD"};;
                    } else {
                        return new string[] {sharp, "TK_OPERATOR"};;
                    }
                }
            }


            if ((c == "<") && (input.Substring(parser_pos - 1,  3) == "<!--")) {
                parser_pos += 3;
                return new string[] {"<!--", "TK_COMMENT"};;
            }

            if ((c == "-") && (input.Substring(parser_pos - 1,  2) == "-->")) {
                parser_pos += 2;
                if (wanted_newline) {
                    print_newline(null);
                }
                return new string[] {"-->", "TK_COMMENT"};
            }

            if (punct.Contains(c)) {
                while ((parser_pos < input.Length) && (punct.Contains(c + input[parser_pos]))) {
                    c += input[parser_pos];
                    parser_pos += 1;
                    if (parser_pos >= input.Length) {
                        break;
                    }
                }

                return new string[] {c, "TK_OPERATOR"};
            }

            return new string[] {c, "TK_UNKNOWN"};


        }

        private string last_word;
        private bool var_line;
        private bool var_line_tainted;
        private string[] line_starters;
        private bool in_case;
        private bool add_script_tags;
        private string token_type;       

        public string GetResult()
        {
            if (add_script_tags)
            {
                output.AppendLine().AppendLine("</script>");
            }
                
            return output.ToString();
        }
       
        public JSBeautify(string js_source_text, JSBeautifyOptions options)
        {
            opt_indent_size = options.indent_size ?? 4;
            opt_indent_char = options.indent_char ?? ' ';
            opt_indent_level = options.indent_level ?? 0;
            opt_preserve_newlines = options.preserve_newlines ?? true;
            output = new StringBuilder();
            modes = new Stack<string>();            

            indent_string = "";
            
            while (opt_indent_size > 0) {
                indent_string += opt_indent_char;
                opt_indent_size -= 1;
            }

            indent_level = opt_indent_level;           

            input = js_source_text.Replace("<script type=\"text/javascript\">","").Replace("</script>","");
            if (input.Length != js_source_text.Length)
            {
                output.AppendLine("<script type=\"text/javascript\">");
                add_script_tags = true;
            }

            last_word = ""; // last 'TK_WORD' passed
            last_type = "TK_START_EXPR"; // last token type
            last_text = ""; // last token text
            
            do_block_just_closed = false;
            var_line = false;         // currently drawing var .... ;
            var_line_tainted = false; // false: var a = 5; true: var a = 5, b = 6

            whitespace = "\n\r\t ";
            wordchar = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_$";
            digits = "0123456789";

            // <!-- is a special case (ok, it's a minor hack actually)
            punct = "+ - * / % & ++ -- = += -= *= /= %= == === != !== > < >= <= >> << >>> >>>= >>= <<= && &= | || ! !! , : ? ^ ^= |= ::".Split(' ');

            // words which should always start on new line.
            line_starters = "continue,try,throw,return,var,if,switch,case,default,for,while,break,function".Split(',');

            // states showing if we are currently in expression (i.e. "if" case) - 'EXPRESSION', or in usual block (like, procedure), 'BLOCK'.
            // some formatting depends on that.
            current_mode = "BLOCK";
            modes.Push(current_mode);

            parser_pos = 0;
            in_case = false;

            while (true) {
                var t = get_next_token(ref parser_pos);
                token_text = t[0];
                token_type = t[1];
                if (token_type == "TK_EOF") {
                    break;
                }

                switch (token_type) {

                case "TK_START_EXPR":
                    var_line = false;
                    set_mode("EXPRESSION");
                    if ((last_text == ";") || (last_type == "TK_START_BLOCK")) {
                        print_newline(null);
                    } else if ((last_type == "TK_END_EXPR") ||( last_type == "TK_START_EXPR")) {
                        // do nothing on (( and )( and ][ and ]( ..
                    } else if ((last_type != "TK_WORD") && (last_type != "TK_OPERATOR")) {
                        print_space();
                    } else if (line_starters.Contains(last_word)) {
                        print_space();
                    }
                    print_token();
                    break;

                case "TK_END_EXPR":
                    print_token();
                    restore_mode();
                    break;

                case "TK_START_BLOCK":

                    if (last_word == "do") {
                        set_mode("DO_BLOCK");
                    } else {
                        set_mode("BLOCK");
                    }
                    if ((last_type != "TK_OPERATOR") && (last_type != "TK_START_EXPR")) {
                        if (last_type == "TK_START_BLOCK") {
                            print_newline(null);
                        } else {
                            print_space();
                        }
                    }
                    print_token();
                    indent();
                    break;

                case "TK_END_BLOCK":
                    if (last_type == "TK_START_BLOCK") {
                        // nothing
                        trim_output();
                        unindent();
                    } else {
                        unindent();
                        print_newline(null);
                    }
                    print_token();
                    restore_mode();
                    break;

                case "TK_WORD":

                    if (do_block_just_closed) {
                        // do {} ## while ()
                        print_space();
                        print_token();
                        print_space();
                        do_block_just_closed = false;
                        break;
                    }

                    if ((token_text == "case" )|| (token_text == "default")) {
                        if (last_text == ":") {
                            // switch cases following one another
                            remove_indent();
                        } else {
                            // case statement starts in the same line where switch
                            unindent();
                            print_newline(null);
                            indent();
                        }
                        print_token();
                        in_case = true;
                        break;
                    }

                    prefix = "NONE";

                    if (last_type == "TK_END_BLOCK") {
                        if (!(new string[] {"else", "catch", "finally" }).Contains(token_text.ToLower())) {
                            prefix = "NEWLINE";
                        } else {
                            prefix = "SPACE";
                            print_space();
                        }
                    } else if ((last_type == "TK_SEMICOLON") && ((current_mode == "BLOCK") ||( current_mode == "DO_BLOCK"))) {
                        prefix = "NEWLINE";
                    } else if ((last_type == "TK_SEMICOLON") && (current_mode == "EXPRESSION")) {
                        prefix = "SPACE";
                    } else if (last_type == "TK_STRING") {
                        prefix = "NEWLINE";
                    } else if (last_type == "TK_WORD") {
                        prefix = "SPACE";
                    } else if (last_type == "TK_START_BLOCK") {
                        prefix = "NEWLINE";
                    } else if (last_type == "TK_END_EXPR") {
                        print_space();
                        prefix = "NEWLINE";
                    }

                    if ((last_type != "TK_END_BLOCK") && ((new string[] {"else", "catch", "finally"}).Contains(token_text.ToLower()))) {
                        print_newline(null);
                    } else if ((line_starters.Contains(token_text)) ||( prefix == "NEWLINE")) {
                        if (last_text == "else") {
                            // no need to force newline on else break
                            print_space();
                        } else if (((last_type == "TK_START_EXPR") ||( last_text == "=") || (last_text == ",")) && (token_text == "function")) {
                            // no need to force newline on "function": (function
                            // DONOTHING
                        } else if ((last_type == "TK_WORD") && ((last_text == "return") || (last_text == "throw"))) {
                            // no newline between "return nnn"
                            print_space();
                        } else if (last_type != "TK_END_EXPR") {
                            if (((last_type != "TK_START_EXPR") || (token_text != "var")) && (last_text != ":")) {
                                // no need to force newline on "var": for (var x = 0...)
                                if ((token_text == "if") && (last_type == "TK_WORD") && (last_word == "else")) {
                                    // no newline for } else if {
                                    print_space();
                                } else {
                                    print_newline(null);
                                }
                            }
                        } else {
                            if ((line_starters.Contains(token_text)) && (last_text != ")")) {
                                print_newline(null);
                            }
                        }
                    } else if (prefix == "SPACE") {
                        print_space();
                    }
                    print_token();
                    last_word = token_text;

                    if (token_text == "var") {
                        var_line = true;
                        var_line_tainted = false;
                    }

                    if (token_text == "if" || token_text == "else") {
                        if_line_flag = true;
                    }

                    break;

                case "TK_SEMICOLON":

                    print_token();
                    var_line = false;
                    break;

                case "TK_STRING":

                    if ((last_type == "TK_START_BLOCK" )||( last_type == "TK_END_BLOCK") || (last_type == "TK_SEMICOLON")) {
                        print_newline(null);
                    } else if (last_type == "TK_WORD") {
                        print_space();
                    }
                    print_token();
                    break;

                case "TK_OPERATOR":

                    var start_delim = true;
                    var end_delim = true;
                    if (var_line && (token_text != ",")) {
                        var_line_tainted = true;
                        if (token_text == ":") {
                            var_line = false;
                        }
                    }
                    if (var_line && (token_text == ",") && (current_mode == "EXPRESSION")) {
                        // do not break on comma, for(var a = 1, b = 2)
                        var_line_tainted = false;
                    }

                    if (token_text == ":" && in_case) {
                        print_token(); // colon really asks for separate treatment
                        print_newline(null);
                        in_case = false; 
                        break;
                    }

                    if (token_text == "::") {
                        // no spaces around exotic namespacing syntax operator
                        print_token();
                        break;
                    }

                    if (token_text == ",") {
                        if (var_line) {
                            if (var_line_tainted) {
                                print_token();
                                print_newline(null);
                                var_line_tainted = false;
                            } else {
                                print_token();
                                print_space();
                            }
                        } else if (last_type == "TK_END_BLOCK") {
                            print_token();
                            print_newline(null);
                        } else {
                            if (current_mode == "BLOCK") {
                                print_token();
                                print_newline(null);
                            } else {
                                // EXPR od DO_BLOCK
                                print_token();
                                print_space();
                            }
                        }
                        break;
                    } else if ((token_text == "--" )|| (token_text == "++")) { // unary operators special case
                        if (last_text == ";") {
                            if (current_mode == "BLOCK") {
                                // { foo; --i }
                                print_newline(null);
                                start_delim = true;
                                end_delim = false;
                            } else {
                                // space for (;; ++i)
                                start_delim = true;
                                end_delim = false;
                            }
                        } else {
                            if (last_text == "{") {
                                // {--i
                                print_newline(null);
                            }
                            start_delim = false;
                            end_delim = false;
                        }
                    } else if (((token_text == "!") ||( token_text == "+") || (token_text == "-")) && ((last_text == "return" )|| (last_text == "case"))) {
                        start_delim = true;
                        end_delim = false;
                    } else if (((token_text == "!" )||( token_text == "+") || (token_text == "-")) && (last_type == "TK_START_EXPR")) {
                        // special case handling: if (!a)
                        start_delim = false;
                        end_delim = false;
                    } else if (last_type == "TK_OPERATOR") {
                        start_delim = false;
                        end_delim = false;
                    } else if (last_type == "TK_END_EXPR") {
                        start_delim = true;
                        end_delim = true;
                    } else if (token_text == ".") {
                        // decimal digits or object.property
                        start_delim = false;
                        end_delim = false;

                    } else if (token_text == ":") {
                        if (is_ternary_op()) {
                            start_delim = true;
                        } else {
                            start_delim = false;
                        }
                    }
                    if (start_delim) {
                        print_space();
                    }

                    print_token();

                    if (end_delim) {
                        print_space();
                    }
                    break;

                case "TK_BLOCK_COMMENT":

                    print_newline(null);
                    print_token();
                    print_newline(null);
                    break;

                case "TK_COMMENT":

                    // print_newline();
                    print_space();
                    print_token();
                    print_newline(null);
                    break;

                case "TK_UNKNOWN":
                    print_token();
                    break;
                }

                last_type = token_type;
                last_text = token_text;
            }


        }


    }
}