package com.ximple.eofms.jobs;

import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.sql.Types;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.TimeZone;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.quartz.JobDetail;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;

import oracle.jdbc.OracleConnection;
import oracle.jdbc.OracleResultSet;
import oracle.sql.ARRAY;
import oracle.sql.BLOB;

import com.ximple.eofms.util.BinConverter;
import com.ximple.eofms.util.ByteArrayCompressor;
import com.ximple.util.PrintfFormat;

/**
 *
 */
public class OracleConvertDgn2ShpJob extends AbstractOracleDatabaseJob
{
    static Log logger = LogFactory.getLog(OracleConvertDgn2ShpJob.class);

    private static final int FETCHSIZE = 30;
    private static final int BATCHSIZE = 25;

    public void execute(JobExecutionContext context) throws JobExecutionException
    {
        // Every job has its own job detail
        JobDetail jobDetail = context.getJobDetail();

        // The name is defined in the job definition
        String jobName = jobDetail.getName();

        // Log the time the job started
        logger.info(jobName + " fired at " + new Date());
        extractJobConfiguration(jobDetail);

        OracleConvertJobContext jobContext = prepareJobContext();
        jobContext.setConnectionInfo(_oracleHost, _oraclePort, _oracleInstance);
        jobContext.setLogin(_username, _password);

        try
        {
            exetcuteConvert(jobContext, _orgSchema, _dataPath);
        } catch (SQLException e)
        {
            throw new JobExecutionException("Database error.", e);
        }

    }

    private void exetcuteConvert(OracleConvertJobContext jobContext,
                                 String querySchema, String dataPath) throws SQLException
    {
        // verify igdsset_seed
        String srcTable = "IGSET_1";
        String destTable = OracleConvertJobContext.TABLE_PREFIX + "ELMSET_1";
        long startTime = System.currentTimeMillis();
        ArrayList srcElms = queryIgsetElement(jobContext, querySchema, srcTable);
        long currentTime = System.currentTimeMillis();
        SimpleDateFormat dateFormat = new SimpleDateFormat("HH:mm:ss:SSS");

        dateFormat.setTimeZone(TimeZone.getTimeZone("GMT"));

        long elapsed = currentTime - startTime;

        System.out.println("Old Format:" + dateFormat.format(new Date(elapsed)));
        logger.info("query source element complete.");
        startTime = System.currentTimeMillis();

        ArrayList dstElms = queryRawElement(jobContext, querySchema, destTable);

        currentTime = System.currentTimeMillis();
        dateFormat = new SimpleDateFormat("HH:mm:ss:SSS");
        dateFormat.setTimeZone(TimeZone.getTimeZone("GMT"));
        elapsed = currentTime - startTime;
        System.out.println("New Format:" + dateFormat.format(new Date(elapsed)));
        logger.info("query dest element complete.");
        // Assert.isTrue(srcElms.size() == dstElms.size(), "src[" + srcElms.size() + "] != dest[" + dstElms.size() + "]");
    }

    private ArrayList queryIgsetElement(OracleConvertJobContext jobContext,
                                        String srcschema, String srctable) throws SQLException
    {
        ArrayList result = new ArrayList();
        OracleConnection connection = jobContext.getOracleConnection();
        String fetchSrcStmtFmt = "SELECT IGDSELM FROM \"%s\".\"%s\" ORDER BY ROWID";
        PrintfFormat spf = new PrintfFormat(fetchSrcStmtFmt);
        String fetchSrcStmt = spf.sprintf(new Object[]{srcschema, srctable});
        Statement stmtSrc = connection.createStatement(ResultSet.TYPE_FORWARD_ONLY, ResultSet.CONCUR_READ_ONLY);

        stmtSrc.setFetchSize(FETCHSIZE);

        ResultSet rsSrc = stmtSrc.executeQuery(fetchSrcStmt);

        while (rsSrc.next())
        {
            byte[] raw = null;

            if (rsSrc.getMetaData().getColumnType(1) == Types.BLOB)
            {
                BLOB blob = (BLOB) rsSrc.getBlob(1);

                raw = getBytesFromBLOB(blob);
                blob.close();
            } else
            {
                raw = rsSrc.getBytes(1);
            }

            result.add(raw);
        }

        return result;
    }

    private ArrayList queryRawElement(OracleConvertJobContext jobContext,
                                      String srcschema, String srctable) throws SQLException
    {
        ArrayList result = new ArrayList();
        OracleConnection connection = jobContext.getOracleConnection();
        String fetchDestStmtFmt = "SELECT ELEMENT FROM \"%s\".\"%s\" ORDER BY ROWID";
        PrintfFormat spf = new PrintfFormat(fetchDestStmtFmt);
        String fetchDestStmt = spf.sprintf(new Object[]{srcschema, srctable});
        Statement stmtDest = connection.createStatement(ResultSet.TYPE_FORWARD_ONLY, ResultSet.CONCUR_READ_ONLY);

        stmtDest.setFetchSize(FETCHSIZE);

        ResultSet rsDest = stmtDest.executeQuery(fetchDestStmt);

        while (rsDest.next())
        {
            ARRAY rawsValue = ((OracleResultSet) rsDest).getARRAY(1);
            long[] rawData = rawsValue.getLongArray();
            byte[] comparessedValue;

            /*
            if (dataMode == TransferTask.DataMode.Normal)
            {
                comparessedValue = BinConverter.unmarshalByteArray(rawData, true);
            } else
            {
                comparessedValue = BinConverter.unmarshalCompactByteArray(rawData);
            }
            */
            comparessedValue = BinConverter.unmarshalByteArray(rawData, true);

            byte[] rawDest = ByteArrayCompressor.decompressByteArray(comparessedValue);

            result.add(rawDest);
        }

        return result;
    }

    private boolean equalRawData(byte[] rawSrc, byte[] rawDest)
    {
        if (rawSrc.length != rawDest.length)
        {
            return false;
        }

        for (int i = 0; i < rawSrc.length; i++)
        {
            if (rawSrc[i] != rawDest[i])
            {
                return false;
            }
        }

        return true;
    }
}