/**

 * Back 2 Browser Bytecode Translator

 * Copyright (C) 2012 Jaroslav Tulach <jaroslav.tulach@apidesign.org>

 *

 * This program is free software: you can redistribute it and/or modify

 * it under the terms of the GNU General Public License as published by

 * the Free Software Foundation, version 2 of the License.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program. Look for COPYING file in the top folder.

 * If not, see http://opensource.org/licenses/GPL-2.0.

 */

package org.apidesign.bck2brwsr.htmlpage;

import java.util.ArrayList;

import java.util.Collections;

import java.util.Iterator;

import java.util.List;

import java.util.ListIterator;

import org.apidesign.bck2brwsr.htmlpage.api.ComputedProperty;

import org.apidesign.bck2brwsr.htmlpage.api.OnFunction;

import org.apidesign.bck2brwsr.htmlpage.api.OnPropertyChange;

import org.apidesign.bck2brwsr.htmlpage.api.Page;

import org.apidesign.bck2brwsr.htmlpage.api.Property;

import static org.testng.Assert.*;

import org.testng.annotations.BeforeMethod;

import org.testng.annotations.Test;

/**

 *

 * @author Jaroslav Tulach <jtulach@netbeans.org>

 */

@Page(xhtml = "Empty.html", className = "Modelik", properties = {

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

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

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

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

    @Property(name = "values", type = int.class, array = true),

    @Property(name = "people", type = PersonImpl.class, array = true),

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

})

public class ModelTest {

    private Modelik model;

    private static Modelik leakedModel;

    @BeforeMethod

    public void createModel() {

        model = new Modelik();

    }

    @Test public void classGeneratedWithSetterGetter() {

        model.setValue(10);

        assertEquals(10, model.getValue(), "Value changed");

    }

    @Test public void computedMethod() {

        model.setValue(4);

        assertEquals(16, model.getPowerValue());

    }

    @Test public void arrayIsMutable() {

        assertEquals(model.getNames().size(), 0, "Is empty");

        model.getNames().add("Jarda");

        assertEquals(model.getNames().size(), 1, "One element");

    }

    @Test public void arrayChangesNotified() {

        MockKnockout my = new MockKnockout();

        MockKnockout.next = my;

        model.applyBindings();

        model.getNames().add("Hello");

        assertFalse(my.mutated.isEmpty(), "There was a change" + my.mutated);

        assertTrue(my.mutated.contains("names"), "Change in names property: " + my.mutated);

        my.mutated.clear();

        Iterator<String> it = model.getNames().iterator();

        assertEquals(it.next(), "Hello");

        it.remove();

        assertFalse(my.mutated.isEmpty(), "There was a change" + my.mutated);

        assertTrue(my.mutated.contains("names"), "Change in names property: " + my.mutated);

        my.mutated.clear();

        ListIterator<String> lit = model.getNames().listIterator();

        lit.add("Jarda");

        assertFalse(my.mutated.isEmpty(), "There was a change" + my.mutated);

        assertTrue(my.mutated.contains("names"), "Change in names property: " + my.mutated);

    }

    @Test public void autoboxedArray() {

        MockKnockout my = new MockKnockout();

        MockKnockout.next = my;

        model.applyBindings();

        model.getValues().add(10);

        assertEquals(model.getValues().get(0), Integer.valueOf(10), "Really ten");

    }

    @Test public void derivedArrayProp() {

        MockKnockout my = new MockKnockout();

        MockKnockout.next = my;

        model.applyBindings();

        model.setCount(10);

        List<String> arr = model.getRepeat();

        assertEquals(arr.size(), 10, "Ten items: " + arr);

        my.mutated.clear();

        model.setCount(5);

        arr = model.getRepeat();

        assertEquals(arr.size(), 5, "Five items: " + arr);

        assertEquals(my.mutated.size(), 2, "Two properties changed: " + my.mutated);

        assertTrue(my.mutated.contains("repeat"), "Array is in there: " + my.mutated);

        assertTrue(my.mutated.contains("count"), "Count is in there: " + my.mutated);

    }

    @Test public void derivedPropertiesAreNotified() {

        MockKnockout my = new MockKnockout();

        MockKnockout.next = my;

        model.applyBindings();

        model.setValue(33);

        // not interested in change of this property

        my.mutated.remove("changedProperty");

        assertEquals(my.mutated.size(), 2, "Two properties changed: " + my.mutated);

        assertTrue(my.mutated.contains("powerValue"), "Power value is in there: " + my.mutated);

        assertTrue(my.mutated.contains("value"), "Simple value is in there: " + my.mutated);

        my.mutated.clear();

        model.setUnrelated(44);

        // not interested in change of this property

        my.mutated.remove("changedProperty");

        assertEquals(my.mutated.size(), 1, "One property changed: " + my.mutated);

        assertTrue(my.mutated.contains("unrelated"), "Its name is unrelated");

    }

    @Test public void computedPropertyCannotWriteToModel() {

        leakedModel = model;

        try {

            String res = model.getNotAllowedWrite();

            fail("We should not be allowed to write to the model: " + res);

        } catch (IllegalStateException ex) {

            // OK, we can't read

        }

    }

    @Test public void computedPropertyCannotReadToModel() {

        leakedModel = model;

        try {

            String res = model.getNotAllowedRead();

            fail("We should not be allowed to read from the model: " + res);

        } catch (IllegalStateException ex) {

            // OK, we can't read

        }

    }

    @OnFunction 

    static void doSomething() {

    }

    @ComputedProperty

    static int powerValue(int value) {

        return value * value;

    }

    @OnPropertyChange({ "powerValue", "unrelated" })

    static void aPropertyChanged(Modelik m, String name) {

        m.setChangedProperty(name);

    }

    @OnPropertyChange({ "values" })

    static void anArrayPropertyChanged(String name, Modelik m) {

        m.setChangedProperty(name);

    }

    @Test public void changeAnything() {

        model.setCount(44);

        assertNull(model.getChangedProperty(), "No observed value change");

    }

    @Test public void changeValue() {

        model.setValue(33);

        assertEquals(model.getChangedProperty(), "powerValue", "power property changed");

    }

    @Test public void changeUnrelated() {

        model.setUnrelated(333);

        assertEquals(model.getChangedProperty(), "unrelated", "unrelated changed");

    }

    @Test public void changeInArray() {

        model.getValues().add(10);

        assertEquals(model.getChangedProperty(), "values", "Something added into the array");

    }

    @ComputedProperty

    static String notAllowedRead() {

        return "Not allowed callback: " + leakedModel.getUnrelated();

    }

    @ComputedProperty

    static String notAllowedWrite() {

        leakedModel.setUnrelated(11);

        return "Not allowed callback!";

    }

    @ComputedProperty

    static List<String> repeat(int count) {

        return Collections.nCopies(count, "Hello");

    }

    static class MockKnockout extends Knockout {

        List<String> mutated = new ArrayList<>();

        public MockKnockout() {

            super(new Object());

        }

        @Override

        public void valueHasMutated(String prop) {

            mutated.add(prop);

        }

    }

    public @Test void hasPersonPropertyAndComputedFullName() {

        List<Person> arr = model.getPeople();

        assertEquals(arr.size(), 0, "By default empty");

        Person p = null;

        if (p != null) {

            String fullNameGenerated = p.getFullName();

            assertNotNull(fullNameGenerated);

        }

    }

}