/**
    * This file Copyright (c) 2018 Magnolia International
    * Ltd.  (http://www.magnolia-cms.com). All rights reserved.
    *
    *
    * This file is dual-licensed under both the Magnolia
    * Network Agreement and the GNU General Public License.
    * You may elect to use one or the other of these licenses.
    *
   * This file is distributed in the hope that it will be
   * useful, but AS-IS and WITHOUT ANY WARRANTY; without even the
   * implied warranty of MERCHANTABILITY or FITNESS FOR A
   * PARTICULAR PURPOSE, TITLE, or NONINFRINGEMENT.
   * Redistribution, except as permitted by whichever of the GPL
   * or MNA you select, is prohibited.
   *
   * 1. For the GPL license (GPL), you can redistribute and/or
   * modify this file under the terms of the GNU General
   * Public License, Version 3, as published by the Free Software
   * Foundation.  You should have received a copy of the GNU
   * General Public License, Version 3 along with this program;
   * if not, write to the Free Software Foundation, Inc., 51
   * Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
   *
   * 2. For the Magnolia Network Agreement (MNA), this file
   * and the accompanying materials are made available under the
   * terms of the MNA which accompanies this distribution, and
   * is available at http://www.magnolia-cms.com/mna.html
   *
   * Any modifications to this file must keep this entire header
   * intact.
   *
   */
  package info.magnolia.rest.delivery.jcr.i18n;
  
  import info.magnolia.cms.i18n.I18nContentSupport;
  import info.magnolia.objectfactory.Components;
  
  import java.io.IOException;
  import java.util.List;
  import java.util.Locale;
  import java.util.Locale.LanguageRange;
  
  import javax.ws.rs.BadRequestException;
  import javax.ws.rs.container.ContainerRequestContext;
  import javax.ws.rs.container.ContainerRequestFilter;
  import javax.ws.rs.core.MultivaluedMap;
  import javax.ws.rs.core.Variant;
  import javax.ws.rs.ext.Provider;
  
  import org.apache.commons.collections4.CollectionUtils;
  import org.apache.commons.lang3.LocaleUtils;
  import org.apache.commons.lang3.StringUtils;
  
  /**
   * This filter determines a locale by detecting "Accept-Language" HTTP header and the "lang" request parameter.
   * "lang" parameter has higher priority than "Accept-Language" header.
   * If the locale can't be determined, {@link I18nContentSupport} will do the job.
   */
  @Provider
  @I18n
  public class I18nContainerRequestFilter implements ContainerRequestFilter {
      private static final String LANGUAGE_PARAM = "lang";
      private static final String ALL_LANGUAGE_PARAM = "all";
  
      private final I18nContentSupport i18nContentSupport;
  
      public I18nContainerRequestFilter() {
          this.i18nContentSupport = Components.getComponent(I18nContentSupport.class);
      }
  
      @Override
      public void filter(ContainerRequestContext containerRequestContext) throws IOException {
          if (ALL_LANGUAGE_PARAM.equalsIgnoreCase(containerRequestContext.getUriInfo().getQueryParameters().getFirst(LANGUAGE_PARAM))) {
              return;
          }
          Locale preferredLocale = determineLocaleFromQueryParameter(containerRequestContext.getUriInfo().getQueryParameters());
          if (preferredLocale == null) {
              preferredLocale = determineLocaleFromRequest(containerRequestContext);
          }
  
          if (preferredLocale != null) {
              i18nContentSupport.setLocale(preferredLocale);
          }
      }
  
      private Locale determineLocaleFromQueryParameter(MultivaluedMap<String, String> queryParameters) {
          if (!queryParameters.containsKey(LANGUAGE_PARAM)) {
              return null;
          }
          String localeString = queryParameters.getFirst(LANGUAGE_PARAM);
          // Allows to request single language only.
          if (!isValidLanguageTag(localeString)) {
              throw new BadRequestException(String.format("Language parameter: %s is not allowed", localeString));
          }
          List<LanguageRange> ranges = LanguageRange.parse(localeString);
          return Locale.lookup(ranges, i18nContentSupport.getLocales());
      }
  
     private Locale determineLocaleFromRequest(ContainerRequestContext request) {
         if (CollectionUtils.isEmpty(i18nContentSupport.getLocales()) || CollectionUtils.isEmpty(request.getAcceptableLanguages())) {
             return null;
         }
         // Accepts only for available languages.
         List<Variant> variantList = Variant.VariantListBuilder.newInstance().languages(i18nContentSupport.getLocales().toArray(new Locale[] {})).build();
         Variant bestMatch = request.getRequest().selectVariant(variantList);
 
         if (bestMatch != null && bestMatch.getLanguage() != null) {
             return bestMatch.getLanguage();
         }
         return null;
     }
 
     private boolean isValidLanguageTag(String languageTag) {
         return StringUtils.isBlank(languageTag) ?
                 false : 
                 LocaleUtils.availableLocaleList().stream()
                         .anyMatch(locale -> locale.toLanguageTag().equalsIgnoreCase(languageTag));
     }
 }