/* Copyright (C) 2011, 2012, 2013 by Bundesanstalt für Gewässerkunde
 * Software engineering by Intevation GmbH
 *
 * 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.parsers;

import java.math.BigDecimal;

import java.text.ParseException;

import org.apache.log4j.Logger;

import org.dive4elements.river.importer.ImportBedHeight;
import org.dive4elements.river.importer.ImportBedHeightSingle;
import org.dive4elements.river.importer.ImportBedHeightSingleValue;


public class BedHeightSingleParser extends BedHeightParser {

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



    @Override
    protected ImportBedHeight newImportBedHeight(String description) {
        return new ImportBedHeightSingle(description);
    }



    /**
     * Create ImportBedHeightSingleValue from a line of csv file, add
     * it to the ImportBedHeight.
     */
    @Override
    protected void handleDataLine(ImportBedHeight obj, String line) {
        String[] values = line.split(SEPERATOR_CHAR);

        if (values == null || (values.length != 1 && values.length < 6)) {
            //log.warn("BSP: Error while parsing data line: '" + line + "'");
            return;
        }

        Double km;

        try {
            km = new Double(nf.parse(values[0]).doubleValue());
	    
            Double key = Double.valueOf(km);

            if (kmExists.contains(key)) {
                log.warn("duplicate station '" + km + "': -> ignored");
                return;
            }

            kmExists.add(key);
	}

        catch (ParseException e) {
            // We expect a lot of ";;;;;;" lines.
            //log.warn("BSP: Error while parsing km of data row.", e);
            return;
        }

        // Handle gaps like "10,0;;;;;".
        if (values.length == 1) {
            // Do not import line without useful data
            return;
        }

        // Because we cannot enforce consistency of values with complete data
        // via null constraints in the database (as there are "gap" values),
        // do this checks manually.
	//        if (values[3].length() == 0 || values[4].length() == 0
	//  || values[5].length() == 0) {
            //log.warn("BSP: Error while parsing data row (manual null constraint violated).");
	//  return;
        //}

	Double height = null;
	if (values[1].length() > 0) {
	    try {
		height = new Double(nf.parse(values[1]).doubleValue());
	    }
	    catch (ParseException e) {
		log.warn("BSP: unparseable height " + values[1]);
	    }
	}

	Double uncertainty = null;
	if (values[2].length() > 0) {
	    try {
		uncertainty = new Double(nf.parse(values[2]).doubleValue());
	    }
	    catch (ParseException e) {
		log.warn("BSP: unparseable uncertainty value " + values[2]);
	    }
	}

	Double dataGap = null;
	if (values[3].length() > 0) {
	    try {
		dataGap = new Double(nf.parse(values[3]).doubleValue());
	    }
	    catch (ParseException e) {
		log.warn("BSP: unparseable data gap " + values[3]);
	    }
	}

	Double soundingWidth = null;
	if (values[4].length() > 0) {
	    try {
		soundingWidth = new Double(nf.parse(values[4]).doubleValue());
	    }
	    catch (ParseException e) {
		log.warn("BSP: unparseable sounding width " + values[4]);
	    }
	}

	Double width = null;
	if (values[5].length() > 0) {
	    try {
		width = new Double(nf.parse(values[5]).doubleValue());
	    }
	    catch (ParseException e) {
		log.warn("BSP: unparseable width " + values[5]);
	    }
	}

	//        try {
	ImportBedHeightSingleValue value = new ImportBedHeightSingleValue(
	    (ImportBedHeightSingle) obj,
	    km,
	    height,//new Double(nf.parse(values[1]).doubleValue()),
	    uncertainty,
	    dataGap,
	    soundingWidth,
	    //                parseBigDecimal(values[4], line),
	    width
	);

	obj.addValue(value);
        // }
//         catch (ParseException e) {
//             log.warn("BSP: unparseable value in data row.", e);
        //}
    }

//     private BigDecimal parseBigDecimal(String value, String line) {
//         BigDecimal result = null;
//         try {
//             Double dValue = Double.valueOf(value.replace(",", "."));
//             result = new BigDecimal(dValue.doubleValue());
//         }
//         catch (NumberFormatException nfe) {
//             log.warn(
//                 "Could not parse " +
//                 value +
//                 " in bed heigt single row: "
//                 + line);
//         }
//        return result;
//    }
}
// vim:set ts=4 sw=4 si et sta sts=4 fenc=utf8 :