/*
 * 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.juneau.bct.assertions;

import static java.util.Collections.*;
import static org.apache.juneau.commons.utils.CollectionUtils.list;
import static org.apache.juneau.commons.utils.Shorts.*;
import static org.apache.juneau.commons.utils.Shorts.eq;
import static org.apache.juneau.commons.utils.ThrowableUtils.*;

import java.io.*;
import java.util.*;
import java.util.function.*;

import org.apache.juneau.commons.function.*;


/**
 * Used for fluent assertion calls against throwables.
 *
 * <h5 class='section'>Test Methods:</h5>
 * <p>
 * <ul class='javatree'>
 *    <li class='jc'>{@link FluentObjectAssertion}
 *    <ul class='javatreec'>
 *       <li class='jm'>{@link FluentObjectAssertion#isExists() isExists()}
 *       <li class='jm'>{@link FluentObjectAssertion#is(Object) is(Object)}
 *       <li class='jm'>{@link FluentObjectAssertion#is(Predicate) is(Predicate)}
 *       <li class='jm'>{@link FluentObjectAssertion#isNot(Object) isNot(Object)}
 *       <li class='jm'>{@link FluentObjectAssertion#isAny(Object...) isAny(Object...)}
 *       <li class='jm'>{@link FluentObjectAssertion#isNotAny(Object...) isNotAny(Object...)}
 *       <li class='jm'>{@link FluentObjectAssertion#isNull() isNull()}
 *       <li class='jm'>{@link FluentObjectAssertion#isNotNull() isNotNull()}
 *       <li class='jm'>{@link FluentObjectAssertion#isString(String) isString(String)}
 *       <li class='jm'>{@link FluentObjectAssertion#isSame(Object) isSame(Object)}
 *       <li class='jm'>{@link FluentObjectAssertion#isType(Class) isType(Class)}
 *       <li class='jm'>{@link FluentObjectAssertion#isExactType(Class) isExactType(Class)}
 *    </ul>
 * </ul>
 *
 * <h5 class='section'>Transform Methods:</h5>
 * <p>
 * <ul class='javatree'>
 *    <li class='jc'>{@link FluentThrowableAssertion}
 *    <ul class='javatreec'>
 *       <li class='jm'>{@link FluentThrowableAssertion#asMessage() asMessage()}
 *       <li class='jm'>{@link FluentThrowableAssertion#asMessages() asMessages()}
 *       <li class='jm'>{@link FluentThrowableAssertion#asLocalizedMessage() asLocalizedMessage()}
 *       <li class='jm'>{@link FluentThrowableAssertion#asLocalizedMessages() asLocalizedMessages()}
 *       <li class='jm'>{@link FluentThrowableAssertion#asStackTrace() asStackTrace()}
 *       <li class='jm'>{@link FluentThrowableAssertion#asCausedBy() asCausedBy()}
 *       <li class='jm'>{@link FluentThrowableAssertion#asCausedBy(Class) asCausedBy(Class)}
 *       <li class='jm'>{@link FluentThrowableAssertion#asFind(Class) asFind(Class)}
 *    </ul>
 *    <li class='jc'>{@link FluentObjectAssertion}
 *    <ul class='javatreec'>
 *       <li class='jm'>{@link FluentObjectAssertion#asString() asString()}
 *       <li class='jm'>{@link FluentObjectAssertion#asString(ThrowingFunction) asString(ThrowingFunction)}
 *       <li class='jm'>{@link FluentObjectAssertion#asTransformed(UnaryOperator) asTransformed(UnaryOperator)}
 *       <li class='jm'>{@link FluentObjectAssertion#asAny() asAny()}
 * </ul>
 * </ul>
 *
 * <h5 class='section'>Configuration Methods:</h5>
 * <p>
 * <ul class='javatree'>
 *    <li class='jc'>{@link Assertion}
 *    <ul class='javatreec'>
 *       <li class='jm'>{@link Assertion#setMsg(String, Object...) setMsg(String, Object...)}
 *       <li class='jm'>{@link Assertion#setOut(PrintStream) setOut(PrintStream)}
 *       <li class='jm'>{@link Assertion#setSilent() setSilent()}
 *       <li class='jm'>{@link Assertion#setStdOut() setStdOut()}
 *       <li class='jm'>{@link Assertion#setThrowable(Class) setThrowable(Class)}
*  </ul>
 * </ul>
 *
 * <h5 class='section'>See Also:</h5><ul>
 *    <li class='link'><a class="doclink" href="https://juneau.apache.org/docs/topics/JuneauEcosystemOverview">Juneau Ecosystem</a>
 * </ul>
 *
 * @param <T> The throwable type.
 * @param <R> The return type.
 */
@SuppressWarnings({
   "java:S115", // Constants use UPPER_snakeCase convention
   "java:S1192" // Duplicated literals (argument/property names) read more clearly inline than as constants
})
public class FluentThrowableAssertion<T extends Throwable,R> extends FluentObjectAssertion<T,R> {

   private static final Messages MESSAGES = Messages.of(FluentThrowableAssertion.class, "Messages");
   private static final String MSG_exceptionWasNotExpectedType = MESSAGES.getString("exceptionWasNotExpectedType");
   private static final String MSG_exceptionWasNotThrown = MESSAGES.getString("exceptionWasNotThrown");
   private static final String MSG_causedByExceptionNotExpectedType = MESSAGES.getString("causedByExceptionNotExpectedType");

   /**
    * Chained constructor.
    *
    * <p>
    * Used when transforming one assertion into another so that the assertion config can be used by the new assertion.
    *
    * @param creator
    *    The assertion that created this assertion.
    *    <br>Should be <jk>null</jk> if this is the top-level assertion.
    * @param value
    *    The object being tested.
    *    <br>Can be <jk>null</jk> (assertions such as {@code isNull()} then operate on the absence of a value).
    * @param returns
    *    The object to return after a test method is called.
    *    <br>If <jk>null</jk>, the test method returns this object allowing multiple test method calls to be
    * used on the same assertion.
    */
   public FluentThrowableAssertion(Assertion creator, T value, R returns) {
      super(creator, value, returns);
   }

   /**
    * Constructor.
    *
    * @param value
    *    The object being tested.
    *    <br>Can be <jk>null</jk> (assertions such as {@code isNull()} then operate on the absence of a value).
    * @param returns
    *    The object to return after a test method is called.
    *    <br>If <jk>null</jk>, the test method returns this object allowing multiple test method calls to be
    * used on the same assertion.
    */
   public FluentThrowableAssertion(T value, R returns) {
      this(null, value, returns);
   }

   /**
    * Returns an assertion against the caused-by throwable.
    *
    * <h5 class='section'>Example:</h5>
    * <p class='bjava'>
    *    <jc>// Asserts that the specified method throws an exception whose
    *    // caused-by message contains 'foobar'. </jc>
    *    ThrowableAssertion.<jsm>assertThrown</jsm>(() -&gt; <jv>foo</jv>.getBar())
    *       .asCausedBy()
    *       .asMessage()
    *       .isPattern(<js>"foobar"</js>);
    * </p>
    *
    * @return An assertion against the caused-by.  Never <jk>null</jk>.
    */
   public FluentThrowableAssertion<Throwable,R> asCausedBy() {
      return asCausedBy(Throwable.class);
   }

   /**
    * Returns an assertion against the caused-by throwable.
    *
    * <h5 class='section'>Example:</h5>
    * <p class='bjava'>
    *    <jc>// Asserts that the specified method throws an exception whose
    *    // caused-by message contains 'foobar'. </jc>
    *    ThrowableAssertion.<jsm>assertThrown</jsm>(() -&gt; <jv>foo</jv>.getBar())
    *       .asCausedBy(RuntimeException.<jk>class</jk>)
    *       .asMessage()
    *       .isPattern(<js>"foobar"</js>);
    * </p>
    *
    * @param <X> The throwable type.
    * @param type The expected exception type.
    * @return An assertion against the caused-by.  Never <jk>null</jk>.
    */
   public <X extends Throwable> FluentThrowableAssertion<X,R> asCausedBy(Class<X> type) {
      var t = map(Throwable::getCause).orElse(null);
      if (t == null || type.isInstance(t))
         return new FluentThrowableAssertion<>(this, type.cast(t), returns());
      throw error(MSG_causedByExceptionNotExpectedType, cn(type), cn(t.getClass()));
   }

   /**
    * Returns an assertion against the throwable localized message.
    *
    * <h5 class='section'>Example:</h5>
    * <p class='bjava'>
    *    <jc>// Asserts that the specified method throws an exception with a
    *    // caused-by RuntimeException containing 'foobar'</jc>
    *    ThrowableAssertion.<jsm>assertThrown</jsm>(() -&gt; <jv>foo</jv>.getBar())
    *       .findCausedBy(RuntimeException.<jk>class</jk>)
    *       .isExists()
    *       .asMessage()
    *       .isPattern(<js>"foobar"</js>);
    * </p>
    *
    * @param <X> The throwable type.
    * @param throwableClass The class type to search for in the caused-by chain.
    * @return An assertion against the caused-by throwable.  Never <jk>null</jk>.
    */
   public <X extends Throwable> FluentThrowableAssertion<X,R> asFind(Class<X> throwableClass) {
      Throwable t = orElse(null);
      while (nn(t)) {
         if (throwableClass.isInstance(t))
            return new FluentThrowableAssertion<>(this, throwableClass.cast(t), returns());
         t = t.getCause();
      }
      return new FluentThrowableAssertion<>(this, (X)null, returns());
   }

   /**
    * Returns an assertion against the throwable localized message.
    *
    * <h5 class='section'>Example:</h5>
    * <p class='bjava'>
    *    <jc>// Asserts that the specified method throws an exception with
    *    // 'foobar' somewhere in the localized messages. </jc>
    *    ThrowableAssertion.<jsm>assertThrown</jsm>(() -&gt; <jv>foo</jv>.getBar())
    *       .asLocalizedMessage()
    *       .isPattern(<js>".*foobar.*"</js>);
    * </p>
    *
    * @return An assertion against the throwable localized message.  Never <jk>null</jk>.
    */
   public FluentStringAssertion<R> asLocalizedMessage() {
      return new FluentStringAssertion<>(this, map(Throwable::getLocalizedMessage).orElse(null), returns());
   }

   /**
    * Returns an assertion against the throwable message and all caused-by messages.
    *
    * <h5 class='section'>Example:</h5>
    * <p class='bjava'>
    *    <jc>// Asserts that the specified method throws an exception with
    *    // 'foobar' somewhere in the messages. </jc>
    *    ThrowableAssertion.<jsm>assertThrown</jsm>(() -&gt; <jv>foo</jv>.getBar())
    *       .asLocalizedMessages()
    *       .isPattern(<js>".*foobar.*"</js>);
    * </p>
    *
    * @return An assertion against the throwable message.  Never <jk>null</jk>.
    */
   public FluentListAssertion<String,R> asLocalizedMessages() {
      List<String> l = null;
      Throwable t = orElse(null);
      if (nn(t)) {
         if (t.getCause() == null)
            l = singletonList(t.getMessage());
         else {
            l = list();
            while (nn(t)) {
               l.add(localizedMessage(t));
               t = t.getCause();
            }
         }
      }
      return new FluentListAssertion<>(this, l, returns());
   }

   /**
    * Returns an assertion against the throwable message.
    *
    * <h5 class='section'>Example:</h5>
    * <p class='bjava'>
    *    <jc>// Asserts that the specified method throws an exception
    * // with 'foobar' somewhere in the messages. </jc>
    *    ThrowableAssertion.<jsm>assertThrown</jsm>(() -&gt; <jv>foo</jv>.getBar())
    *       .asMessage()
    *       .isPattern(<js>".*foobar.*"</js>);
    * </p>
    *
    * @return An assertion against the throwable message.  Never <jk>null</jk>.
    */
   public FluentStringAssertion<R> asMessage() {
      return new FluentStringAssertion<>(this, map(Throwable::getMessage).orElse(null), returns());
   }

   /**
    * Returns an assertion against the throwable message and all caused-by messages.
    *
    * <h5 class='section'>Example:</h5>
    * <p class='bjava'>
    *    <jc>// Asserts that the specified method throws an exception with
    *    // 'foobar' somewhere in the messages. </jc>
    *    ThrowableAssertion.<jsm>assertThrown</jsm>(() -&gt; <jv>foo</jv>.getBar())
    *       .asMessages()
    *       .isPattern(<js>".*foobar.*"</js>);
    * </p>
    *
    * @return An assertion against the throwable message.  Never <jk>null</jk>.
    */
   public FluentListAssertion<String,R> asMessages() {
      List<String> l = null;
      Throwable t = orElse(null);
      if (nn(t)) {
         if (t.getCause() == null)
            l = singletonList(t.getMessage());
         else {
            l = list();
            while (nn(t)) {
               l.add(t.getMessage());
               t = t.getCause();
            }
         }
      }
      return new FluentListAssertion<>(this, l, returns());
   }

   /**
    * Returns an assertion against the throwable localized message.
    *
    * <h5 class='section'>Example:</h5>
    * <p class='bjava'>
    *    <jc>// Asserts that the specified method throws an exception with
    *    // 'foobar' somewhere in the stack trace. </jc>
    *    ThrowableAssertion.<jsm>assertThrown</jsm>(() -&gt; <jv>foo</jv>.getBar())
    *       .asStackTrace()
    *       .isPattern(<js>"foobar"</js>);
    * </p>
    *
    * @return An assertion against the throwable stacktrace.  Never <jk>null</jk>.
    */
   public FluentStringListAssertion<R> asStackTrace() {
      return new FluentStringListAssertion<>(this, valueIsNull() ? null : l(getStackTrace(value())), returns());
   }

   @Override /* Overridden from FluentObjectAssertion */
   public FluentThrowableAssertion<T,R> asTransformed(UnaryOperator<T> function) {
      return new FluentThrowableAssertion<>(this, function.apply(orElse(null)), returns());
   }

   /**
    * Asserts that this throwable is exactly the specified type.
    *
    * <h5 class='section'>Example:</h5>
    * <p class='bjava'>
    *    <jc>// Asserts that the specified method throws a RuntimeException. </jc>
    *    ThrowableAssertion.<jsm>assertThrown</jsm>(() -&gt; <jv>foo</jv>.getBar())
    *       .isExactType(RuntimeException.<jk>class</jk>);
    * </p>
    *
    * @param type The type.
    * @return The fluent return object.
    */
   @Override
   public R isExactType(Class<?> type) {
      reqnn("type", type);
      if (type != value().getClass())
         throw error(MSG_exceptionWasNotExpectedType, cn(type), cn(value()));
      return returns();
   }

   /**
    * Asserts that this throwable exists.
    *
    * <h5 class='section'>Example:</h5>
    * <p class='bjava'>
    *    <jc>// Asserts that the specified method throws any exception.</jc>
    *    ThrowableAssertion.<jsm>assertThrown</jsm>(() -&gt; <jv>foo</jv>.getBar()).isExists();
    * </p>
    *
    * @return The fluent return object.
    */
   @Override
   public R isExists() {
      if (valueIsNull())
         throw error(MSG_exceptionWasNotThrown);
      return returns();
   }

   /**
    * Asserts that this throwable is of the specified type.
    *
    * <h5 class='section'>Example:</h5>
    * <p class='bjava'>
    *    <jc>// Asserts that the specified method throws a RuntimeException. </jc>
    *    ThrowableAssertion.<jsm>assertThrown</jsm>(() -&gt; <jv>foo</jv>.getBar())
    *       .isType(RuntimeException.<jk>class</jk>);
    * </p>
    *
    * @param parent The type.
    * @return The fluent return object.
    */
   @Override
   public R isType(Class<?> parent) {
      reqnn("parent", parent);
      if (! parent.isInstance(value()))
         throw error(MSG_exceptionWasNotExpectedType, cn(parent), cn(value()));
      return returns();
   }

   @Override /* Overridden from Assertion */
   public FluentThrowableAssertion<T,R> setMsg(String msg, Object...args) {
      super.setMsg(msg, args);
      return this;
   }

   @Override /* Overridden from Assertion */
   public FluentThrowableAssertion<T,R> setOut(PrintStream value) {
      super.setOut(value);
      return this;
   }

   @Override /* Overridden from Assertion */
   public FluentThrowableAssertion<T,R> setSilent() {
      super.setSilent();
      return this;
   }

   @Override /* Overridden from Assertion */
   public FluentThrowableAssertion<T,R> setStdOut() {
      super.setStdOut();
      return this;
   }

   @Override /* Overridden from Assertion */
   public FluentThrowableAssertion<T,R> setThrowable(Class<? extends RuntimeException> value) {
      super.setThrowable(value);
      return this;
   }

   @Override
   protected boolean equals(Object o1, Object o2) {
      if (o1 instanceof Throwable o1t && o2 instanceof Throwable o2t)
         return eq(o1t, o2t, (x, y) -> eq(x.getClass(), y.getClass()) && eq(x.getMessage(), y.getMessage()));
      return super.equals(o1, o2);
   }
}