package de.intevation.flys.importer.parsers;

import java.io.File;
import java.io.IOException;
import java.math.BigDecimal;
import java.text.NumberFormat;
import java.text.ParseException;
import java.util.ArrayList;
import java.util.List;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import org.apache.log4j.Logger;

import de.intevation.flys.importer.ImportUnit;
import de.intevation.flys.importer.ImportWaterlevel;
import de.intevation.flys.importer.ImportWaterlevelQRange;
import de.intevation.flys.importer.ImportWaterlevelValue;

import de.intevation.flys.importer.ImportRange;
import de.intevation.flys.importer.ImportWst;
import de.intevation.flys.importer.ImportWstColumn;
import de.intevation.flys.importer.ImportWstQRange;


/**
 * Parse CSV Waterlevel files.
 * As these waterlevels are probably used in fixation analysis
 * only, functionality to export them to "fixation"-wsts
 * has been added (the ImportWaterlevel*- stuff is actually
 * not needed to do so.)
 */
public class WaterlevelParser extends LineParser {

    private static final Logger log = Logger.getLogger(WaterlevelParser.class);

    private static final NumberFormat nf =
        NumberFormat.getInstance(DEFAULT_LOCALE);

    private static final Pattern META_Q_RANGE =
        Pattern.compile("Abfluss\\s\\[(.*)\\];(.*)");

    public static final Pattern META_UNIT =
        Pattern.compile("^Einheit: \\[(.*)\\].*");

    private List<ImportWaterlevel> waterlevels;

    private ImportWaterlevel current;

    private ImportWaterlevelQRange currentQ;

    private String currentDescription;


    public WaterlevelParser() {
        waterlevels = new ArrayList<ImportWaterlevel>();
    }


    /**
     * Create ImportWst objects from ImportWaterlevel
     * objects.
     */
    public List<ImportWst> exportWsts() {
        List<ImportWst> wsts = new ArrayList<ImportWst>();
        for(ImportWaterlevel waterlevel: getWaterlevels()) {
            String description = waterlevel.getDescription();
            ImportWst wst = new ImportWst();
            wsts.add(wst);
            wst.setDescription(description);
            // Fixation kind.
            wst.setKind(6);
            wst.setUnit(waterlevel.getUnit());

            // Fake WST has but 1 column.
            wst.setNumberColumns(1);
            ImportWstColumn column = wst.getColumn(0);
            column.setDescription(description);
            column.setName(description);
            column.setPosition(0);

            // Build Q Range.
            List<ImportWaterlevelQRange> qRanges = waterlevel.getQRanges();
            for(ImportWaterlevelQRange range: qRanges) {
                List<ImportWaterlevelValue> values = range.getValues();
                if (values.size() < 2) {
                    log.warn ("Not enough values to build valid QRange");
                    continue;
                }
                ImportRange iRange = new ImportRange(
                   BigDecimal.valueOf(values.get(0).getStation()),
                   BigDecimal.valueOf(values.get(values.size() -1).getStation()));
                column.addColumnQRange(
                     new ImportWstQRange(iRange, BigDecimal.valueOf(range.getQ())));
            }

            // The other W/KM values.
            for(ImportWaterlevelQRange range: qRanges) {
                for(ImportWaterlevelValue value: range.getValues()) {
                    column.addColumnValue(BigDecimal.valueOf(value.getStation()),
                                          BigDecimal.valueOf(value.getW()));
                }
            }
            // TODO Maybe set a timeinterval.
        }
        return wsts;
    }


    public List<ImportWaterlevel> getWaterlevels() {
        return waterlevels;
    }


    @Override
    public void parse(File file) throws IOException {
        currentDescription = file.getName();

        super.parse(file);
    }


    @Override
    protected void reset() {
        currentQ = null;
        current  = new ImportWaterlevel(currentDescription);
    }


    @Override
    protected void finish() {
        if (current != null) {
            if (currentQ != null) {
                current.addValue(currentQ);
            }

            waterlevels.add(current);
        }
    }

    @Override
    protected void handleLine(int lineNum, String line) {
        if (line.startsWith(START_META_CHAR)) {
            handleMetaLine(stripMetaLine(line));
            return;
        }
        else if (handleQRange(line)) {
            return;
        }
        else {
            handleDataLine(line);
            return;
        }
    }


    private void handleMetaLine(String meta) {
        Matcher m = META_UNIT.matcher(meta);

        if (m.matches()) {
            String unit = m.group(1);
            log.debug("Found unit: '" + unit + "'");

            current.setUnit(new ImportUnit(unit));
        }
    }


    private boolean handleQRange(String line) {
        Matcher m = META_Q_RANGE.matcher(line);

        if (m.matches()) {
            String unitStr  = m.group(1);
            String valueStr = m.group(2);

            if (currentQ != null) {
                if (current != null) {
                    current.addValue(currentQ);
                }
                else {
                    // this should never happen
                    log.warn("Try to add Q range without waterlevel!");
                }
            }

            try {
                log.debug("Found new Q range: Q=" + valueStr);

                currentQ = new ImportWaterlevelQRange(
                    nf.parse(valueStr).doubleValue());

                return true;
            }
            catch (ParseException pe) {
                log.warn("Error while parsing Q range: '" + line + "'");
            }
        }

        return false;
    }


    private void handleDataLine(String line) {
        String[] cols = line.split(SEPERATOR_CHAR);

        if (cols == null || cols.length < 2) {
            log.warn("skip invalid waterlevel line: '" + line + "'");
            return;
        }

        try {
            Double station = nf.parse(cols[0]).doubleValue();
            Double value   = nf.parse(cols[1]).doubleValue();

            currentQ.addValue(new ImportWaterlevelValue(station, value));
        }
        catch (ParseException pe) {
            log.warn("Error while parsing number values: '" + line + "'");
        }
    }
}
// vim:set ts=4 sw=4 si et sta sts=4 fenc=utf8 :