/*
 * Copyright 2013 Netflix, Inc.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package feign.codec;

import java.io.IOException;
import java.io.Reader;
import java.lang.reflect.Type;
import java.util.ArrayList;
import java.util.List;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import static feign.Util.checkNotNull;
import static java.lang.String.format;
import static java.util.regex.Pattern.DOTALL;
import static java.util.regex.Pattern.compile;

/**
 * Static utility methods pertaining to {@code Decoder} instances. <br>
 * <br>
 * <br>
 * <b>Pattern Decoders</b><br>
 * <br>
 * Pattern decoders typically require less initialization, dependencies, and
 * code than reflective decoders, but not can be awkward to those unfamiliar
 * with regex. Typical use of pattern decoders is to grab a single field from an
 * xml response, or parse a list of Strings. The pattern decoders here
 * facilitate these use cases.
 */
public class Decoders {
  /**
   * guava users will implement this with {@code ApplyFirstGroup<String, T>}.
   *
   * @param <T> intended result type
   */
  public interface ApplyFirstGroup<T> {
    /**
     * create a new instance from the non-null {@code firstGroup} specified.
     */
    T apply(String firstGroup);
  }

  /**
   * shortcut for <pre>new TransformFirstGroup<String>(pattern, applyFirstGroup){}</pre> when
   * {@code String} is the type you are decoding into. <br>
   * <br>
   * Ex. to pull the first interesting element from an xml response: <br>
   * <p/>
   * <pre>
   * decodeFirstDirPoolID = firstGroup(&quot;&lt;DirPoolID[&circ;&gt;]*&gt;([&circ;&lt;]+)&lt;/DirPoolID&gt;&quot;);
   * </pre>
   */
  public static Decoder.TextStream<String> firstGroup(String pattern) {
    return new TransformFirstGroup<String>(pattern, IDENTITY) {
    };
  }

  /**
   * shortcut for <pre>new TransformEachFirstGroup<String>(pattern, applyFirstGroup){}</pre> when
   * {@code List<String>} is the type you are decoding into. <br>
   * Ex. to pull a list zones names, which are http paths starting with
   * {@code /Rest/Zone/}: <br>
   * <p/>
   * <pre>
   * decodeListOfZonesNames = eachFirstGroup(&quot;/REST/Zone/([&circ;/]+)/&quot;);
   * </pre>
   */
  public static Decoder.TextStream<List<String>> eachFirstGroup(String pattern) {
    return new TransformEachFirstGroup<String>(pattern, IDENTITY) {
    };
  }

  private static String toString(Reader reader) throws IOException {
    return TO_STRING.decode(reader, null).toString();
  }

  private static final StringDecoder TO_STRING = new StringDecoder();

  private static final ApplyFirstGroup<String> IDENTITY = new ApplyFirstGroup<String>() {
    @Override
    public String apply(String firstGroup) {
      return firstGroup;
    }
  };

  /**
   * The first match group is applied to {@code applyGroups} and result
   * returned. If no matches are found, the response is null; <br>
   * Ex. to pull the first interesting element from an xml response: <br>
   * <p/>
   * <pre>
   * decodeFirstDirPoolID = new TransformFirstGroup&lt;Long&gt;(&quot;&lt;DirPoolID[&circ;&gt;]*&gt;([&circ;&lt;]+)&lt;/DirPoolID&gt;&quot;, ToLong.INSTANCE) {
   * };
   * </pre>
   */
  public static class TransformFirstGroup<T> implements Decoder.TextStream<T> {
    private final Pattern patternForMatcher;
    private final ApplyFirstGroup<T> applyFirstGroup;

    /**
     * You must subclass this, in order to prevent type erasure on {@code T}
     * . In addition to making a concrete type, you can also use the
     * following form.
     * <p/>
     * <br>
     * <p/>
     * <pre>
     * new TransformFirstGroup&lt;Foo&gt;(pattern, applyFirstGroup) {
     * }; // note the curly braces ensures no type erasure!
     * </pre>
     */
    protected TransformFirstGroup(String pattern, ApplyFirstGroup<T> applyFirstGroup) {
      this.patternForMatcher = compile(checkNotNull(pattern, "pattern"), DOTALL);
      this.applyFirstGroup = checkNotNull(applyFirstGroup, "applyFirstGroup");
    }

    @Override
    public T decode(Reader reader, Type type) throws IOException {
      Matcher matcher = patternForMatcher.matcher(Decoders.toString(reader));
      if (matcher.find()) {
        return applyFirstGroup.apply(matcher.group(1));
      }
      return null;
    }

    @Override
    public String toString() {
      return format("decode groups from %s into %s", patternForMatcher, applyFirstGroup);
    }
  }

  /**
   * On the each find the first match group is applied to
   * {@code applyFirstGroup} and added to the list returned. If no matches are
   * found, the response is an empty list; <br>
   * Ex. to pull a list zones constructed from http paths starting with
   * {@code /Rest/Zone/}:
   * <p/>
   * <br>
   * <p/>
   * <pre>
   * decodeListOfZones = new TransformEachFirstGroup(&quot;/REST/Zone/([&circ;/]+)/&quot;, ToZone.INSTANCE) {
   * };
   * </pre>
   */
  public static class TransformEachFirstGroup<T> implements Decoder.TextStream<List<T>> {
    private final Pattern patternForMatcher;
    private final ApplyFirstGroup<T> applyFirstGroup;

    /**
     * You must subclass this, in order to prevent type erasure on {@code T}
     * . In addition to making a concrete type, you can also use the
     * following form.
     * <p/>
     * <br>
     * <p/>
     * <pre>
     * new TransformEachFirstGroup&lt;Foo&gt;(pattern, applyFirstGroup) {
     * }; // note the curly braces ensures no type erasure!
     * </pre>
     */
    protected TransformEachFirstGroup(String pattern, ApplyFirstGroup<T> applyFirstGroup) {
      this.patternForMatcher = compile(checkNotNull(pattern, "pattern"), DOTALL);
      this.applyFirstGroup = checkNotNull(applyFirstGroup, "applyFirstGroup");
    }

    @Override
    public List<T> decode(Reader reader, Type type) throws IOException {
      Matcher matcher = patternForMatcher.matcher(Decoders.toString(reader));
      List<T> result = new ArrayList<T>();
      while (matcher.find()) {
        result.add(applyFirstGroup.apply(matcher.group(1)));
      }
      return result;
    }

    @Override
    public String toString() {
      return format("decode %s into list elements, where each group(1) is transformed with %s",
          patternForMatcher, applyFirstGroup);
    }
  }
}