/**

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.

 *

 * Copyright 2013-2014 Oracle and/or its affiliates. All rights reserved.

 *

 * Oracle and Java are registered trademarks of Oracle and/or its affiliates.

 * Other names may be trademarks of their respective owners.

 *

 * The contents of this file are subject to the terms of either the GNU

 * General Public License Version 2 only ("GPL") or the Common

 * Development and Distribution License("CDDL") (collectively, the

 * "License"). You may not use this file except in compliance with the

 * License. You can obtain a copy of the License at

 * http://www.netbeans.org/cddl-gplv2.html

 * or nbbuild/licenses/CDDL-GPL-2-CP. See the License for the

 * specific language governing permissions and limitations under the

 * License.  When distributing the software, include this License Header

 * Notice in each file and include the License file at

 * nbbuild/licenses/CDDL-GPL-2-CP.  Oracle designates this

 * particular file as subject to the "Classpath" exception as provided

 * by Oracle in the GPL Version 2 section of the License file that

 * accompanied this code. If applicable, add the following below the

 * License Header, with the fields enclosed by brackets [] replaced by

 * your own identifying information:

 * "Portions Copyrighted [year] [name of copyright owner]"

 *

 * Contributor(s):

 *

 * The Original Software is NetBeans. The Initial Developer of the Original

 * Software is Oracle. Portions Copyright 2013-2014 Oracle. All Rights Reserved.

 *

 * If you wish your version of this file to be governed by only the CDDL

 * or only the GPL Version 2, indicate your decision by adding

 * "[Contributor] elects to include this software in this distribution

 * under the [CDDL or GPL Version 2] license." If you do not indicate a

 * single choice of license, a recipient has the option to distribute

 * your version of this file under either the CDDL, the GPL Version 2 or

 * to extend the choice of license to its licensees as provided above.

 * However, if you add GPL Version 2 code and therefore, elected the GPL

 * Version 2 license, then the option applies only if the new code is

 * made subject to such option by the copyright holder.

 */

package net.java.html.json.tests;

import java.io.ByteArrayInputStream;

import java.io.ByteArrayOutputStream;

import java.io.PrintStream;

import net.java.html.BrwsrCtx;

import net.java.html.json.Model;

import net.java.html.json.ModelOperation;

import net.java.html.json.Models;

import net.java.html.json.OnReceive;

import net.java.html.json.Property;

import org.apidesign.html.json.tck.KOTest;

/** Need to verify that models produce reasonable JSON objects.

 *

 * @author Jaroslav Tulach

 */

@Model(className = "JSONik", properties = {

    @Property(name = "fetched", type = Person.class),

    @Property(name = "fetchedCount", type = int.class),

    @Property(name = "fetchedResponse", type = String.class),

    @Property(name = "fetchedSex", type = Sex.class, array = true)

})

public final class JSONTest {

    private JSONik js;

    private Integer orig;

    private String url;

    @ModelOperation static void assignFetched(JSONik m, Person p) {

        m.setFetched(p);

    }

    private BrwsrCtx ctx;

    @KOTest public void toJSONInABrowser() throws Throwable {

        Person p = Models.bind(new Person(), newContext());

        p.setSex(Sex.MALE);

        p.setFirstName("Jarda");

        p.setLastName("Tulach");

        Object json;

        try {

            json = parseJSON(p.toString());

        } catch (Throwable ex) {

            throw new IllegalStateException("Can't parse " + p).initCause(ex);

        }

        Person p2 = Models.fromRaw(newContext(), Person.class, json);

        assert p2.getFirstName().equals(p.getFirstName()) : 

            "Should be the same: " + p.getFirstName() + " != " + p2.getFirstName();

    }

    @KOTest public void toJSONWithEscapeCharactersInABrowser() throws Throwable {

        Person p = Models.bind(new Person(), newContext());

        p.setSex(Sex.MALE);

        p.setFirstName("/*\n * Copyright (c) 2013");

        final String txt = p.toString();

        Object json;

        try {

            json = parseJSON(txt);

        } catch (Throwable ex) {

            throw new IllegalStateException("Can't parse " + txt).initCause(ex);

        }

        Person p2 = Models.fromRaw(newContext(), Person.class, json);

        assert p2.getFirstName().equals(p.getFirstName()) : 

            "Should be the same: " + p.getFirstName() + " != " + p2.getFirstName();

    }

    @KOTest public void toJSONWithDoubleSlashInABrowser() throws Throwable {

        Person p = Models.bind(new Person(), newContext());

        p.setSex(Sex.MALE);

        p.setFirstName("/*\\n * Copyright (c) 2013");

        final String txt = p.toString();

        Object json;

        try {

            json = parseJSON(txt);

        } catch (Throwable ex) {

            throw new IllegalStateException("Can't parse " + txt).initCause(ex);

        }

        Person p2 = Models.fromRaw(newContext(), Person.class, json);

        assert p2.getFirstName().equals(p.getFirstName()) : 

            "Should be the same: " + p.getFirstName() + " != " + p2.getFirstName();

    }

    @KOTest public void toJSONWithApostrophInABrowser() throws Throwable {

        Person p = Models.bind(new Person(), newContext());

        p.setSex(Sex.MALE);

        p.setFirstName("Jimmy 'Jim' Rambo");

        final String txt = p.toString();

        Object json;

        try {

            json = parseJSON(txt);

        } catch (Throwable ex) {

            throw new IllegalStateException("Can't parse " + txt).initCause(ex);

        }

        Person p2 = Models.fromRaw(newContext(), Person.class, json);

        assert p2.getFirstName().equals(p.getFirstName()) : 

            "Should be the same: " + p.getFirstName() + " != " + p2.getFirstName();

    }

    private static BrwsrCtx onCallback;

    @OnReceive(url="{url}")

    static void fetch(JSONik model, Person p) {

        model.setFetched(p);

        onCallback = BrwsrCtx.findDefault(model.getClass());

    }

    @OnReceive(url="{url}", onError = "setMessage")

    static void fetchArray(JSONik model, Person[] p) {

        model.setFetchedCount(p.length);

        model.setFetched(p[0]);

        onCallback = BrwsrCtx.findDefault(model.getClass());

    }

    static void setMessage(JSONik m, Exception t) {

        assert t != null;

        m.setFetchedResponse("Exception");

    }

    @OnReceive(url="{url}")

    static void fetchPeople(JSONik model, People p) {

        final int size = p.getInfo().size();

        if (size > 0) {

            model.setFetched(p.getInfo().get(0));

        }

        model.setFetchedCount(size);

    }

    @OnReceive(url="{url}")

    static void fetchPeopleAge(JSONik model, People p) {

        int sum = 0;

        for (int a : p.getAge()) {

            sum += a;

        }

        model.setFetchedCount(sum);

    }

    @KOTest public void loadAndParseJSON() throws InterruptedException {

        if (js == null) {

            url = Utils.prepareURL(

                JSONTest.class, "{'firstName': 'Sitar', 'sex': 'MALE'}",

                "application/json"

            );

            js = Models.bind(new JSONik(), ctx = newContext());

            js.applyBindings();

            js.setFetched(null);

            js.fetch(url);

        }

        Person p = js.getFetched();

        if (p == null) {

            throw new InterruptedException();

        }

        assert "Sitar".equals(p.getFirstName()) : "Expecting Sitar: " + p.getFirstName();

        assert Sex.MALE.equals(p.getSex()) : "Expecting MALE: " + p.getSex();

        assert ctx == onCallback;

    }

    @OnReceive(url="{url}?callme={me}", jsonp = "me")

    static void fetchViaJSONP(JSONik model, Person p) {

        model.setFetched(p);

    }

    @KOTest public void loadAndParseJSONP() throws InterruptedException, Exception {

        if (js == null) {

            url = Utils.prepareURL(

                JSONTest.class, "$0({'firstName': 'Mitar', 'sex': 'MALE'})", 

                "application/javascript",

                "callme"

            );

            orig = scriptElements();

            assert orig > 0 : "There should be some scripts on the page";

            js = Models.bind(new JSONik(), newContext());

            js.applyBindings();

            js.setFetched(null);

            js.fetchViaJSONP(url);

        }

        Person p = js.getFetched();

        if (p == null) {

            throw new InterruptedException();

        }

        assert "Mitar".equals(p.getFirstName()) : "Unexpected: " + p.getFirstName();

        assert Sex.MALE.equals(p.getSex()) : "Expecting MALE: " + p.getSex();

        int now = scriptElements();

        assert orig == now : "The set of elements is unchanged. Delta: " + (now - orig);

    }

    @OnReceive(url="{url}", method = "PUT", data = Person.class)

    static void putPerson(JSONik model, String reply) {

        model.setFetchedCount(1);

        model.setFetchedResponse(reply);

    }

    @KOTest public void putPeopleUsesRightMethod() throws InterruptedException, Exception {

        if (js == null) {

            url = Utils.prepareURL(

                JSONTest.class, "$0\n$1", 

                "text/plain",

                "http.method", "http.requestBody"

            );

            orig = scriptElements();

            assert orig > 0 : "There should be some scripts on the page";

            js = Models.bind(new JSONik(), newContext());

            js.applyBindings();

            Person p = Models.bind(new Person(), BrwsrCtx.EMPTY);

            p.setFirstName("Jarda");

            js.putPerson(url, p);

        }

        int cnt = js.getFetchedCount();

        if (cnt == 0) {

            throw new InterruptedException();

        }

        String res = js.getFetchedResponse();

        int line = res.indexOf('\n');

        String msg;

        if (line >= 0) {

            msg = res.substring(line + 1);

            res = res.substring(0, line);

        } else {

            msg = res;

        }

        assert "PUT".equals(res) : "Server was queried with PUT method: " + js.getFetchedResponse();

        assert msg.contains("Jarda") : "Data transferred to the server: " + msg;

    }

    private static int scriptElements() throws Exception {

        return ((Number)Utils.executeScript(

            JSONTest.class, 

            "return window.document.getElementsByTagName('script').length;")).intValue();

    }

    private static Object parseJSON(String s) throws Exception {

        return Utils.executeScript(

            JSONTest.class, 

            "return window.JSON.parse(arguments[0]);", s);

    }

    @KOTest public void loadAndParseJSONSentToArray() throws InterruptedException {

        if (js == null) {

            url = Utils.prepareURL(

                JSONTest.class, "{'firstName': 'Sitar', 'sex': 'MALE'}", 

                "application/json"

            );

            js = Models.bind(new JSONik(), newContext());

            js.applyBindings();

            js.setFetched(null);

            js.fetchArray(url);

        }

        Person p = js.getFetched();

        if (p == null) {

            throw new InterruptedException();

        }

        assert "Sitar".equals(p.getFirstName()) : "Expecting Sitar: " + p.getFirstName();

        assert Sex.MALE.equals(p.getSex()) : "Expecting MALE: " + p.getSex();

    }

    @KOTest public void loadAndParseJSONArraySingle() throws InterruptedException {

        if (js == null) {

            url = Utils.prepareURL(

                JSONTest.class, "[{'firstName': 'Gitar', 'sex': 'FEMALE'}]", 

                "application/json"

            );

            js = Models.bind(new JSONik(), newContext());

            js.applyBindings();

            js.setFetched(null);

            js.fetch(url);

        }

        Person p = js.getFetched();

        if (p == null) {

            throw new InterruptedException();

        }

        assert "Gitar".equals(p.getFirstName()) : "Expecting Gitar: " + p.getFirstName();

        assert Sex.FEMALE.equals(p.getSex()) : "Expecting FEMALE: " + p.getSex();

    }

    @KOTest public void loadAndParseArrayInPeople() throws InterruptedException {

        if (js == null) {

            url = Utils.prepareURL(

                JSONTest.class, "{'info':[{'firstName': 'Gitar', 'sex': 'FEMALE'}]}", 

                "application/json"

            );

            js = Models.bind(new JSONik(), newContext());

            js.applyBindings();

            js.fetchPeople(url);

        }

        if (0 == js.getFetchedCount()) {

            throw new InterruptedException();

        }

        assert js.getFetchedCount() == 1 : "One person loaded: " + js.getFetchedCount();

        Person p = js.getFetched();

        assert p != null : "We should get our person back: " + p;

        assert "Gitar".equals(p.getFirstName()) : "Expecting Gitar: " + p.getFirstName();

        assert Sex.FEMALE.equals(p.getSex()) : "Expecting FEMALE: " + p.getSex();

    }

    @KOTest public void loadAndParseArrayOfIntegers() throws InterruptedException {

        if (js == null) {

            url = Utils.prepareURL(

                JSONTest.class, "{'age':[1, 2, 3]}", 

                "application/json"

            );

            js = Models.bind(new JSONik(), newContext());

            js.applyBindings();

            js.fetchPeopleAge(url);

        }

        if (0 == js.getFetchedCount()) {

            throw new InterruptedException();

        }

        assert js.getFetchedCount() == 6 : "1 + 2 + 3 is " + js.getFetchedCount();

    }

    @OnReceive(url="{url}")

    static void fetchPeopleSex(JSONik model, People p) {

        model.setFetchedCount(1);

        model.getFetchedSex().addAll(p.getSex());

    }

    @KOTest public void loadAndParseArrayOfEnums() throws InterruptedException {

        if (js == null) {

            url = Utils.prepareURL(

                JSONTest.class, "{'sex':['FEMALE', 'MALE', 'MALE']}", 

                "application/json"

            );

            js = Models.bind(new JSONik(), newContext());

            js.applyBindings();

            js.fetchPeopleSex(url);

        }

        if (0 == js.getFetchedCount()) {

            throw new InterruptedException();

        }

        assert js.getFetchedCount() == 1 : "Loaded";

        assert js.getFetchedSex().size() == 3 : "Three values " + js.getFetchedSex();

        assert js.getFetchedSex().get(0) == Sex.FEMALE : "Female first " + js.getFetchedSex();

        assert js.getFetchedSex().get(1) == Sex.MALE : "male 2nd " + js.getFetchedSex();

        assert js.getFetchedSex().get(2) == Sex.MALE : "male 3rd " + js.getFetchedSex();

    }

    @KOTest public void loadAndParseJSONArray() throws InterruptedException {

        if (js == null) {

            url = Utils.prepareURL(

                JSONTest.class, "[{'firstName': 'Gitar', 'sex': 'FEMALE'},"

                + "{'firstName': 'Peter', 'sex': 'MALE'}"

                + "]", 

                "application/json"

            );

            js = Models.bind(new JSONik(), newContext());

            js.applyBindings();

            js.setFetched(null);

            js.fetchArray(url);

        }

        Person p = js.getFetched();

        if (p == null) {

            throw new InterruptedException();

        }

        assert js.getFetchedCount() == 2 : "We got two values: " + js.getFetchedCount();

        assert "Gitar".equals(p.getFirstName()) : "Expecting Gitar: " + p.getFirstName();

        assert Sex.FEMALE.equals(p.getSex()) : "Expecting FEMALE: " + p.getSex();

    }

    @KOTest public void loadError() throws InterruptedException {

        if (js == null) {

            js = Models.bind(new JSONik(), newContext());

            js.applyBindings();

            js.setFetched(null);

            js.fetchArray("http://127.0.0.1:54253/does/not/exist.txt");

        }

        if (js.getFetchedResponse() == null) {

            throw new InterruptedException();

        }

        assert "Exception".equals(js.getFetchedResponse()) : js.getFetchedResponse();

    }

    @Model(className = "NameAndValue", properties = {

        @Property(name = "name", type = String.class),

        @Property(name = "value", type = long.class),

        @Property(name = "small", type = byte.class)

    })

    static class NandV {

    }

    @KOTest public void parseNullNumber() throws Exception {

        String txt = "{ \"name\":\"M\" }";

        ByteArrayInputStream is = new ByteArrayInputStream(txt.getBytes("UTF-8"));

        NameAndValue v = Models.parse(newContext(), NameAndValue.class, is);

        assert "M".equals(v.getName()) : "Name is 'M': " + v.getName();

        assert 0 == v.getValue() : "Value is empty: " + v.getValue();

        assert 0 == v.getSmall() : "Small value is empty: " + v.getSmall();

    }

    @KOTest public void deserializeWrongEnum() throws Exception {

        PrintStream prev = null;

        ByteArrayOutputStream err = new ByteArrayOutputStream();

        try {

            prev = System.err;

            System.setErr(new PrintStream(err));

        } catch (SecurityException e) {

            err = null;

            prev = null;

        } catch (LinkageError e) {

            err = null;

            prev = null;

        }

        String str = "{ \"sex\" : \"unknown\" }";

        ByteArrayInputStream is = new ByteArrayInputStream(str.getBytes("UTF-8"));

        Person p = Models.parse(newContext(), Person.class, is);

        assert p.getSex() == null : "Wrong sex means null, but was: " + p.getSex();

        if (err != null) {

            assert err.toString().contains("unknown") && err.toString().contains("Sex"): "Expecting error: " + err.toString();

        }

        if (prev != null) {

            try {

                System.setErr(prev);

            } catch (LinkageError e) {

                // ignore

            }

        }

    }

    private static BrwsrCtx newContext() {

        return Utils.newContext(JSONTest.class);

    }

}