ServletParameterHelper.java

package server.restful.common.parameter;

import com.beust.jcommander.Parameter;
import com.beust.jcommander.Parameters;
import com.beust.jcommander.ParametersDelegate;
import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.JsonFilter;
import com.fasterxml.jackson.core.JsonGenerator;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.JsonMappingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.SerializerProvider;
import com.fasterxml.jackson.databind.introspect.ClassIntrospector.MixInResolver;
import com.fasterxml.jackson.databind.ser.PropertyWriter;
import com.fasterxml.jackson.databind.ser.impl.SimpleBeanPropertyFilter;
import com.fasterxml.jackson.databind.ser.impl.SimpleFilterProvider;
import libsidutils.IOUtils;
import org.hibernate.type.descriptor.java.LocaleJavaType.LocaleComparator;
import server.restful.servlets.ConvertServlet;

import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.nio.ByteBuffer;
import java.nio.charset.CharacterCodingException;
import java.nio.charset.CharsetDecoder;
import java.nio.charset.CodingErrorAction;
import java.util.AbstractMap.SimpleEntry;
import java.util.*;
import java.util.Map.Entry;
import java.util.ResourceBundle.Control;
import java.util.logging.Level;
import java.util.logging.Logger;

import static com.fasterxml.jackson.annotation.JsonAutoDetect.Visibility.ANY;
import static java.lang.String.format;
import static java.nio.charset.StandardCharsets.US_ASCII;
import static java.util.stream.Collectors.toList;
import static libsidplay.common.ChipModel.MOS6581;
import static libsidplay.common.ChipModel.MOS8580;
import static libsidplay.common.Emulation.*;
import static server.restful.common.parameter.ConvertStubGenerator.createConvertMessagesStub;
import static server.restful.common.parameter.ConvertStubGenerator.createConvertOptionsStub;
import static sidplay.ini.IniDefaults.DEFAULTS;

/**
 * Provides parameter default values and localization of ConvertServlet as well as parameter checks to spot development
 * errors.
 *
 * @author ken
 *
 */
public class ServletParameterHelper {

    private static final Logger LOG = Logger.getLogger(ServletParameterHelper.class.getName());
    private static final ResourceBundle ERRORS = ResourceBundle
            .getBundle("server.restful.common.parameter.ServletParameterHelper");

    public static final List<Locale> SUPPORTED_LOCALES = Collections
            .unmodifiableList(Arrays.asList(Locale.ROOT /* ENGLISH */, Locale.GERMAN));
    public static final String CONVERT_OPTIONS;
    public static final String FILTER_NAMES_RESID_MOS6581;
    public static final String FILTER_NAMES_RESID_MOS8580;
    public static final String FILTER_NAMES_RESIDFP_MOS6581;
    public static final String FILTER_NAMES_RESIDFP_CIRCUIT_MOS6581;
    public static final String FILTER_NAMES_RESIDFP_MOS8580;
    public static final String FILTER_NAMES_RESIDFP_CIRCUIT_MOS8580;
    public static final Map<Locale, String> CONVERT_MESSAGES;
    public static final String CONVERT_MESSAGES_TS;
    public static final String CONVERT_OPTIONS_TS;

    static {
        try {
            ObjectMapper objectMapper = new ObjectMapper();
            CONVERT_OPTIONS = objectMapper.writeValueAsString(new ConvertServlet.ConvertServletParameters());
            CONVERT_OPTIONS_TS = createConvertOptionsStub("convertOptions", new ConvertServlet.ConvertServletParameters());
            FILTER_NAMES_RESID_MOS6581 = objectMapper.writeValueAsString(DEFAULTS.getFilterNames(RESID, MOS6581));
            FILTER_NAMES_RESID_MOS8580 = objectMapper.writeValueAsString(DEFAULTS.getFilterNames(RESID, MOS8580));
            FILTER_NAMES_RESIDFP_MOS6581 = objectMapper.writeValueAsString(DEFAULTS.getFilterNames(RESIDFP, MOS6581));
            FILTER_NAMES_RESIDFP_MOS8580 = objectMapper.writeValueAsString(DEFAULTS.getFilterNames(RESIDFP, MOS8580));
            FILTER_NAMES_RESIDFP_CIRCUIT_MOS6581 = objectMapper.writeValueAsString(DEFAULTS.getFilterNames(RESIDFP_CIRCUIT, MOS6581));
            FILTER_NAMES_RESIDFP_CIRCUIT_MOS8580 = objectMapper.writeValueAsString(DEFAULTS.getFilterNames(RESIDFP_CIRCUIT, MOS8580));

            Map<Locale, String> convertMessages = new HashMap<>();
            for (Locale locale : SUPPORTED_LOCALES) {
                convertMessages.put(locale, createObjectMapper(new BeanParameterLocalizer(locale))
                        .writeValueAsString(new ConvertServlet.ConvertServletParameters()));
            }
            CONVERT_MESSAGES = Collections.unmodifiableMap(convertMessages);
            CONVERT_MESSAGES_TS = createConvertMessagesStub("convertMessages", new ConvertServlet.ConvertServletParameters());
        } catch (JsonProcessingException e) {
            throw new ExceptionInInitializerError(e);
        }
    }

    /**
     * Options have exactly one character.
     */
    public static final int OPTION_MAX_LENGTH = 1;
    /**
     * GNU options have at least two characters.
     */
    public static final int GNU_OPTION_MIN_LENGTH = 2;

    public static void check(Class<?> servletParameterClass, boolean servletParameter)
            throws ExceptionInInitializerError {
        try {
            LOG.info(servletParameterClass.getName());
            Optional.ofNullable(servletParameterClass.getAnnotation(Parameters.class))
                    .orElseThrow(() -> new IllegalAccessException(
                            format(ERRORS.getString("CHECKED_CLASS_MUST_BE_ANNOTATED_WITH_PARAMETERS"),
                                    servletParameterClass)));
            if (servletParameterClass.getAnnotation(Parameters.class).resourceBundle().isEmpty()) {
                throw new IllegalAccessException(
                        format(ERRORS.getString("RESOURCE_BUNDLE_ATTR_MISSING"), servletParameterClass));
            }

            Constructor<?> declaredConstructor = servletParameterClass.getDeclaredConstructor();
            declaredConstructor.setAccessible(true);
            BeanParameterChecker beanParameterChecker = new BeanParameterChecker(servletParameter);
            createObjectMapper(beanParameterChecker).writeValueAsString(declaredConstructor.newInstance());

            if (!(servletParameterClass.getAnnotation(Parameters.class).commandDescriptionKey() != null
                    /* command of a parameter */ || beanParameterChecker.hasUsage)) {
                throw new ExceptionInInitializerError(
                        format(ERRORS.getString("CHECKED_CLASS_IS_MISSING_A_USAGE"), servletParameterClass));
            }
        } catch (JsonProcessingException | InstantiationException | IllegalAccessException | IllegalArgumentException
                 | InvocationTargetException | NoSuchMethodException | SecurityException e) {
            throw new ExceptionInInitializerError(e);
        }
    }

    private static final String FILTER_NAME = "localizer";

    @JsonFilter(FILTER_NAME)
    @JsonAutoDetect(fieldVisibility = ANY, getterVisibility = ANY, setterVisibility = ANY)
    private static final class FilteredMixIn {
    }

    private static ObjectMapper createObjectMapper(SimpleBeanPropertyFilter filter) {
        return new ObjectMapper().setMixInResolver(new MixInResolver() {
            @Override
            public Class<?> findMixInClassFor(Class<?> cls) {
                return FilteredMixIn.class;
            }

            @Override
            public MixInResolver copy() {
                return this;
            }
        }).setFilterProvider(new SimpleFilterProvider().addFilter(FILTER_NAME, filter));
    }

    private static final class BeanParameterLocalizer extends SimpleBeanPropertyFilter {

        private final Locale locale;

        private BeanParameterLocalizer(Locale locale) {
            this.locale = locale;
        }

        @Override
        public void serializeAsField(Object pojo, JsonGenerator jgen, SerializerProvider prov, PropertyWriter writer)
                throws Exception {
            Parameters parameters = pojo.getClass().getAnnotation(Parameters.class);
            Parameter parameter = writer.getAnnotation(Parameter.class);
            if (parameters != null && parameter != null && !parameters.resourceBundle().isEmpty()) {
                ResourceBundle resBundle = ResourceBundle.getBundle(parameters.resourceBundle(), locale);
                jgen.writeStringField(writer.getName(), resBundle.getString(parameter.descriptionKey()));
            } else if (writer.getAnnotation(ParametersDelegate.class) != null) {
                super.serializeAsField(pojo, jgen, prov, writer);
            }
        }
    }

    private static final class BeanParameterChecker extends SimpleBeanPropertyFilter {

        private static final LocaleComparator LOCALE_COMPARATOR = new LocaleComparator();
        private static final Control CONTROL = ResourceBundle.Control.getControl(Control.FORMAT_PROPERTIES);

        private static final CharsetDecoder US_ASCII_DECODER = US_ASCII.newDecoder()
                .onMalformedInput(CodingErrorAction.REPORT);

        private final Set<Integer> orders = new HashSet<>();

        private final Set<String> checkedResourceBundles = new HashSet<>();

        private final boolean servletParameter;

        private boolean hasUsage;

        private BeanParameterChecker(boolean servletParameter) {
            this.servletParameter = servletParameter;
        }

        @Override
        public void serializeAsField(Object pojo, JsonGenerator jgen, SerializerProvider prov, PropertyWriter writer)
                throws Exception {
            Parameters parameters = pojo.getClass().getAnnotation(Parameters.class);
            Parameter parameter = writer.getAnnotation(Parameter.class);
            if (parameter != null) {
                if (parameter.help()) {
                    hasUsage = true;
                }
                if (!orders.add(parameter.order())) {
                    throw JsonMappingException.from(prov,
                            format(ERRORS.getString("AMBIGUOUS_ORDER"), parameter.order()));
                }
                if (servletParameter) {
                    for (String name : parameter.names()) {
                        if (name.startsWith("--")) {
                            if (name.length() < ("--".length() + GNU_OPTION_MIN_LENGTH)) {
                                throw JsonMappingException.from(prov, ERRORS.getString("GNU_OPTION_MIN_LENGTH_ERROR"));
                            }
                        } else if (name.startsWith("-")) {
                            if (name.length() > ("-".length() + OPTION_MAX_LENGTH)) {
                                throw JsonMappingException.from(prov, ERRORS.getString("OPTION_MAX_LENGTH_ERROR"));
                            }
                        } else {
                            throw JsonMappingException.from(prov, ERRORS.getString("OPTION_PREFIX_ERROR"));
                        }
                    }
                    if (Arrays.asList(Boolean.class, boolean.class).contains(writer.getType().getRawClass())
                            && parameter.arity() != 1) {
                        throw JsonMappingException.from(prov,
                                format(ERRORS.getString("BOOLEAN_ARITY_ERROR"), parameter.arity()));
                    }
                }
                ResourceBundle rootResourceBundle = null;

                for (Locale locale : SUPPORTED_LOCALES.stream().sorted(LOCALE_COMPARATOR).collect(toList())) {
                    checkEncoding(parameters.resourceBundle(), locale);

                    ResourceBundle resourceBundle = ResourceBundle.getBundle(parameters.resourceBundle(), locale);
                    if (locale == Locale.ROOT) {
                        rootResourceBundle = resourceBundle;
                    }
                    if (parameter.descriptionKey().isEmpty()) {
                        throw JsonMappingException.from(prov,
                                format(ERRORS.getString("DESCRIPTION_KEY_ATTR_MISSING"), pojo.getClass()));
                    }
                    throwIfLocalizationMissing(prov, resourceBundle, rootResourceBundle, parameter.descriptionKey());

                    if (servletParameter) {
                        if (parameter.help()) {
                            throwIfLocalizationMissing(prov, resourceBundle, rootResourceBundle, "USAGE_DESCRIPTION");
                            if (locale == Locale.ROOT) {
                                // RESTful API documentation, available only in english
                                throwIfLocalizationMissing(prov, resourceBundle, rootResourceBundle,
                                        "USAGE_LONG_DESCRIPTION");
                                throwIfLocalizationMissing(prov, resourceBundle, rootResourceBundle,
                                        "EXAMPLE_REQUEST_SERVLET_PATH");
                                throwIfLocalizationMissing(prov, resourceBundle, rootResourceBundle,
                                        "EXAMPLE_REQUEST_PATH");
                            }
                        }
                        if (parameter.names().length == 0 /* main parameter */) {
                            throwIfLocalizationMissing(prov, resourceBundle, rootResourceBundle,
                                    "EXAMPLE_REQUEST_PATH");
                        }
                    }
                }
            } else if (writer.getAnnotation(ParametersDelegate.class) != null) {
                super.serializeAsField(pojo, jgen, prov, writer);
            }
        }

        private void throwIfLocalizationMissing(SerializerProvider prov, ResourceBundle resourceBundle,
                                                ResourceBundle rootResourceBundle, String key) throws JsonMappingException {
            String bundleName = CONTROL.toBundleName(resourceBundle.getBaseBundleName(), resourceBundle.getLocale());

            if (!isKeyOfBundle(resourceBundle, rootResourceBundle, key)) {
                throw JsonMappingException.from(prov,
                        format(ERRORS.getString("LOCALIZATION_MISSING"), bundleName, key));
            }
        }

        private boolean isKeyOfBundle(ResourceBundle resourceBundle, ResourceBundle rootResourceBundle, String key) {
            //noinspection StringEquality
            return resourceBundle.getLocale() == Locale.ROOT ? resourceBundle.containsKey(key)
                    : resourceBundle.getString(key) != rootResourceBundle.getString(key);
        }

        private void checkEncoding(String resourceBundleName, Locale locale) throws Exception {
            String bundleName = CONTROL.toBundleName(resourceBundleName, locale);
            String resourceName = CONTROL.toResourceName(bundleName, "properties");

            if (checkedResourceBundles.add(resourceName)) {
                LOG.fine(format("Check encoding of %s", resourceName));

                ByteBuffer byteBuffer = null;
                byte[] byteArray = null;
                try {
                    InputStream resourceAsStream = getClass().getResourceAsStream("/" + resourceName);
                    if (resourceAsStream == null) {
                        throw new FileNotFoundException(resourceName);
                    }
                    byteArray = IOUtils.readAllBytes(resourceAsStream);
                    byteBuffer = ByteBuffer.wrap(byteArray);
                    US_ASCII_DECODER.decode(byteBuffer);
                } catch (CharacterCodingException e) {
                    Entry<Integer, Integer> lineColumn = getLineColumn(byteArray, byteBuffer.position());
                    LOG.log(Level.SEVERE, format(ERRORS.getString("ILLEGAL_CHARACTERS_IN_RESOURCE_NAME"), resourceName,
                            lineColumn.getKey(), lineColumn.getValue()), e);
                    throw e;
                } catch (IOException e) {
                    LOG.log(Level.SEVERE, format(ERRORS.getString("CHECK_ENCODING_FAILED"), resourceName), e);
                    throw e;
                }
            }
        }

        private Map.Entry<Integer, Integer> getLineColumn(byte[] byteArray, int bytePosition) {
            int currentPos = 0, colNo = 1, lineNo = 1;
            for (byte b : byteArray) {
                if (currentPos == bytePosition) {
                    break;
                }
                if (b == '\n') {
                    lineNo++;
                    colNo = 0;
                }
                colNo++;
                currentPos++;
            }
            return new SimpleEntry<>(lineNo, colNo);
        }

    }

}