/*
 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 */

import com.oracle.jmx.remote.rest.json.parser.JSONParser;
import com.oracle.jmx.remote.rest.json.parser.ParseException;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Random;

/**
 * @test @modules java.management.rest
 * @run main JSONTest
 */
public class JSONTest {

    public static void main(String[] args) throws ParseException {
        JSONGraphGenerator graphGen = new JSONGraphGenerator(50);
        JSONElement jElem = graphGen.generateJsonGraph(20000);
        System.out.println("Graph Generated");
        String str = jElem.toJsonString();
        System.out.println(str);

        JSONParser parser = new JSONParser(str);

        com.oracle.jmx.remote.rest.json.JSONElement parse = parser.parse();
        String resultJson = parse.toJsonString();
        System.out.println(resultJson);
    }
}

interface JSONElement {

    String toJsonString();
}

interface Visitable {

    public void accept(NodeVisitor visitor);
}

interface NodeVisitor {

    public void visit(Node node);

    //visit other concrete items
    public void visit(Digit19 digit12);

    public void visit(Digits dvd);
}

class Node implements Visitable {

    final private String label;

    public Node(String label) {
        children = new LinkedList<>();
        this.label = label;
    }

    public Node() {
        this("");
    }

    public void add(Node node) {
        if (!children.contains(node)) {
            children.add(node);
        }
    }

    public String getLabel() {
        return label;
    }
    List<Node> children;

    @Override
    public void accept(NodeVisitor visitor) {
        visitor.visit(this);
    }
}

class Digit19 extends Node {

    Random rnd = new Random();

    public Digit19() {
        super();
    }

    @Override
    public String getLabel() {
        return "" + (rnd.nextInt(9) + 1);
    }
}

class Digits extends Node {

    Random rnd = new Random();

    public Digits() {
        super();
    }

    @Override
    public String getLabel() {
        return "" + (rnd.nextInt(10));
    }
}

class JSONNumberGenerator {

    private final static Node root;
    Number num;

    static {
        root = new Node("R");
        Node minus1 = new Node("-");
        Node zero = new Node("0");
        Node digit19 = new Digit19();
        Node digits1 = new Digits();
        Node dot = new Node(".");
        Node digits2 = new Digits();
        Node e = new Node("e");
        Node E = new Node("E");
        Node plus = new Node("+");
        Node minus2 = new Node("-");
        Node digits3 = new Digits();
        Node terminal = new Node("T");

        root.add(zero);
        root.add(minus1);
        root.add(digit19);

        minus1.add(zero);
        minus1.add(digit19);

        zero.add(dot);
//        zero.add(e);
//        zero.add(E);
        zero.add(terminal);

        digit19.add(dot);
        digit19.add(digits1);
//        digit19.add(e);
//        digit19.add(E);
        digit19.add(terminal);

        digits1.add(dot);
        digits1.add(digits1);
//        digits1.add(e);
//        digits1.add(E);
        digits1.add(terminal);

        dot.add(digits2);

        digits2.add(digits2);
        digits2.add(e);
        digits2.add(E);
        digits2.add(terminal);

        e.add(plus);
        e.add(minus2);
        e.add(digits3);

        E.add(plus);
        E.add(minus2);
        E.add(digits3);

        plus.add(digits3);
        minus2.add(digits3);

        digits3.add(digits3);
        digits3.add(terminal);
    }

    private static class NumberNodeVisitor implements NodeVisitor {

        private final StringBuilder sbuf = new StringBuilder();
        Random rnd = new Random();

        public NumberNodeVisitor() {
        }

        @Override
        public void visit(Node node) {
            if (!node.getLabel().equals("R")) {
                sbuf.append(node.getLabel());
            }
            if (node.children.size() > 0) {
                Node child = node.children.get(rnd.nextInt(node.children.size()));
                if (!child.getLabel().equals("T")) {
                    visit(child);
                }
            } else {
                System.out.println("Found node " + node.getLabel() + " with children : " + node.children.size());
            }
        }

        @Override
        public void visit(Digit19 digit12) {
            sbuf.append(digit12.getLabel());
            Node child = digit12.children.get(rnd.nextInt(digit12.children.size()));
            if (!child.getLabel().equals("T")) {
                visit(child);
            }
        }

        @Override
        public void visit(Digits digits) {
            sbuf.append(digits.getLabel());
            Node child = digits.children.get(rnd.nextInt(digits.children.size()));
            if (!child.getLabel().equals("T")) {
                visit(child);
            }
        }

        public String getNumber() {
            return sbuf.toString();
        }

    }

    public String generate() {
        NumberNodeVisitor visitor = new NumberNodeVisitor();
        visitor.visit(root);
        // System.out.println(visitor.getNumber());
//        Double.parseDouble(visitor.getNumber());
        return visitor.getNumber();
    }
}

class TestJsonObject extends LinkedHashMap<String, JSONElement> implements JSONElement {

    @Override
    public String toJsonString() {
        if (isEmpty()) {
            return null;
        }

        StringBuilder sbuild = new StringBuilder();
        sbuild.append("{");
        keySet().forEach((elem) -> {
            sbuild.append(elem).append(": ").
                    append((get(elem) != null) ? get(elem).toJsonString() : "null").append(",");
        });

        sbuild.deleteCharAt(sbuild.lastIndexOf(","));
        sbuild.append("}");
        return sbuild.toString();
    }
}

class TestJsonArray extends ArrayList<JSONElement> implements JSONElement {

    @Override
    public String toJsonString() {
        if (isEmpty()) {
            return null;
        }
        StringBuilder sbuild = new StringBuilder();
        sbuild.append("[");
        Iterator<JSONElement> itr = iterator();
        while (itr.hasNext()) {
            JSONElement val = itr.next();
            if (val != null) {
                sbuild.append(val.toJsonString()).append(", ");
            } else {
                sbuild.append("null").append(", ");
            }
        }

        sbuild.deleteCharAt(sbuild.lastIndexOf(","));
        sbuild.append("]");
        return sbuild.toString();
    }
}

class TestJsonPrimitive implements JSONElement {

    private final String s;

    public TestJsonPrimitive(String s) {
        this.s = s;
    }

    @Override
    public String toJsonString() {
        return s;
    }
}

class JSONStringGenerator {

    private static final int minStringLength = 0;
    private static final int maxStringLength = 10;

    private final Random rnd = new Random(System.currentTimeMillis());

    private static final String specials = "\b" + "\f" + "\n" + "\r" + "\t" + "\\" + "\"";    // TODO: Special characters '/', '\', '"', "\\uxxxx"
    private static final String alphanums = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";

    public String generate() {
        char ch;
        StringBuilder sbuf = new StringBuilder();
        int len = minStringLength + rnd.nextInt(maxStringLength - minStringLength + 1);
        sbuf.append("\"");
        for (int i = 0; i < len; i++) {
            if (rnd.nextInt(10) == 1) { // 1/10 chances of a control character
                ch = specials.charAt(rnd.nextInt(specials.length()));
            } else {
//                ch = alphanums.charAt(rnd.nextInt(alphanums.length()));
                ch = (char) rnd.nextInt(Character.MAX_VALUE + 1);
            }
            switch (ch) {
                case '\"':
                case '\\':
                    sbuf.append('\\');
            }
            sbuf.append(ch);
        }
        sbuf.append("\"");
        return sbuf.toString();
    }
}

class JSONGraphGenerator {

    JSONStringGenerator stringGen;
    JSONNumberGenerator numGen;
    private final int maxChildPerNode;
    static Random rnd = new Random(System.currentTimeMillis());

    public JSONGraphGenerator(int maxChildPerNode) {
        this.maxChildPerNode = maxChildPerNode;
        stringGen = new JSONStringGenerator();
        numGen = new JSONNumberGenerator();
    }

    private TestJsonPrimitive generatePrimitiveData() {
        int primitiveTypre = rnd.nextInt(10) + 1;
        switch (primitiveTypre) {
            case 1:
            case 2:
            case 3:
            case 4:
                return new TestJsonPrimitive(stringGen.generate());
            case 5:
            case 6:
            case 7:
            case 8:
                return new TestJsonPrimitive(numGen.generate());
            case 9:
                return new TestJsonPrimitive(Boolean.toString(rnd.nextBoolean()));
            case 10:
                return null;
        }
        return null;
    }

    public TestJsonObject generateJsonObject(int size) {
        TestJsonObject jobj = new TestJsonObject();
        if (size <= maxChildPerNode) {
            for (int i = 0; i < size; i++) {
                jobj.put(stringGen.generate(), generatePrimitiveData());
            }
        } else {
            int newSize = size;
            do {
                int childSize = rnd.nextInt(newSize);
                jobj.put(stringGen.generate(), generateJsonGraph(childSize));
                newSize = newSize - childSize;
            } while (newSize > maxChildPerNode);
            jobj.put(stringGen.generate(), generateJsonGraph(newSize));
        }
        return jobj;
    }

    public TestJsonArray generateJsonArray(int size) {
        TestJsonArray array = new TestJsonArray();
        if (size <= maxChildPerNode) {
            for (int i = 0; i < size; i++) {
                array.add(generatePrimitiveData());
            }
        } else if (size >= maxChildPerNode) {
            int newSize = size;
            do {
                int childSize = rnd.nextInt(newSize);
                array.add(generateJsonGraph(childSize));
                newSize = newSize - childSize;
            } while (newSize > maxChildPerNode);
            array.add(generateJsonGraph(newSize));
        }
        return array;
    }

    public JSONElement generateJsonGraph(int size) {
        if (rnd.nextBoolean()) {
            return generateJsonArray(size);
        } else {
            return generateJsonObject(size);
        }
    }
}