package gudusoft.gsqlparser.util.csv;

import java.io.*;
import java.nio.charset.Charset;

public class CsvWriter {

    private Writer outWriter;
    private char sepChar = ',';
    private char recDelimiterChar = '\n';
    private char textQuoteChar = '"';
    private boolean enableTextQuote = true;
    private boolean forceTextQuote = false;
    private char commentSymbol = '#';
    private int escMode = ESCAPE_MODE_DOUBLED;
    private boolean isFirstColumn = true;
    private boolean isClosed = false;
    private boolean customRecDelimiter = false;

    public static final int ESCAPE_MODE_DOUBLED = 1;
    public static final int ESCAPE_MODE_BACKSLASH = 2;

    public CsvWriter(String fileName, char delimiter, Charset charset) {
        if (fileName == null || charset == null) {
            throw new IllegalArgumentException("Parameters cannot be null");
        }
        try {
            this.outWriter = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(fileName), charset));
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
        this.sepChar = delimiter;
    }

    public CsvWriter(String fileName) {
        this(fileName, ',', Charset.forName("ISO-8859-1"));
    }

    public CsvWriter(Writer writer, char delimiter) {
        if (writer == null) throw new IllegalArgumentException("Writer cannot be null");
        this.outWriter = writer;
        this.sepChar = delimiter;
    }

    public CsvWriter(OutputStream stream, char delimiter, Charset charset) {
        this(new OutputStreamWriter(stream, charset), delimiter);
    }

    public char getDelimiter() { return sepChar; }
    public void setDelimiter(char delimiter) { this.sepChar = delimiter; }

    public char getRecordDelimiter() { return recDelimiterChar; }
    public void setRecordDelimiter(char recDelimiter) {
        this.recDelimiterChar = recDelimiter;
        this.customRecDelimiter = true;
    }

    public char getTextQualifier() { return textQuoteChar; }
    public void setTextQualifier(char textQualifier) { this.textQuoteChar = textQualifier; }

    public boolean getUseTextQualifier() { return enableTextQuote; }
    public void setUseTextQualifier(boolean useTextQualifier) { this.enableTextQuote = useTextQualifier; }

    public int getEscapeMode() { return escMode; }
    public void setEscapeMode(int escapeMode) { this.escMode = escapeMode; }

    public char getComment() { return commentSymbol; }
    public void setComment(char comment) { this.commentSymbol = comment; }

    public boolean getForceQualifier() { return forceTextQuote; }
    public void setForceQualifier(boolean forceQualifier) { this.forceTextQuote = forceQualifier; }

    public void write(String content, boolean preserveSpaces) throws IOException {
        checkClosed();
        if (content == null) content = "";

        if (!isFirstColumn) outWriter.write(sepChar);

        boolean quote = forceTextQuote;
        String value = preserveSpaces ? content : content.trim();

        if (enableTextQuote && !quote) {
            if (value.indexOf(sepChar) >= 0 || value.indexOf(textQuoteChar) >= 0 ||
                    (!customRecDelimiter && (value.indexOf('\n') >= 0 || value.indexOf('\r') >= 0)) ||
                    (customRecDelimiter && value.indexOf(recDelimiterChar) >= 0) ||
                    (isFirstColumn && value.length() > 0 && value.charAt(0) == commentSymbol) ||
                    (isFirstColumn && value.isEmpty())
            ) {
                quote = true;
            }
        }

        if (quote) {
            outWriter.write(textQuoteChar);
            value = escapeValue(value);
        } else if (escMode == ESCAPE_MODE_BACKSLASH) {
            value = escapeWithBackslash(value);
        }

        outWriter.write(value);

        if (quote) outWriter.write(textQuoteChar);

        isFirstColumn = false;
    }

    public void write(String content) throws IOException {
        write(content, false);
    }

    public void writeComment(String commentText) throws IOException {
        checkClosed();
        outWriter.write(commentSymbol);
        outWriter.write(commentText);
        outWriter.write(customRecDelimiter ? recDelimiterChar : '\n');
        isFirstColumn = true;
    }

    public void writeRecord(String[] values, boolean preserveSpaces) throws IOException {
        if (values != null && values.length > 0) {
            for (String val : values) {
                write(val, preserveSpaces);
            }
            endRecord();
        }
    }

    public void writeRecord(String[] values) throws IOException {
        writeRecord(values, false);
    }

    public void endRecord() throws IOException {
        checkClosed();
        outWriter.write(customRecDelimiter ? recDelimiterChar : '\n');
        isFirstColumn = true;
    }

    public void flush() throws IOException { outWriter.flush(); }

    public void close() {
        if (!isClosed) {
            try {
                outWriter.close();
            } catch (Exception ignored) {}
            isClosed = true;
        }
    }

    private void checkClosed() throws IOException {
        if (isClosed) throw new IOException("CsvWriter already closed.");
    }

    private String escapeValue(String val) {
        if (escMode == ESCAPE_MODE_DOUBLED) {
            return val.replace("" + textQuoteChar, "" + textQuoteChar + textQuoteChar);
        }
        return val;
    }

    private String escapeWithBackslash(String val) {
        val = val.replace("\\", "\\\\")
                .replace("" + textQuoteChar, "\\" + textQuoteChar)
                .replace("" + sepChar, "\\" + sepChar);
        if (!customRecDelimiter) {
            val = val.replace("\n", "\\n").replace("\r", "\\r");
        } else {
            val = val.replace("" + recDelimiterChar, "\\" + recDelimiterChar);
        }
        if (isFirstColumn && val.length() > 0 && val.charAt(0) == commentSymbol) {
            val = "\\" + val;
        }
        return val;
    }
}