/*******************************************************************************
 * Copyright (c) 2012 Oracle. All rights reserved.
 * This program and the accompanying materials are made available under the
 * terms of the Eclipse Public License v1.0 and Eclipse Distribution License v. 1.0
 * which accompanies this distribution.
 * The Eclipse Public License is available at http://www.eclipse.org/legal/epl-v10.html
 * and the Eclipse Distribution License is available at
 * http://www.eclipse.org/org/documents/edl-v10.php.
 *
 * Contributors:
 *     Mike Norman - Feb 1 2012, created anchored types (%TYPE, %ROWTYPE) tests
 ******************************************************************************/
package org.eclipse.persistence.tools.oracleddl.test.ddlparser;

//javase imports
import java.io.IOException;
import java.io.InputStream;
import java.io.StringReader;

//JUnit4 imports
import org.junit.BeforeClass;
import org.junit.Test;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;

//Oracle DDL parser imports
import org.eclipse.persistence.tools.oracleddl.metadata.DatabaseType;
import org.eclipse.persistence.tools.oracleddl.metadata.FieldType;
import org.eclipse.persistence.tools.oracleddl.metadata.PLSQLCursorType;
import org.eclipse.persistence.tools.oracleddl.metadata.PLSQLPackageType;
import org.eclipse.persistence.tools.oracleddl.metadata.PLSQLSubType;
import org.eclipse.persistence.tools.oracleddl.metadata.PLSQLType;
import org.eclipse.persistence.tools.oracleddl.parser.DDLParser;
import org.eclipse.persistence.tools.oracleddl.parser.ParseException;
import org.eclipse.persistence.tools.oracleddl.util.DatabaseTypesRepository;

public class AnchoredTypesTestSuite {

    static final String CREATE_PACKAGE_PREFIX = "CREATE PACKAGE ";
    //JUnit fixture(s)
    static DDLParser parser = null;

    @BeforeClass
    static public void setUp() {
        parser = new DDLParser(new InputStream() {
            public int read() throws IOException {
                return 0;
            }
        });
        parser.setTypesRepository(new DatabaseTypesRepository());
    }

    static final String ANCHORED_TYPES_TEST1_PACKAGE = "ANCHORED_TYPES_TEST1";
    static final String ANCHORED_TYPES_TABLE = "ANCHORED_TYPES_TABLE";
    static final String ANCHORED_TYPES_TABLE_FIELD = "NAME";
    static final String ANCHORED_TYPE1_NAME = "W" + ANCHORED_TYPES_TABLE_FIELD;
    static final String ANCHORED_TYPE1 =
        ANCHORED_TYPES_TABLE + "." + ANCHORED_TYPES_TABLE_FIELD + "%TYPE";
    static final String CREATE_ANCHORED_TYPES_TEST1_PACKAGE =
        CREATE_PACKAGE_PREFIX + ANCHORED_TYPES_TEST1_PACKAGE + " AS" +
            "\nSUBTYPE " + ANCHORED_TYPE1_NAME + " IS " + ANCHORED_TYPE1 + ";" +
        "\nEND " + ANCHORED_TYPES_TEST1_PACKAGE + ";";
    @Test
    public void anchoredTypesTest1() {
        parser.ReInit(new StringReader(CREATE_ANCHORED_TYPES_TEST1_PACKAGE));
        boolean worked = true;
        @SuppressWarnings("unused") PLSQLPackageType packageType = null;
        try {
            packageType = parser.parsePLSQLPackage();
        }
        catch (ParseException pe) {
            worked = false;
        }
        assertTrue(ANCHORED_TYPES_TEST1_PACKAGE + " package should parse", worked);
        assertEquals(ANCHORED_TYPES_TEST1_PACKAGE + " package wrong name",
            packageType.getPackageName(), ANCHORED_TYPES_TEST1_PACKAGE);
        assertNotNull(ANCHORED_TYPES_TEST1_PACKAGE + " package should have types",
            packageType.getTypes());
        assertEquals(ANCHORED_TYPES_TEST1_PACKAGE + " package should have exactly 1 type", 1,
            packageType.getTypes().size());
        PLSQLType type = packageType.getTypes().get(0);
        assertEquals("type has wrong name", ANCHORED_TYPE1_NAME, type.getTypeName());
        assertTrue(ANCHORED_TYPE1_NAME+ " is not SUBTYPE", type.isPLSQLSubType());
        PLSQLSubType subType = (PLSQLSubType)type;
        assertFalse(ANCHORED_TYPE1_NAME+ " is not supposed to have a NOT NULL constraint",
            subType.isNotNull());
        assertFalse(ANCHORED_TYPE1_NAME+ " is not supposed to have a RANGE constraint",
            subType.hasRange());
        DatabaseType enclosedType = subType.getEnclosedType();
        assertFalse(ANCHORED_TYPE1_NAME+ "'s enclosedType is not supposed to be resolved",
            enclosedType.isResolved());
        assertEquals(ANCHORED_TYPE1_NAME + "'s enclosedType is incorrect", ANCHORED_TYPE1,
            enclosedType.getTypeName());
    }

    static final String ANCHORED_TYPES_TEST2_PACKAGE = "ANCHORED_TYPES_TEST2";
    static final String ANCHORED_TYPE2_NAME = "WREC";
    static final String ANCHORED_TYPE2 = ANCHORED_TYPES_TABLE + "%ROWTYPE";
    static final String CREATE_ANCHORED_TYPES_TEST2_PACKAGE =
        CREATE_PACKAGE_PREFIX + ANCHORED_TYPES_TEST2_PACKAGE + " AS" +
            "\nSUBTYPE " + ANCHORED_TYPE1_NAME + " IS " + ANCHORED_TYPE1 + ";" +
            "\nSUBTYPE " + ANCHORED_TYPE2_NAME + " IS " + ANCHORED_TYPE2 + ";" +
            "\nTYPE " + ANCHORED_TYPE2_NAME + "_CURSOR IS REF CURSOR RETURN " + ANCHORED_TYPE2_NAME + ";" +
        "\nEND " + ANCHORED_TYPES_TEST2_PACKAGE + ";";
    @Test
    public void anchoredTypesTest2() {
        parser.ReInit(new StringReader(CREATE_ANCHORED_TYPES_TEST2_PACKAGE));
        boolean worked = true;
        @SuppressWarnings("unused") PLSQLPackageType packageType = null;
        try {
            packageType = parser.parsePLSQLPackage();
        }
        catch (ParseException pe) {
            worked = false;
        }
        assertTrue(ANCHORED_TYPES_TEST2_PACKAGE + " package should parse", worked);
        assertEquals(ANCHORED_TYPES_TEST2_PACKAGE + " package wrong name",
            packageType.getPackageName(), ANCHORED_TYPES_TEST2_PACKAGE);
        assertNotNull(ANCHORED_TYPES_TEST2_PACKAGE + " package should have types",
            packageType.getTypes());
        assertEquals(ANCHORED_TYPES_TEST2_PACKAGE + " package should have exactly 2 types", 2,
            packageType.getTypes().size());
        PLSQLType type1 = packageType.getTypes().get(0);
        assertEquals("type has wrong name", ANCHORED_TYPE1_NAME, type1.getTypeName());
        assertTrue(ANCHORED_TYPE1_NAME + " is not SUBTYPE", type1.isPLSQLSubType());
        PLSQLSubType subType = (PLSQLSubType)type1;
        assertFalse(ANCHORED_TYPE1_NAME+ " is not supposed to have a NOT NULL constraint",
            subType.isNotNull());
        assertFalse(ANCHORED_TYPE1_NAME+ " is not supposed to have a RANGE constraint",
            subType.hasRange());
        DatabaseType enclosedType = subType.getEnclosedType();
        assertFalse(ANCHORED_TYPE1_NAME+ "'s enclosedType is not supposed to be resolved",
            enclosedType.isResolved());
        assertEquals(ANCHORED_TYPE1_NAME + "'s enclosedType is incorrect", ANCHORED_TYPE1,
            enclosedType.getTypeName());
        PLSQLType type2 = packageType.getTypes().get(1);
        assertEquals("type has wrong name", ANCHORED_TYPE2_NAME, type2.getTypeName());
        assertTrue(ANCHORED_TYPE2_NAME + " is not SUBTYPE", type2.isPLSQLSubType());
        PLSQLSubType subType2 = (PLSQLSubType)type2;
        assertFalse(ANCHORED_TYPE2_NAME+ " is not supposed to have a NOT NULL constraint",
            subType2.isNotNull());
        assertFalse(ANCHORED_TYPE2_NAME+ " is not supposed to have a RANGE constraint",
            subType2.hasRange());
        DatabaseType enclosedType2 = subType2.getEnclosedType();
        assertFalse(ANCHORED_TYPE2_NAME+ "'s enclosedType is not supposed to be resolved",
            enclosedType2.isResolved());
        assertEquals(ANCHORED_TYPE2_NAME + "'s enclosedType is incorrect", ANCHORED_TYPE2,
            enclosedType2.getTypeName());
        PLSQLCursorType cursor = packageType.getCursors().get(0);
        assertEquals("cursor has wrong name", ANCHORED_TYPE2_NAME + "_CURSOR",
            cursor.getCursorName());
        assertFalse(ANCHORED_TYPE2_NAME + "_CURSOR is not supposed to be weakly typed",
            cursor.isWeaklyTyped());
        assertEquals(ANCHORED_TYPE2_NAME + "_CURSOR returns wrong type", ANCHORED_TYPE2_NAME,
            cursor.getEnclosedType().getTypeName());
        assertFalse(ANCHORED_TYPE2_NAME + "_CURSOR's return type is not supposed to be resolved",
            cursor.getEnclosedType().isResolved());
    }

    /*
    CREATE OR REPLACE PACKAGE ANCHORED_TYPES_TEST3 AS
        WREC WTRC_TABLE%ROWTYPE;
        SUBTYPE WNAME IS WREC.NAME%TYPE;
        TYPE WREC_CURSOR IS REF CURSOR RETURN WREC%TYPE;
        END ANCHORED_TYPES_TEST3;
     */
    static final String ANCHORED_TYPES_TEST3_PACKAGE = "ANCHORED_TYPES_TEST3";
    static final String VAR_NAME = "WREC";
    static final String CREATE_ANCHORED_TYPES_TEST3_PACKAGE =
        CREATE_PACKAGE_PREFIX + ANCHORED_TYPES_TEST3_PACKAGE + " AS" +
            "\n" + VAR_NAME + " " + ANCHORED_TYPE2 + ";" +
            "\nSUBTYPE " + ANCHORED_TYPE1_NAME + " IS " + VAR_NAME + "." +  ANCHORED_TYPES_TABLE_FIELD  + "%TYPE;" +
            "\nTYPE " + ANCHORED_TYPE2_NAME + "_CURSOR IS REF CURSOR RETURN " + ANCHORED_TYPE2_NAME + "%TYPE;" +
        "\nEND " + ANCHORED_TYPES_TEST3_PACKAGE + ";";
    @Test
    public void anchoredTypesTest3() {
        parser.ReInit(new StringReader(CREATE_ANCHORED_TYPES_TEST3_PACKAGE));
        boolean worked = true;
        @SuppressWarnings("unused") PLSQLPackageType packageType = null;
        try {
            packageType = parser.parsePLSQLPackage();
        }
        catch (ParseException pe) {
            worked = false;
        }
        assertTrue(ANCHORED_TYPES_TEST3_PACKAGE + " package should parse", worked);
        assertEquals(ANCHORED_TYPES_TEST3_PACKAGE + " package wrong name",
            packageType.getPackageName(), ANCHORED_TYPES_TEST3_PACKAGE);
        assertNotNull(ANCHORED_TYPES_TEST3_PACKAGE + " package should have variables",
            packageType.getLocalVariables());
        assertEquals(ANCHORED_TYPES_TEST3_PACKAGE + " package should have exactly 1 variables", 1,
            packageType.getLocalVariables().size());
        FieldType var1 = packageType.getLocalVariables().get(0);
        assertEquals(VAR_NAME + " wrong name", VAR_NAME, var1.getFieldName());
        assertEquals(VAR_NAME + " wrong datatype", ANCHORED_TYPE2, var1.getEnclosedType().getTypeName());
        assertEquals(ANCHORED_TYPES_TEST3_PACKAGE + " package should have exactly 1 type", 1,
            packageType.getTypes().size());
        PLSQLType type1 = packageType.getTypes().get(0);
        assertEquals("type has wrong name", ANCHORED_TYPE1_NAME, type1.getTypeName());
        assertTrue(ANCHORED_TYPE1_NAME + " is not SUBTYPE", type1.isPLSQLSubType());
        PLSQLSubType subType = (PLSQLSubType)type1;
        assertFalse(ANCHORED_TYPE1_NAME+ " is not supposed to have a NOT NULL constraint",
            subType.isNotNull());
        assertFalse(ANCHORED_TYPE1_NAME+ " is not supposed to have a RANGE constraint",
            subType.hasRange());
        DatabaseType enclosedType = subType.getEnclosedType();
        assertFalse(ANCHORED_TYPE1_NAME+ "'s enclosedType is not supposed to be resolved",
            enclosedType.isResolved());
        assertEquals(ANCHORED_TYPE1_NAME + "'s enclosedType is incorrect",
            VAR_NAME + "." +  ANCHORED_TYPES_TABLE_FIELD  + "%TYPE", enclosedType.getTypeName());
        PLSQLCursorType cursor = packageType.getCursors().get(0);
        assertEquals("cursor has wrong name", ANCHORED_TYPE2_NAME + "_CURSOR",
            cursor.getCursorName());
        assertFalse(ANCHORED_TYPE2_NAME + "_CURSOR is not supposed to be weakly typed",
            cursor.isWeaklyTyped());
        assertEquals(ANCHORED_TYPE2_NAME + "_CURSOR returns wrong type", ANCHORED_TYPE2_NAME + "%TYPE",
            cursor.getEnclosedType().getTypeName());
        assertFalse(ANCHORED_TYPE2_NAME + "_CURSOR's return type is not supposed to be resolved",
            cursor.getEnclosedType().isResolved());
    }
}