/*
 * Copyright (c) 2014, 2015, Oracle and/or its affiliates. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.
 *
 * This code 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
 * version 2 for more details (a copy is included in the LICENSE file that
 * accompanied this code).
 *
 * You should have received a copy of the GNU General Public License version
 * 2 along with this work; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 *
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
 * or visit www.oracle.com if you need additional information or have any
 * questions.
 */
package test.rowset;

import java.io.InputStream;
import java.io.Reader;
import java.io.StringBufferInputStream;
import java.io.StringReader;
import java.math.BigDecimal;
import java.sql.Array;
import java.sql.Blob;
import java.sql.Clob;
import java.sql.Date;
import java.sql.Ref;
import java.sql.SQLException;
import java.sql.Time;
import java.sql.Timestamp;
import java.sql.Types;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.LocalTime;
import java.util.Calendar;
import javax.sql.RowSet;
import javax.sql.rowset.serial.SerialArray;
import javax.sql.rowset.serial.SerialBlob;
import javax.sql.rowset.serial.SerialClob;
import javax.sql.rowset.serial.SerialRef;
import static org.testng.Assert.*;
import org.testng.annotations.DataProvider;
import org.testng.annotations.Test;
import util.StubArray;
import util.StubBaseRowSet;
import util.StubBlob;
import util.StubClob;
import util.StubRef;
import util.TestRowSetListener;

public class BaseRowSetTests extends CommonRowSetTests {

    private StubBaseRowSet brs;

    @Override
    protected RowSet newInstance() throws SQLException {
        return new StubBaseRowSet();
    }

    /*
     * Create a RowSetListener and validate that notifyCursorMoved is called
     */
    @Test(dataProvider = "rowSetType")
    public void baseRowSetTest0000(StubBaseRowSet rs) throws Exception {
        TestRowSetListener rsl = new TestRowSetListener();
        rs.addRowSetListener(rsl);
        rs.notifyCursorMoved();
        assertTrue(rsl.isNotified(TestRowSetListener.CURSOR_MOVED));
    }

    /*
     * Create a RowSetListener and validate that notifyRowChanged is called
     */
    @Test(dataProvider = "rowSetType")
    public void baseRowSetTest0001(StubBaseRowSet rs) throws Exception {
        TestRowSetListener rsl = new TestRowSetListener();
        rs.addRowSetListener(rsl);
        rs.notifyRowChanged();
        assertTrue(rsl.isNotified(TestRowSetListener.ROW_CHANGED));
    }

    /*
     * Create a RowSetListener and validate that notifyRowSetChanged is called
     */
    @Test(dataProvider = "rowSetType")
    public void baseRowSetTest0002(StubBaseRowSet rs) throws Exception {
        TestRowSetListener rsl = new TestRowSetListener();
        rs.addRowSetListener(rsl);
        rs.notifyRowSetChanged();
        assertTrue(rsl.isNotified(TestRowSetListener.ROWSET_CHANGED));
    }

    /*
     * Create multiple RowSetListeners and validate that notifyRowSetChanged
     * is called on all listeners
     */
    @Test(dataProvider = "rowSetType")
    public void baseRowSetTest0003(StubBaseRowSet rs) throws Exception {
        TestRowSetListener rsl = new TestRowSetListener();
        TestRowSetListener rsl2 = new TestRowSetListener();
        rs.addRowSetListener(rsl);
        rs.addRowSetListener(rsl2);
        rs.notifyRowSetChanged();
        assertTrue(rsl.isNotified(TestRowSetListener.ROWSET_CHANGED));
        assertTrue(rsl2.isNotified(TestRowSetListener.ROWSET_CHANGED));
    }

    /*
     * Create multiple RowSetListeners and validate that notifyRowChanged
     * is called on all listeners
     */
    @Test(dataProvider = "rowSetType")
    public void baseRowSetTest0004(StubBaseRowSet rs) throws Exception {
        TestRowSetListener rsl = new TestRowSetListener();
        TestRowSetListener rsl2 = new TestRowSetListener();
        rs.addRowSetListener(rsl);
        rs.addRowSetListener(rsl2);
        rs.notifyRowChanged();
        assertTrue(rsl.isNotified(TestRowSetListener.ROW_CHANGED));
        assertTrue(rsl2.isNotified(TestRowSetListener.ROW_CHANGED));
    }

    /*
     * Create multiple RowSetListeners and validate that notifyCursorMoved
     * is called on all listeners
     */
    @Test(dataProvider = "rowSetType")
    public void baseRowSetTest0005(StubBaseRowSet rs) throws Exception {
        TestRowSetListener rsl = new TestRowSetListener();
        TestRowSetListener rsl2 = new TestRowSetListener();
        rs.addRowSetListener(rsl);
        rs.addRowSetListener(rsl2);
        rs.notifyCursorMoved();
        assertTrue(rsl.isNotified(TestRowSetListener.CURSOR_MOVED));
        assertTrue(rsl2.isNotified(TestRowSetListener.CURSOR_MOVED));
    }

    /*
     * Create a RowSetListener and validate that notifyRowSetChanged,
     * notifyRowChanged() and notifyCursorMoved are called
     */
    @Test(dataProvider = "rowSetType")
    public void baseRowSetTest0006(StubBaseRowSet rs) throws Exception {
        TestRowSetListener rsl = new TestRowSetListener();
        rs.addRowSetListener(rsl);
        rs.notifyRowSetChanged();
        rs.notifyRowChanged();
        rs.notifyCursorMoved();
        assertTrue(rsl.isNotified(
                TestRowSetListener.CURSOR_MOVED | TestRowSetListener.ROWSET_CHANGED
                | TestRowSetListener.ROW_CHANGED));
    }


    /*
     * Create multiple RowSetListeners and validate that notifyRowSetChanged,
     * notifyRowChanged() and notifyCursorMoved are called on all listeners
     */
    @Test(dataProvider = "rowSetType")
    public void baseRowSetTest0007(StubBaseRowSet rs) throws Exception {
        TestRowSetListener rsl = new TestRowSetListener();
        TestRowSetListener rsl2 = new TestRowSetListener();
        rs.addRowSetListener(rsl);
        rs.addRowSetListener(rsl2);
        rs.notifyRowSetChanged();
        rs.notifyRowChanged();
        rs.notifyCursorMoved();
        assertTrue(rsl.isNotified(
                TestRowSetListener.CURSOR_MOVED | TestRowSetListener.ROWSET_CHANGED
                | TestRowSetListener.ROW_CHANGED));
        assertTrue(rsl2.isNotified(
                TestRowSetListener.CURSOR_MOVED | TestRowSetListener.ROWSET_CHANGED
                | TestRowSetListener.ROW_CHANGED));
    }

    /*
     * Create a RowSetListener and validate that notifyRowSetChanged is called,
     * remove the listener, invoke notifyRowSetChanged again and verify the
     * listner is not called
     */
    @Test(dataProvider = "rowSetType")
    public void baseRowSetTest0008(StubBaseRowSet rs) throws Exception {
        TestRowSetListener rsl = new TestRowSetListener();
        rs.addRowSetListener(rsl);
        rs.notifyRowSetChanged();
        assertTrue(rsl.isNotified(TestRowSetListener.ROWSET_CHANGED));
        // Clear the flag indicating the listener has been called
        rsl.resetFlag();
        rs.removeRowSetListener(rsl);
        rs.notifyRowSetChanged();
        assertFalse(rsl.isNotified(TestRowSetListener.ROWSET_CHANGED));
    }

    /*
     * Set the base parameters and validate that the value set is
     * the correct type and value
     */
    @Test(dataProvider = "testBaseParameters")
    public void baseRowSetTest0009(int pos, Object o) throws Exception {
        assertTrue(getParam(pos, o).getClass().isInstance(o));
        assertTrue(o.equals(getParam(pos, o)));
    }

    /*
     * Set the complex parameters and validate that the value set is
     * the correct type
     */
    @Test(dataProvider = "testAdvancedParameters")
    public void baseRowSetTest0010(int pos, Object o) throws Exception {
        assertTrue(getParam(pos, o).getClass().isInstance(o));
    }

    /*
     * Validate setNull specifying the supported type values
     */
    @Test(dataProvider = "jdbcTypes")
    public void baseRowSetTest0011(Integer type) throws Exception {
        brs = new StubBaseRowSet();
        brs.setNull(1, type);
        assertTrue(checkNullParam(1, type, null));
    }

    /*
     * Validate setNull specifying the supported type values and that
     * typeName is set internally
     */
    @Test(dataProvider = "jdbcTypes")
    public void baseRowSetTest0012(Integer type) throws Exception {
        brs = new StubBaseRowSet();
        brs.setNull(1, type, "SUPERHERO");
        assertTrue(checkNullParam(1, type, "SUPERHERO"));
    }

    /*
     *  Validate that setDate sets the specified Calendar internally
     */
    @Test()
    public void baseRowSetTest0013() throws Exception {
        Calendar cal = Calendar.getInstance();
        brs = new StubBaseRowSet();
        brs.setDate(1, Date.valueOf(LocalDate.now()), cal);
        assertTrue(checkCalendarParam(1, cal));
    }

    /*
     *  Validate that setTime sets the specified Calendar internally
     */
    @Test()
    public void baseRowSetTest0014() throws Exception {
        Calendar cal = Calendar.getInstance();
        brs = new StubBaseRowSet();
        brs.setTime(1, Time.valueOf(LocalTime.now()), cal);
        assertTrue(checkCalendarParam(1, cal));
    }

    /*
     *  Validate that setTimestamp sets the specified Calendar internally
     */
    @Test()
    public void baseRowSetTest0015() throws Exception {
        Calendar cal = Calendar.getInstance();
        brs = new StubBaseRowSet();
        brs.setTimestamp(1, Timestamp.valueOf(LocalDateTime.now()), cal);
        assertTrue(checkCalendarParam(1, cal));
    }

    /*
     * Validate that initParams() initializes the parameters
     */
    @Test(dataProvider = "rowSetType")
    public void baseRowSetTest0016(StubBaseRowSet rs) throws Exception {
        rs.setInt(1, 1);
        rs.initParams();
        assertTrue(rs.getParams().length == 0);
    }


    /*
     * DataProvider used to set parameters for basic types that are supported
     */
    @DataProvider(name = "testBaseParameters")
    private Object[][] testBaseParameters() throws SQLException {
        Integer aInt = 1;
        Long aLong = Long.MAX_VALUE;
        Short aShort = Short.MIN_VALUE;
        BigDecimal bd = BigDecimal.ONE;
        Double aDouble = Double.MAX_VALUE;
        Date aDate = Date.valueOf(LocalDate.now());
        Time aTime = Time.valueOf(LocalTime.now());
        Timestamp aTimeStamp = Timestamp.valueOf(LocalDateTime.now());
        Calendar cal = Calendar.getInstance();
        Boolean aBoolean = true;
        Float aFloat = 1.5f;
        Byte aByte = 1;
        brs = new StubBaseRowSet();

        brs.setInt(1, aInt);
        brs.setString(2, query);
        brs.setLong(3, aLong);
        brs.setBoolean(4, aBoolean);
        brs.setShort(5, aShort);
        brs.setDouble(6, aDouble);
        brs.setBigDecimal(7, bd);
        brs.setFloat(8, aFloat);
        brs.setByte(9, aByte);
        brs.setDate(10, aDate);
        brs.setTime(11, aTime);
        brs.setTimestamp(12, aTimeStamp);
        brs.setDate(13, aDate, cal);
        brs.setTime(14, aTime, cal);
        brs.setTimestamp(15, aTimeStamp);
        brs.setObject(16, query);
        brs.setObject(17, query, Types.CHAR);
        brs.setObject(18, query, Types.CHAR, 0);

        return new Object[][]{
            {1, aInt},
            {2, query},
            {3, aLong},
            {4, aBoolean},
            {5, aShort},
            {6, aDouble},
            {7, bd},
            {8, aFloat},
            {9, aByte},
            {10, aDate},
            {11, aTime},
            {12, aTimeStamp},
            {13, aDate},
            {14, aTime},
            {15, aTimeStamp},
            {16, query},
            {17, query},
            {18, query}

        };
    }

    /*
     * DataProvider used to set advanced parameters for types that are supported
     */
    @DataProvider(name = "testAdvancedParameters")
    private Object[][] testAdvancedParameters() throws SQLException {

        byte[] bytes = new byte[10];
        Ref aRef = new SerialRef(new StubRef("INTEGER", query));
        Array aArray = new SerialArray(new StubArray("INTEGER", new Object[1]));
        Blob aBlob = new SerialBlob(new StubBlob());
        Clob aClob = new SerialClob(new StubClob());
        Reader rdr = new StringReader(query);
        InputStream is = new StringBufferInputStream(query);;
        brs = new StubBaseRowSet();
        brs.setBytes(1, bytes);
        brs.setAsciiStream(2, is, query.length());
        brs.setRef(3, aRef);
        brs.setArray(4, aArray);
        brs.setBlob(5, aBlob);
        brs.setClob(6, aClob);
        brs.setBinaryStream(7, is, query.length());
        brs.setUnicodeStream(8, is, query.length());
        brs.setCharacterStream(9, rdr, query.length());

        return new Object[][]{
            {1, bytes},
            {2, is},
            {3, aRef},
            {4, aArray},
            {5, aBlob},
            {6, aClob},
            {7, is},
            {8, is},
            {9, rdr}
        };
    }

    /*
     *  Method that returns the specified parameter instance that was set via setXXX
     *  Note non-basic types are stored as an Object[] where the 1st element
     *  is the object instnace
     */
    @SuppressWarnings("unchecked")
    private <T> T getParam(int pos, T o) throws SQLException {
        Object[] params = brs.getParams();
        if (params[pos - 1] instanceof Object[]) {
            Object[] param = (Object[]) params[pos - 1];
            return (T) param[0];
        } else {
            return (T) params[pos - 1];
        }
    }

    /*
     * Utility method to validate parameters when the param is an Object[]
     */
    private boolean checkParam(int pos, int type, Object val) throws SQLException {
        boolean result = false;
        Object[] params = brs.getParams();
        if (params[pos - 1] instanceof Object[]) {
            Object[] param = (Object[]) params[pos - 1];

            if (param[0] == null) {
                // setNull was used
                if (param.length == 2 && (Integer) param[1] == type) {
                    result = true;
                } else {
                    if (param.length == 3 && (Integer) param[1] == type
                            && val.equals(param[2])) {
                        result = true;
                    }
                }

            } else if (param[0] instanceof java.util.Date) {
                // setDate/Time/Timestamp with a Calendar object
                if (param[1] instanceof Calendar && val.equals(param[1])) {
                    result = true;
                }
            }
        }
        return result;
    }

    /*
     * Wrapper method for validating that a null was set and the appropriate
     * type and typeName if applicable
     */
    private boolean checkNullParam(int pos, int type, String typeName) throws SQLException {
        return checkParam(pos, type, typeName);
    }

    /*
     *  Wrapper method for validating that a Calander was set
     */
    private boolean checkCalendarParam(int pos, Calendar cal) throws SQLException {
        // 2nd param is ignored when instanceof java.util.Date
        return checkParam(pos, Types.DATE, cal);
    }
}