/*

Derby - Class org.apache.derbyTesting.functionTests.tests.upgradeTests.OldVersions

Licensed to the Apache Software Foundation (ASF) under one or more
contributor license agreements.  See the NOTICE file distributed with
this work for additional information regarding copyright ownership.
The ASF licenses this file to You under the Apache License, Version 2.0
(the "License"); you may not use this file except in compliance with
the License.  You may obtain a copy of the License at

   http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.

*/
package org.apache.derbyTesting.functionTests.tests.upgradeTests;

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Arrays;

import org.apache.derbyTesting.junit.BaseTestCase;
import org.apache.derbyTesting.junit.JDBC;

/**
 * <p>
 * Old versions visible to the upgrade machinery.
 * </p>
 */
public class OldVersions
{
    private static int[][] VERSIONS =
    {
        {10, 0, 2, 1}, // 10.0.2.1 (incubator release)
        {10, 1, 1, 0}, // 10.1.1.0 (Aug 3, 2005 / SVN 208786)
        {10, 1, 2, 1}, // 10.1.2.1 (Nov 18, 2005 / SVN 330608)
        {10, 1, 3, 1}, // 10.1.3.1 (Jun 30, 2006 / SVN 417277)
        {10, 2, 1, 6}, // 10.2.1.6 (Oct 02, 2006 / SVN 452058)
        {10, 2, 2, 0}, // 10.2.2.0 (Dec 12, 2006 / SVN 485682)
        {10, 3, 1, 4}, // 10.3.1.4 (Aug 1, 2007 / SVN 561794)
        {10, 3, 3, 0}, // 10.3.3.0 (May 12, 2008 / SVN 652961)
        {10, 4, 1, 3}, // 10.4.1.3 (April 24, 2008 / SVN 648739)
        {10, 4, 2, 0}, // 10.4.2.0 (September 05, 2008 / SVN 693552)
        {10, 5, 1, 1}, // 10.5.1.1 (April 28, 2009 / SVN 764942)
        {10, 5, 3, 0}, // 10.5.3.0 (August 21, 2009 / SVN 802917)
        {10, 6, 1, 0}, // 10.6.1.0 (May 18, 2010/ SVN 938214)
        {10, 6, 2, 1}, // 10.6.2.1 (Oct 6, 2010/ SVN 999685)
        {10, 7, 1, 1}, // 10.7.1.1 (December 14, 2010/ SVN 1040133)
        {10, 8, 1, 2}, // 10.8.1.2 (April 29, 2011/ SVN 1095077)
        {10, 8, 2, 2}, // 10.8.2.2 (October 24, 2011/ SVN 1181258)
        {10, 8, 3, 0}, // 10.8.3.0 (November 16, 2012/ SVN 1405108)
        {10, 9, 1, 0}, // 10.9.1.0 (June 25, 2012/ SVN 1344872)
        {10, 10, 1, 1}, // 10.10.1.1 (April 15, 2013/ SVN 1458268)
        {10, 10, 2, 0}, // 10.10.2.0 (April 15, 2014/ SVN 1582446)
        {10, 11, 1, 1}, // 10.11.1.1 (August 26, 2014 / SVN 1616546)
        {10, 12, 1, 1}, // 10.12.1.1 (October 11, 2015 / SVN 1704137)
    };

    //Constant for special upgrade testing with both upgrade and create 
    // set. We just test this with one version in the interest of time
    // DERBY-4913
    public static int[] VERSION_10_3_3_0=  new int[] {10,3,3,0};
    /**
     * <p>
     * Get an array of versions supported by this platform.
     * </p>
     */
    public static int[][] getSupportedVersions()
    {
        int[][] old = null;
        
        if ( UpgradeRun.oldVersionsPath != null )
        {
            old = getVersions(UpgradeRun.oldVersionsPath);
        }
        
        if ( old == null ) { old = VERSIONS; }

        show( old );

        return getSupportedVersions( old );
    }

    /**
     * <p>
     * Squeeze the supported versions out of any array of candidate versions.
     * </p>
     */
    private static int[][] getSupportedVersions( int[][] old )
    {
        ArrayList<int[]> list = new ArrayList<int[]>();
        int count = old.length;
        
        for (int i = 0; i < count; i++) {
            // JSR169 support was only added with 10.1, so don't
            // run 10.0 to later upgrade if that's what our jvm is supporting.
            if ((JDBC.vmSupportsJSR169() && 
                (old[i][0]==10) && (old[i][1]==0))) {
                traceit("Skipping 10.0 on JSR169");
                continue;
            }
            // Derby 10.3.1.4 does not boot on the phoneME advanced platform,
            // (see DERBY-3176) so don't run upgrade tests in this combination.
            if ( BaseTestCase.isCVM()
                  && old[i][0]==10 && old[i][1]==3 
                  && old[i][2]==1 && old[i][3]==4 ) {
                traceit("Skipping 10.3.1.4 on CVM");
                continue;
            }

            // DERBY-6100: Data sources from Derby versions prior to 10.10
            // cannot be loaded on platforms that don't support JNDI.
            if (JDBC.vmSupportsJDBC3() && !JDBC.vmSupportsJNDI() &&
                    UpgradeRun.lessThan(old[i], new int[] {10, 10, 0, 0})) {
                traceit("Skipping " + Arrays.toString(old[i]) +
                        " because JNDI is not available");
                continue;
            }

            // otherwise, it's a supported version
            list.add( old[ i ] );
        }

        return list.toArray(new int[list.size()][]);
    }
    
    private static int[][] getVersions(String oldVersionsPath)
    {
        BufferedReader br = null;
        try{
            FileReader fr = new FileReader(oldVersionsPath);
            br = new BufferedReader(fr);
        }
        catch (java.io.FileNotFoundException fNFE)
        {
            alarm("File '" + oldVersionsPath 
                  + "' was not found, using default old versions for upgrade tests.");
            return null;
        }
        traceit("Run upgrade tests on versions defined in '" + oldVersionsPath + "'");
        return getVersions(br, oldVersionsPath);
    }
    
    private static int[][] getVersions(BufferedReader br, String oldVersionsPath) 
    {
        int[][] versionArray = new int[256][4];
        
        int versions = 0;
        
        String line = null;
        int lineNum = 0;
        try {
            while ((line = br.readLine()) != null) {
                lineNum++;
                /* Ignore lines not matching the regexp: "^[\\d]+\\.[\\d]+\\.[\\d]+\\.[\\d]"
                 * NB. java.util.regex.Matcher and java.util.regex.Pattern can not be
                 * used on small devices(JSR219).
                 */
                try {
                    String[] parts = split4(line,'.');
                    // String[] parts = line.split("\\."); // JSR219 does NOT have String.split()!
                    if (parts.length >= 3) {
                        
                        int[] vstr = new int[4];
                        for (int i = 0; i < 4; i++) // Using first 4 values
                        {
                            String str = parts[i];
                            if (i == 3) { // Clean... remove trailing non-digits
                                str = clean(str,"0123456789");
                            }
                            vstr[i] = Integer.parseInt(str);
                        }
                        versionArray[versions++] = vstr;
                    } else {
                        alarm("Illegal version format on: " + line);
                    }
                } catch (NumberFormatException nfe) {
                    alarm("NumberFormatException on line " + lineNum + ": " + line + ": " + " " + nfe.getMessage());
                } catch (ArrayIndexOutOfBoundsException aie) {
                    alarm("ArrayIndexOutOfBoundsException on line " + lineNum + ": " + line + ": " + " " + aie.getMessage());
                }
            }
        } catch (IOException ioe) {
            alarm("Error reading from file: " + oldVersionsPath + ioe.getMessage());
        }
        
        int[][] finalVERSIONS = new int[versions][4];
        for (int v = 0; v < versions; v++) {
            finalVERSIONS[v] = versionArray[v];
        }
        return  finalVERSIONS;
        
    }
    
    private static void show( int[][] old ) {
        traceit("Upgrade test versions listed:");
        for (int o = 0; o < old.length; o++) {
            String ver = "";
            for (int i = 0; i < old[o].length; i++) {
                if (i == 0) {
                    ver = "" + old[o][i];
                } else {
                    ver = ver + "." + old[o][i];
                }
            }
            traceit(ver);
        }
    }
    private static String[] split4(String l, char c)
    {
        String[] res = new String[4];
        try{
            int p0 = l.indexOf(c);
            if (p0<0) return res;
            
            res[0] = l.substring(0, p0);
            int p1 = l.indexOf(c,p0+1);
            if (p1<0) return res;
            
            res[1] = l.substring(p0+1, p1);
            int p2 = l.indexOf(c,p1+1); 
            if (p2<0) return res;
            
            res[2] = l.substring(p1+1, p2);
            int p3 = l.indexOf(c,p2+1); 
            if (p3<0) p3=l.length();
            
            res[3] = l.substring(p2+1, p3);
            
        } catch(StringIndexOutOfBoundsException sie){
            println("split4 StringIndexOutOfBoundsException: "+sie.getMessage());
            sie.printStackTrace();
        }
        return res;
    }
    private static String clean(String l, String allowed)
    {
        for (int i=0;i<l.length();i++)
        {
            if (!matches(l.charAt(i),allowed))
            {
                return l.substring(0,i);
            }
        }
        return l;
    }
    private static boolean matches(char c, String allowed)
    {
        for (int j=0;j<allowed.length();j++)
        {
            if (allowed.charAt(j) == c) return true;
        }
        return false;
    }

    private static void println( String text ) { BaseTestCase.println( text ); }
    private static void traceit( String text ) { BaseTestCase.traceit( text ); }
    private static void alarm( String text ) { BaseTestCase.alarm( text ); }
    
}