/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you 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 org.apache.beam.sdk.values;

import static org.junit.Assert.assertEquals;

import java.lang.reflect.Method;
import java.lang.reflect.TypeVariable;
import java.util.List;
import java.util.Set;
import org.apache.beam.vendor.guava.v26_0_jre.com.google.common.reflect.TypeToken;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.ExpectedException;
import org.junit.runner.RunWith;
import org.junit.runners.JUnit4;

/** Tests for TypeDescriptor. */
@RunWith(JUnit4.class)
@SuppressWarnings({
  "nullness" // TODO(https://issues.apache.org/jira/browse/BEAM-10402)
})
public class TypeDescriptorTest {

  @Rule public transient ExpectedException thrown = ExpectedException.none();

  @Test
  public void testTypeDescriptorOfRawType() throws Exception {
    assertEquals(
        TypeToken.of(String.class).getRawType(), TypeDescriptor.of(String.class).getRawType());
  }

  @Test
  public void testTypeDescriptorImmediate() throws Exception {
    assertEquals(Boolean.class, new TypeDescriptor<Boolean>() {}.getRawType());
    assertEquals(Double.class, new TypeDescriptor<Double>() {}.getRawType());
    assertEquals(Float.class, new TypeDescriptor<Float>() {}.getRawType());
    assertEquals(Integer.class, new TypeDescriptor<Integer>() {}.getRawType());
    assertEquals(Long.class, new TypeDescriptor<Long>() {}.getRawType());
    assertEquals(Short.class, new TypeDescriptor<Short>() {}.getRawType());
    assertEquals(String.class, new TypeDescriptor<String>() {}.getRawType());
  }

  @Test
  public void testTypeDescriptorGeneric() throws Exception {
    TypeDescriptor<List<String>> descriptor = new TypeDescriptor<List<String>>() {};
    TypeToken<List<String>> token = new TypeToken<List<String>>() {};
    assertEquals(token.getType(), descriptor.getType());
  }

  private static class TypeRememberer<T> {
    public final TypeDescriptor<T> descriptorByClass;
    public final TypeDescriptor<T> descriptorByInstance;

    public TypeRememberer() {
      descriptorByClass = new TypeDescriptor<T>(getClass()) {};
      descriptorByInstance = new TypeDescriptor<T>(this) {};
    }
  }

  @Test
  public void testTypeDescriptorNested() throws Exception {
    TypeRememberer<String> rememberer = new TypeRememberer<String>() {};
    assertEquals(new TypeToken<String>() {}.getType(), rememberer.descriptorByClass.getType());
    assertEquals(new TypeToken<String>() {}.getType(), rememberer.descriptorByInstance.getType());

    TypeRememberer<List<String>> genericRememberer = new TypeRememberer<List<String>>() {};
    assertEquals(
        new TypeToken<List<String>>() {}.getType(), genericRememberer.descriptorByClass.getType());
    assertEquals(
        new TypeToken<List<String>>() {}.getType(),
        genericRememberer.descriptorByInstance.getType());
  }

  private static class Id<T> {
    @SuppressWarnings("unused") // used via reflection
    public T identity(T thingie) {
      return thingie;
    }
  }

  @Test
  public void testGetArgumentTypes() throws Exception {
    Method identity = Id.class.getDeclaredMethod("identity", Object.class);

    TypeToken<Id<String>> token = new TypeToken<Id<String>>() {};
    TypeDescriptor<Id<String>> descriptor = new TypeDescriptor<Id<String>>() {};
    assertEquals(
        token.method(identity).getParameters().get(0).getType().getType(),
        descriptor.getArgumentTypes(identity).get(0).getType());

    TypeToken<Id<List<String>>> genericToken = new TypeToken<Id<List<String>>>() {};
    TypeDescriptor<Id<List<String>>> genericDescriptor = new TypeDescriptor<Id<List<String>>>() {};
    assertEquals(
        genericToken.method(identity).getParameters().get(0).getType().getType(),
        genericDescriptor.getArgumentTypes(identity).get(0).getType());
  }

  private static class TypeRemembererer<T1, T2> {
    public TypeDescriptor<T1> descriptor1;
    public TypeDescriptor<T2> descriptor2;

    public TypeRemembererer() {
      descriptor1 = new TypeDescriptor<T1>(getClass()) {};
      descriptor2 = new TypeDescriptor<T2>(getClass()) {};
    }
  }

  @Test
  public void testTypeDescriptorNested2() throws Exception {
    TypeRemembererer<String, Integer> remembererer = new TypeRemembererer<String, Integer>() {};
    assertEquals(new TypeToken<String>() {}.getType(), remembererer.descriptor1.getType());
    assertEquals(new TypeToken<Integer>() {}.getType(), remembererer.descriptor2.getType());

    TypeRemembererer<List<String>, Set<Integer>> genericRemembererer =
        new TypeRemembererer<List<String>, Set<Integer>>() {};
    assertEquals(
        new TypeToken<List<String>>() {}.getType(), genericRemembererer.descriptor1.getType());
    assertEquals(
        new TypeToken<Set<Integer>>() {}.getType(), genericRemembererer.descriptor2.getType());
  }

  private static class GenericClass<BizzleT> {}

  @Test
  public void testGetTypeParameterGood() throws Exception {
    @SuppressWarnings("rawtypes")
    TypeVariable<Class<? super GenericClass>> bizzleT =
        TypeDescriptor.of(GenericClass.class).getTypeParameter("BizzleT");
    assertEquals(GenericClass.class.getTypeParameters()[0], bizzleT);
  }

  @Test
  public void testGetTypeParameterBad() throws Exception {
    thrown.expect(IllegalArgumentException.class);
    thrown.expectMessage("MerpleT"); // just check that the message gives actionable details
    TypeDescriptor.of(GenericClass.class).getTypeParameter("MerpleT");
  }

  private static class GenericMaker<T> {
    public TypeRememberer<List<T>> getRememberer() {
      return new TypeRememberer<List<T>>() {};
    }
  }

  private static class GenericMaker2<T> {
    public GenericMaker<Set<T>> getGenericMaker() {
      return new GenericMaker<Set<T>>() {};
    }
  }

  @Test
  public void testEnclosing() throws Exception {
    TypeRememberer<List<String>> rememberer = new GenericMaker<String>() {}.getRememberer();
    assertEquals(
        new TypeToken<List<String>>() {}.getType(), rememberer.descriptorByInstance.getType());

    // descriptorByClass *is not* able to find the type of T because it comes from the enclosing
    // instance of GenericMaker.
    // assertEquals(new TypeToken<List<T>>() {}.getType(), rememberer.descriptorByClass.getType());
  }

  @Test
  public void testEnclosing2() throws Exception {
    // If we don't override, the best we can get is List<Set<T>>
    // TypeRememberer<List<Set<String>>> rememberer =
    //    new GenericMaker2<String>(){}.getGenericMaker().getRememberer();
    // assertNotEquals(
    //    new TypeToken<List<Set<String>>>() {}.getType(),
    //    rememberer.descriptorByInstance.getType());

    // If we've overridden the getGenericMaker we can determine the types.
    TypeRememberer<List<Set<String>>> rememberer =
        new GenericMaker2<String>() {
          @Override
          public GenericMaker<Set<String>> getGenericMaker() {
            return new GenericMaker<Set<String>>() {};
          }
        }.getGenericMaker().getRememberer();
    assertEquals(
        new TypeToken<List<Set<String>>>() {}.getType(), rememberer.descriptorByInstance.getType());
  }

  @Test
  public void testWhere() throws Exception {
    useWhereMethodToDefineTypeParam(new TypeDescriptor<String>() {});
  }

  private <T> void useWhereMethodToDefineTypeParam(TypeDescriptor<T> parameterType) {
    TypeDescriptor<Set<T>> typeDescriptor =
        new TypeDescriptor<Set<T>>() {}.where(new TypeParameter<T>() {}, parameterType);
    assertEquals(new TypeToken<Set<String>>() {}.getType(), typeDescriptor.getType());
  }
}
