package com.philmcrew.utility;

import java.io.*;
import java.sql.PreparedStatement;
import java.sql.SQLException;
import java.util.Iterator;

/**
 * Created by IntelliJ IDEA.
 * User: Mitchell
 * Date: Feb 24, 2005
 * Time: 4:21:34 PM
 * To change this template use Options | File Templates.
 */
public class FixedToDelim {
    Iterator getIterator(InputStream is, String pos) {
        return new FixedToDelimIterator(is, pos);
    }

    Iterator getDelimIterator(InputStream is, String delimiter) {
        return new DelimIterator(is, delimiter);
    }

    public int deliminate(InputStream is, PreparedStatement pst, String pos) throws SQLException {
        int lineCount = -1;

        Iterator iterator = getIterator(is, pos);
        String[] tokens;
        String token;
        for (lineCount = 0; iterator.hasNext(); lineCount++) {
            tokens = (String[]) iterator.next();
            pst.clearParameters();
            for (int jj = 0; jj < tokens.length; jj++) {
                token = tokens[jj];
                pst.setString(jj + 1, token);
            }

            pst.executeUpdate();
        }

        return lineCount;
    }

    public int fixedDeliminate(InputStream is, PreparedStatement pst, String delimiter, int numParams) throws SQLException {
        int lineCount = -1;

        Iterator iterator = getDelimIterator(is, delimiter);
        String[] tokens;
        String token;
        for (lineCount = 0; iterator.hasNext(); lineCount++) {
            tokens = (String[]) iterator.next();

            pst.clearParameters();
            for (int jj = 0; jj < tokens.length && jj < numParams; jj++) {
                token = tokens[jj];
                pst.setString(jj + 1, token);
            }
            if (tokens.length == 0)
                continue;

            if (tokens[0] != null && tokens[0].charAt(0) == ';') {
                // commented out with a ;
                continue;
            }

            for (int kk = tokens.length; kk < numParams; kk++) {
                pst.setString(kk + 1, "");
            }

            try {
                pst.executeUpdate();
            }
            catch (SQLException e) {
                System.out.println("problem with line=" + lineCount + ";t=" + tokens + "; e=" + e);
                if (lineCount != 0) {
                    throw e;
                }
            }

        }

        return lineCount;
    }

    public int deliminate(InputStream is, OutputStream os, String pos, String delim) throws IOException {
        int lineCount = -1;

        byte[] bdelim = delim.getBytes();
        Iterator iterator = getIterator(is, pos);
        String[] tokens;
        String token;

        for (lineCount = 0; iterator.hasNext(); lineCount++) {
            if (lineCount > 0) {
                os.write('\n');
            }

            tokens = (String[]) iterator.next();

            for (int jj = 0; jj < tokens.length; jj++) {
                token = tokens[jj];
                if (null != token) {
                    os.write(token.getBytes());
                }

                os.write(bdelim);
            }
        }
        os.write('\n');

        return lineCount;
    }

    protected class FixedToDelimIterator implements Iterator {
        int[] posArray = null;
        String[] tokenArray = null;

        InputStream inputStream = null;
        InputStreamReader inputStreamReader = null;
        BufferedReader bufferedReader;

        FixedToDelimIterator(InputStream is, String pos) {
            String[] posStrings = pos.split(",");
            posArray = new int[posStrings.length];
            for (int ii = 0; ii < posStrings.length; ii++) {
                posArray[ii] = Integer.parseInt(posStrings[ii]);
            }

            tokenArray = new String[posArray.length + 1];
            inputStream = is;
        }

        public void initialize() {
            if (null != inputStream && null == inputStreamReader) {
                inputStreamReader = new InputStreamReader(inputStream);
            }

            if (null != inputStreamReader && null == bufferedReader) {
                bufferedReader = new BufferedReader(inputStreamReader);
            }
        }

        public boolean hasNext() {
            boolean ret = false;
            initialize();

            try {
                ret = (null != bufferedReader && bufferedReader.ready());
            }
            catch (IOException e) {
                // must not have next then
            }

            return ret;
        }

        public Object next() {
            String line = null;

            try {
                line = bufferedReader.readLine();
            }
            catch (IOException e) {
                return null;
            }

            for (int ii = 0; ii < tokenArray.length; ii++) {
                tokenArray[ii] = null;
            }

            if (posArray[0] < line.length()) {
                // get first token if available
                tokenArray[0] = line.substring(0, posArray[0]);
            }

            for (int ii = 1; ii < posArray.length; ii++) {
                if (posArray[ii] < line.length()) {
                    // get next token if available
                    tokenArray[ii] = line.substring(posArray[ii - 1], posArray[ii]);
                }
            }

            if (posArray[posArray.length - 1] < line.length()) {
                // get last token
                tokenArray[posArray.length] = line.substring(posArray[posArray.length - 1], line.length());
            }

            return tokenArray;
        }

        public void remove() {
        }
    }

    protected class DelimIterator implements Iterator {
        String delimiter = null;

        InputStream inputStream = null;
        InputStreamReader inputStreamReader = null;
        BufferedReader bufferedReader;

        DelimIterator(InputStream is, String delimiter) {
            this.delimiter = delimiter;
            inputStream = is;
        }

        public void initialize() {
            if (null != inputStream && null == inputStreamReader) {
                inputStreamReader = new InputStreamReader(inputStream);
            }

            if (null != inputStreamReader && null == bufferedReader) {
                bufferedReader = new BufferedReader(inputStreamReader);
            }
        }

        public boolean hasNext() {
            boolean ret = false;
            initialize();

            try {
                ret = (null != bufferedReader && bufferedReader.ready());
            }
            catch (IOException e) {
                // must not have next then
            }

            return ret;
        }

        public Object next() {
            String line = null;

            try {
                line = bufferedReader.readLine();
            }
            catch (IOException e) {
                return null;
            }

            return line.split(delimiter);
        }

        public void remove() {
        }
    }

}