/* Copyright (C) 2017 by Bundesanstalt für Gewässerkunde
 * Software engineering by
 *  Björnsen Beratende Ingenieure GmbH
 *  Dr. Schumacher Ingenieurbüro für Wasser und Umwelt
 *
 * This file is Free Software under the GNU AGPL (>=v3)
 * and comes with ABSOLUTELY NO WARRANTY! Check out the
 * documentation coming with Dive4Elements River for details.
 */

package org.dive4elements.river.importer.uinfo.parsers;

import java.io.File;
import java.util.ArrayList;
import java.util.EnumMap;
import java.util.List;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import org.apache.log4j.Logger;
import org.dive4elements.river.importer.Config;
import org.dive4elements.river.importer.ImportRiver;
import org.dive4elements.river.importer.common.AbstractParser;
import org.dive4elements.river.importer.common.ParsingState;
import org.dive4elements.river.importer.uinfo.importitem.SalixKmLineImport;
import org.dive4elements.river.importer.uinfo.importitem.SalixSeriesImport;
import org.dive4elements.river.model.uinfo.Salix;
import org.dive4elements.river.model.uinfo.SalixValue;

/**
 * Reads and parses a salix file
 *
 * @author Matthias Schäfer
 *
 */
public class SalixParser extends AbstractParser<Salix, SalixValue, SalixKmLineImport, SalixSeriesImport> {

    /***** FIELDS *****/

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

    private static final String IMPORT_FILENAME = "Salix-Linie.csv";

    private static final Pattern META_EVALUATOR = Pattern.compile("^#\\sAuswerter:\\s*([^;]*).*", Pattern.CASE_INSENSITIVE);

    private enum ColTitlePattern {
        FACTOR("Salix.Fa.tor\\s*\\[(.*)\\].*"), //
        MWMNW("\\(MW-MNW\\).*\\[(.*)\\].*");

        private final Pattern pattern;

        ColTitlePattern(final String regexp) {
            this.pattern = Pattern.compile(regexp, Pattern.CASE_INSENSITIVE);
        }

        public Pattern getPattern() {
            return this.pattern;
        }
    }

    private final EnumMap<ColTitlePattern, Integer> cols = new EnumMap<>(ColTitlePattern.class);


    /***** CONSTRUCTORS *****/

    public SalixParser(final File importPath, final File rootRelativePath, final ImportRiver river) {
        super(importPath, rootRelativePath, river);
    }


    /***** METHODS *****/

    @Override
    protected Logger getLog() {
        return log;
    }

    /**
     * Whether this import type shall be skipped
     */
    public static boolean shallSkip() {
        return Config.INSTANCE.skipUInfoSalix();
    }

    /**
     * Creates a list of parsers for all salix import files in a directory
     */
    public static List<SalixParser> createParsers(final File importDir, final File relativeDir, final ImportRiver river) {
        final List<SalixParser> parsers = new ArrayList<>();
        final File importFile = new File(importDir, IMPORT_FILENAME);
        if (importFile.exists())
            parsers.add(new SalixParser(importFile, new File(relativeDir, IMPORT_FILENAME), river));
        return parsers;
    }

    @Override
    protected SalixSeriesImport createSeriesImport(final String filename) {
        return new SalixSeriesImport(filename);
    }

    @Override
    protected boolean handleMetaOther() {
        if (handleMetaEvaluator())
            return true;
        else
            return false;
    }

    private boolean handleMetaEvaluator() {
        final Matcher m = META_EVALUATOR.matcher(this.currentLine);
        if (m.matches()) {
            this.metaPatternsMatched.add(META_EVALUATOR);
            this.seriesHeader.setEvaluationBy(parseMetaInfo(m.group(1).trim()));
            return true;
        }
        return false;
    }

    @Override
    protected boolean handleMetaColumnTitles() {
        if (!super.handleMetaColumnTitles())
            return false;
        for (final ColTitlePattern col : ColTitlePattern.values())
            this.cols.put(col, -1);
        for (int i = 1; i <= this.columnTitles.size() - 1; i++) {
            for (final ColTitlePattern col : ColTitlePattern.values()) {
                if (col.getPattern().matcher(this.columnTitles.get(i)).matches()) {
                    this.cols.put(col, i);
                    break;
                }
            }
        }
        if ((this.cols.get(ColTitlePattern.FACTOR) < 0) || (this.cols.get(ColTitlePattern.MWMNW) < 0)) {
            logError("Column of the salix factor and/or mnw-mw-diff could not be identified");
            this.headerParsingState = ParsingState.STOP;
            return false;
        }
        return true;
    }

    @Override
    protected SalixKmLineImport createKmLineImport(final Double km, final String[] values) {
        if (Double.isNaN(parseDoubleWithNull(values[this.cols.get(ColTitlePattern.FACTOR)]).doubleValue())) {
            logError("Salix factor not found in line " + this.in.getLineNumber());
            return null;
        }
        if (Double.isNaN(parseDoubleWithNull(values[this.cols.get(ColTitlePattern.MWMNW)]).doubleValue())) {
            logError("MNW-MW-diff not found in line " + this.in.getLineNumber());
            return null;
        }
        return new SalixKmLineImport(km, parseDoubleWithNull(values[this.cols.get(ColTitlePattern.FACTOR)]).doubleValue(),
                parseDoubleWithNull(values[this.cols.get(ColTitlePattern.MWMNW)]).doubleValue());
    }
}