/*
 * Copyright (c) 2010 by Intevation GmbH
 *
 * This program is free software under the LGPL (>=v2.1)
 * Read the file LGPL.txt coming with the software for details
 * or visit http://www.gnu.org/licenses/ if it does not exist.
 */

package de.intevation.gnv.action;

import de.intevation.gnv.action.sessionmodel.DiagrammOptions;
import de.intevation.gnv.action.sessionmodel.SessionModel;
import de.intevation.gnv.action.sessionmodel.SessionModelFactory;

import de.intevation.gnv.artifactdatabase.objects.ArtifactDescription;
import de.intevation.gnv.artifactdatabase.objects.OutputMode;
import de.intevation.gnv.artifactdatabase.objects.OutputParameter;

import java.text.NumberFormat;
import java.text.ParseException;

import java.util.Collection;
import java.util.Iterator;
import java.util.Locale;
import java.util.Map;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.apache.log4j.Logger;

import org.apache.struts.action.ActionForm;
import org.apache.struts.action.ActionForward;
import org.apache.struts.action.ActionMapping;

/**
 * This controller is called to change options used in charts and histograms
 * (e.g. width, height, etc).
 *
 * @author <a href="mailto:tim.englich@intevation.de">Tim Englich</a>
 */
public class ChangeOptionsAction extends DescribeUIAction {
    /**
     * the logger, used to log exceptions and additonaly information
     */
    private static Logger log = Logger.getLogger(ChangeOptionsAction.class);

    /**
     * Constructor
     */
    public ChangeOptionsAction() {
        super();
    }

    @Override
    public ActionForward execute(ActionMapping mapping, ActionForm form,
                                 HttpServletRequest request,
                                 HttpServletResponse response) throws Exception {
        if (isSessionExhausted(request)) {
            return sessionExhaustedForward(mapping, form, request, response);
        }

        log.debug("NextArtifactStepAction.execute");
        try {
            SessionModel sm = SessionModelFactory.getInstance()
                    .getSessionModel(request);

            ArtifactDescription ad = sm.getArtifactDescription();

            String target         = request.getParameter("target");
            OutputMode outputMode = sm.getOutputMode(target);
            Locale locale         = sm.getCurrentLocale();

            if (outputMode != null) {
                Collection<OutputParameter> op = outputMode
                        .getOutputParameters();
                if (op != null) {
                    Iterator<OutputParameter> it = op.iterator();
                    DiagrammOptions oldOptions      = sm.getDiagrammOptions();
                    DiagrammOptions diagrammOptions = new DiagrammOptions();
                    while (it.hasNext()) {
                        OutputParameter parameter = it.next();
                        String name  = parameter.getName();
                        Object old   = oldOptions != null
                            ? oldOptions.getValue(name)
                            : parameter.getValue();
                        String value = request.getParameter(name);
                        String type  = parameter.getType();

                        if (log.isDebugEnabled()) {
                            log.debug("Change chart options now...");
                            log.debug("Parameter name: " + name);
                            log.debug("Parameter type: " + type);
                            log.debug("Parameter value: " + value);
                        }

                        if (type.equalsIgnoreCase("boolean")){
                            if (value == null){
                                value = "false";
                            }
                            else {
                                value = "true";
                            }

                            diagrammOptions.setValue(name,value);
                        }
                        else if (type.equalsIgnoreCase("integer")) {
                            if (validInteger(request.getLocale(), value)) {
                                diagrammOptions.setValue(name, value);
                            }
                            else {
                                log.warn("Text is not a valid integer: "+value);
                                diagrammOptions.setValue(name, old);

                                request.setAttribute(
                                    CommunicationKeys.REQUEST_EXCEPTION_MESSAGE,
                                    "input.not.a.integer"
                                );

                                request.setAttribute(
                                    CommunicationKeys.REQUEST_EXCEPTION_VALUE,
                                    value
                                );
                            }
                        }
                        else if (type.equalsIgnoreCase("double")) {
                            try {
                                double val    = parseDoubleValue(locale, value);
                                String valStr = Double.toString(val);
                                log.debug("Change diagram options ["
                                    + name +"] to " + val);
                                diagrammOptions.setValue(name, val);
                            }
                            catch (ParseException pe) {
                                log.warn("Text is not a valid double: "+value);
                                diagrammOptions.setValue(name, old);

                                request.setAttribute(
                                    CommunicationKeys.REQUEST_EXCEPTION_MESSAGE,
                                    "input.not.a.double"
                                );

                                request.setAttribute(
                                    CommunicationKeys.REQUEST_EXCEPTION_VALUE,
                                    value
                                );
                            }
                        }
                    }
                    sm.setDiagrammOptions(diagrammOptions);

                    // XXX Little workarround. We should implement a 'choice' type,
                    // if we need further choice elements! (iw)
                    String bintype = request.getParameter("bintype");
                    if (bintype != null) {
                        diagrammOptions.setValue("bintype", bintype);
                        sm.setDiagrammOptions(diagrammOptions);
                        request.setAttribute("bintype", bintype);
                    }
                }
            }

            Map tmpOuts = ad.getOutputModes();
            if (tmpOuts == null || tmpOuts.isEmpty()) {
                request.setAttribute("furthertargets", true);
            }
            else {
                request.setAttribute(target, true);
            }

            return super.execute(mapping, form, request, response);
        } catch (Exception e) {
            log.error(e, e);
            request.setAttribute(
                    CommunicationKeys.REQUEST_EXCEPTION_MESSAGE_ID, e
                            .getMessage());
            return super.getExceptionForward(mapping);
        }
    }

    protected boolean validInteger(Locale locale, String value) {
        try {
            if (value.split("\\.").length > 1 || value.split("\\,").length > 1){
                return false;
            }

            NumberFormat format = NumberFormat.getIntegerInstance(locale);
            format.setParseIntegerOnly(true);
            Number       number = format.parse(value);

            if (number.longValue() < 0)
                return false;

            return (number instanceof Integer) || (number instanceof Long);
        }
        catch (ParseException pe) {
            return false;
        }
    }

    protected double parseDoubleValue(Locale locale, String value)
    throws ParseException
    {
        log.error("LOCALE FOR DOUBLE PARSING: " + locale.toString());
        NumberFormat format = NumberFormat.getNumberInstance(locale);
        Number       number = format.parse(value);

        return number.doubleValue();
    }
}
// vim:set ts=4 sw=4 si et sta sts=4 fenc=utf-8 :