/*
 * Copyright 2000-2013 JetBrains s.r.o.
 *
 * 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 com.intellij.codeInsight.daemon.lambda;

import com.intellij.psi.*;
import com.intellij.psi.impl.source.resolve.graphInference.InferenceSession;
import com.intellij.psi.impl.source.resolve.graphInference.PsiPolyExpressionUtil;
import com.intellij.psi.util.PsiTreeUtil;
import com.intellij.testFramework.fixtures.LightCodeInsightFixtureTestCase;

public class PsiPolyExpressionUtilTest extends LightCodeInsightFixtureTestCase {
  public void testPrefixExpression() throws Exception {
    final PsiExpression psiExpression = findExpression("     int j = i<caret>++;");
    assertInstanceOf(psiExpression, PsiPostfixExpression.class);
    assertTrue(PsiPolyExpressionUtil.hasStandaloneForm(psiExpression));
    assertFalse(PsiPolyExpressionUtil.isPolyExpression(psiExpression));
  }

  public void testNumericConditionExpression() throws Exception {
    final PsiExpression psiExpression = findExpression("     int j = i == 0 <caret>? i + 1 : i - 1;");
    assertInstanceOf(psiExpression, PsiConditionalExpression.class);
    assertFalse(PsiPolyExpressionUtil.hasStandaloneForm(psiExpression));
    assertFalse(PsiPolyExpressionUtil.isPolyExpression(psiExpression));
  }

  public void testPolyConditionExpression() throws Exception {
    myFixture.configureByText("Foo.java", "import java.util.*;" +
                                          "class Foo {" +
                                          "  String foo(int i) {" +
                                          "     return i == 0 <caret>? bar() : bar();" +
                                          "  }" +
                                          "  String bar() {return null;}" +
                                          "}");
    final PsiElement elementAtCaret = myFixture.getFile().findElementAt(myFixture.getCaretOffset());
    assertNotNull(elementAtCaret);
    final PsiExpression psiExpression = PsiTreeUtil.getParentOfType(elementAtCaret, PsiExpression.class);
    assertInstanceOf(psiExpression, PsiConditionalExpression.class);
    assertFalse(PsiPolyExpressionUtil.hasStandaloneForm(psiExpression));
    assertTrue(PsiPolyExpressionUtil.isPolyExpression(psiExpression));
  }

  public void testNewExpressionDiamond() throws Exception {
    final PsiExpression psiExpression = findExpression("     List<String> l = new Arr<caret>ayList<>();");
    assertInstanceOf(psiExpression, PsiNewExpression.class);
    assertFalse(PsiPolyExpressionUtil.hasStandaloneForm(psiExpression));
    assertTrue(PsiPolyExpressionUtil.isPolyExpression(psiExpression));
  }

  public void testNewExpression() throws Exception {
    final PsiExpression psiExpression = findExpression("     List<String> l = new Arr<caret>ayList<String>();");
    assertInstanceOf(psiExpression, PsiNewExpression.class);
    assertFalse(PsiPolyExpressionUtil.hasStandaloneForm(psiExpression));
    assertFalse(PsiPolyExpressionUtil.isPolyExpression(psiExpression));
  }

  public void testMethodCallInsideArrayCreation() throws Exception {
    myFixture.configureByText("Foo.java", "import java.util.*;" +
                                          "class Foo {" +
                                          "  <T> T bar() {return null;}" +
                                          "  void foo() {" +
                                          "    String[] a = new String[] {ba<caret>r()};" +
                                          "  }" +
                                          "}");
    final PsiElement elementAtCaret = myFixture.getFile().findElementAt(myFixture.getCaretOffset());
    assertNotNull(elementAtCaret);
    final PsiExpression psiExpression = PsiTreeUtil.getParentOfType(elementAtCaret, PsiMethodCallExpression.class);
    assertInstanceOf(psiExpression, PsiMethodCallExpression.class);
    assertTrue(PsiPolyExpressionUtil.isPolyExpression(psiExpression));
  }

  public void testConditional() throws Exception {
    myFixture.configureByText("Foo.java", "import java.util.function.Supplier;" +
                                          "class Foo {" +
                                          "    private static <R> void map(Supplier<R> fn) {}\n" +
                                          "    public static void main(String[] args) {\n" +
                                          "        Runnable r = null;\n" +
                                          "        map(() -> (true <caret>? r : r));\n" +
                                          "    }" +
                                          "}");
    final PsiElement elementAtCaret = myFixture.getFile().findElementAt(myFixture.getCaretOffset());
    assertNotNull(elementAtCaret);
    final PsiExpression psiExpression = PsiTreeUtil.getParentOfType(elementAtCaret, PsiExpression.class);
    assertInstanceOf(psiExpression, PsiConditionalExpression.class);
    assertTrue(PsiPolyExpressionUtil.isPolyExpression(psiExpression));
  }

  public void testConditionalInAssignment() throws Exception {
    myFixture.configureByText("Foo.java", "class Foo {" +
                                          "    public static void main(String[] args) {\n" +
                                          "        Object obj = new Object();\n" +
                                          "        String str = \"\";\n" +
                                          "        str += args.length == 0 <caret>? obj : args[0];\n" +
                                          "    }" +
                                          "}");
    final PsiElement elementAtCaret = myFixture.getFile().findElementAt(myFixture.getCaretOffset());
    assertNotNull(elementAtCaret);
    final PsiExpression psiExpression = PsiTreeUtil.getParentOfType(elementAtCaret, PsiExpression.class);
    assertInstanceOf(psiExpression, PsiConditionalExpression.class);
    assertFalse(PsiPolyExpressionUtil.isPolyExpression(psiExpression));
  }



  private PsiExpression findExpression(String textWithExpression) {
    myFixture.configureByText("Foo.java", "import java.util.*;" +
                                          "class Foo {" +
                                          "  void foo(int i) {" +
                                               textWithExpression +
                                          "  }" +
                                          "}");
    final PsiElement elementAtCaret = myFixture.getFile().findElementAt(myFixture.getCaretOffset());
    assertNotNull(elementAtCaret);
    return PsiTreeUtil.getParentOfType(elementAtCaret, PsiExpression.class);
  }

  public void testPertinentLambdaExpression() throws Exception {
    assertFalse(doTestLambdaPertinent("  void bar(List<Runnable> l) {" +
                                      "   foo(() <caret>-> {}, l);" +
                                      "  }"));
  }

  public void testPertinentImplicitLambdaExpression() throws Exception {
    assertFalse(doTestLambdaPertinent("  void bar(List<Comparable<String>> l) {" +
                                      "   foo((String s) <caret>-> 1, l);" +
                                      "  }"));
  }

  public void testPertinentNestedLambdaExpression() throws Exception {
    assertFalse(doTestLambdaPertinent("  interface Fun<I, O> { O inOut(I i);}\n" +
                                      "  void bar(List<Fun<String, Fun<String, String>>> l) {" +
                                      "   foo((sIn, sOut) -> (sInInner, sOutInner) <caret>-> sOutInner, l);" +
                                      "  }"));
  }

  public void testPertinentNestedLambdaExpressionWhenTargetIsTypeParameterOfMethod() throws Exception {
    myFixture.configureByText("Foo.java", "interface Supplier<T> { T get();}" +
                                          "class Foo {" +
                                          "      { Supplier<Runnable> x = foo ((<caret>) -> () -> {});}\n" +
                                          "      static <T> Supplier<T> foo(Supplier<T> delegate) {\n" +
                                          "          return null;\n" +
                                          "      }\n" +
                                          "}");
    final PsiElement elementAtCaret = myFixture.getFile().findElementAt(myFixture.getCaretOffset());
    assertNotNull(elementAtCaret);
    final PsiExpression psiExpression = PsiTreeUtil.getParentOfType(elementAtCaret, PsiExpression.class);
    assertInstanceOf(psiExpression, PsiLambdaExpression.class);
    final PsiClass aClass = myFixture.findClass("Foo");
    assertNotNull(aClass);
    final PsiMethod[] meths = aClass.findMethodsByName("foo", false);
    assertTrue(meths.length == 1);
    assertFalse(InferenceSession.isPertinentToApplicability(psiExpression, meths[0]));
  }

  public void testNotExactMethodReferenceOnRawClassType() throws Exception {
    myFixture.configureByText("Foo.java", "class Foo {" +
                                          "    class Test<A>{ Test(){}}" +
                                          "    {Runnable r = Test:<caret>:new;}" +  
                                          "}");
    final PsiElement elementAtCaret = myFixture.getFile().findElementAt(myFixture.getCaretOffset());
    assertNotNull(elementAtCaret);
    final PsiExpression psiExpression = PsiTreeUtil.getParentOfType(elementAtCaret, PsiExpression.class);
    assertInstanceOf(psiExpression, PsiMethodReferenceExpression.class);
    assertFalse(((PsiMethodReferenceExpression)psiExpression).isExact());
  }

  public void testExactMethodReferenceOnGenericClassType() throws Exception {
    myFixture.configureByText("Foo.java", "class Foo {" +
                                          "    class Test<A>{ Test(){}}" +
                                          "    {Runnable r = Test<String>:<caret>:new;}" +  
                                          "}");
    final PsiElement elementAtCaret = myFixture.getFile().findElementAt(myFixture.getCaretOffset());
    assertNotNull(elementAtCaret);
    final PsiExpression psiExpression = PsiTreeUtil.getParentOfType(elementAtCaret, PsiExpression.class);
    assertInstanceOf(psiExpression, PsiMethodReferenceExpression.class);
    assertTrue(((PsiMethodReferenceExpression)psiExpression).isExact());
  }

  private boolean doTestLambdaPertinent(final String barText) {
    myFixture.configureByText("Foo.java", "import java.util.*;" +
                                          "class Foo {" +
                                          "  <T> T foo(T t, List<T> lT) {" +
                                          "  }" +
                                          barText +
                                          "}");
    final PsiElement elementAtCaret = myFixture.getFile().findElementAt(myFixture.getCaretOffset());
    assertNotNull(elementAtCaret);
    final PsiExpression psiExpression = PsiTreeUtil.getParentOfType(elementAtCaret, PsiExpression.class);
    assertInstanceOf(psiExpression, PsiLambdaExpression.class);
    final PsiClass aClass = myFixture.findClass("Foo");
    assertNotNull(aClass);
    final PsiMethod[] meths = aClass.findMethodsByName("foo", false);
    assertTrue(meths.length == 1);
    return InferenceSession.isPertinentToApplicability(psiExpression, meths[0]);
  }
}