package com.puppycrawl.tools.checkstyle.checks.modifier.modifierorder;

import java.io.File;
import java.io.IOException;
import java.io.Serializable;
import java.lang.annotation.ElementType;
import java.lang.annotation.Target;
import java.util.Collection;
import java.util.Comparator;
import java.util.List;
import java.util.Map;

public class InputModifierOrderTypeAnnotations extends MyClass {

    // Simple type definitions with type annotations
    private @TypeAnnotation String hello = "Hello, World!";
    private @TypeAnnotation final String jdk = "JDK8";
    @TypeAnnotation private String projectName = "Checkstyle";

    // We can use type Annotations with generic type arguments
    private Map.@TypeAnnotation Entry entry;
    // Type annotations can also be applied to nested types
    private List<@TypeAnnotation String> strings;

    // Constructors with type annotations
    {
        new @TypeAnnotation Object();
    }

    static {
        new @TypeAnnotation Object();
    }

    public void foo1() {
        new @TypeAnnotation Object();
    }

    // Type annotations work with nested (non static) class constructors too
    public void foo2() {
        Object myObject = new Object();
        //myObject.new @TypeAnnotation Nested();
    }

    // Type casts
    public void foo3() {
        String myString = (@TypeAnnotation String) new Object();

    }

    // Type annotations with method arguments
    private void foo4(final @TypeAnnotation String parameterName) { }

    // Inheritance
    class MySerializableClass<T> implements @TypeAnnotation Serializable {  }

    // Nested type annotations
    Map<@TypeAnnotation String, @TypeAnnotation List<@TypeAnnotation String>> documents;

    // Apply type annotations to intersection types
    public <E extends @TypeAnnotation Comparator<E> & @TypeAnnotation Comparable> void foo5() {  }

    // Including parameter bounds and wildcard bounds
    class Folder<F extends @TypeAnnotation File> { }
    Collection<? super @TypeAnnotation File> c;
    List<@TypeAnnotation ? extends Comparable<T>> unchangeable;

    // Throwing exceptions
    void foo6() throws @TypeAnnotation IOException { }

    // Type annotations in instanceof statements
    public void foo7() {
        boolean isNonNull = "string" instanceof @TypeAnnotation String;

    }

    class Nested { }

    class T { }

    // Type annotation on method return type
    @Override
    public @TypeAnnotation String toString() { return ""; }

    @Override
    @TypeAnnotation public int hashCode() { return 1; }

    public @TypeAnnotation int foo8() { return 1; }

    public @TypeAnnotation boolean equals(Object obj) { return super.equals(obj); }

//    @TypeAnnotation void foo9() { } <-- Compiletime error:
                                        // void type cannot be annotated with type annotation

    @Override
    void foo10() {
        super.foo10();
    }
}

class MyClass {

    // It is annotation on method, but not on type!
    @MethodAnnotation void foo10() {}
    private @MethodAnnotation void foo11() {}

    public @TypeAnnotation MyClass() {}
    @ConstructorAnnotation public MyClass(String name) {}
}

enum MyEnum {
    @TypeAnnotation A;
}

interface IInterfacable {
    default @TypeAnnotation String foo() {
        return null;
    }
}

@Target({
    ElementType.FIELD, ElementType.LOCAL_VARIABLE, ElementType.PARAMETER,
    ElementType.TYPE_PARAMETER, ElementType.TYPE_USE})
@interface TypeAnnotation {
}

@interface MethodAnnotation {}

@interface ConstructorAnnotation {}
