/*
 * 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.rest.mock;

import static org.apache.juneau.commons.utils.Shorts.*;
import static org.apache.juneau.rest.server.util.RestUtils.*;

import java.io.*;
import java.util.*;
import java.util.concurrent.*;
import java.util.logging.*;

import org.apache.juneau.commons.inject.*;
import org.apache.juneau.http.header.NoTrace;
import org.apache.juneau.marshall.json.*;
import org.apache.juneau.marshall.parser.*;
import org.apache.juneau.rest.client.*;
import org.apache.juneau.rest.client.RestRequest;
import org.apache.juneau.rest.server.*;
import org.apache.juneau.rest.server.logging.*;

import jakarta.servlet.*;

/**
 * Next-generation mock REST client that routes requests in-process to a Juneau {@link RestContext}.
 *
 * <p>
 * Use this class to write serverless unit tests for {@link Rest @Rest}-annotated
 * resource classes.  Requests are dispatched directly to the {@link RestContext} without any network activity,
 * making tests fast and self-contained.
 *
 * <h5 class='section'>Example:</h5>
 * <p class='bjava'>
 *    <ja>@Rest</ja>
 *    <jk>public class</jk> MyResource {
 *       <ja>@RestGet</ja>(<js>"/hello"</js>)
 *       <jk>public</jk> String hello() { <jk>return</jk> <js>"Hello!"</js>; }
 *    }
 *
 *    <ja>@Test</ja>
 *    <jk>void</jk> test() <jk>throws</jk> Exception {
 *       <jk>try</jk> (<jv>client</jv> = MockRestClient.<jsm>create</jsm>(MyResource.<jk>class</jk>)) {
 *          var <jv>body</jv> = <jv>client</jv>.get(<js>"/hello"</js>).run().asString();
 *          assertEquals(<js>"\"Hello!\""</js>, <jv>body</jv>);
 *       }
 *    }
 * </p>
 *
 * <h5 class='section'>See Also:</h5><ul>
 *    <li class='link'><a class="doclink" href="https://juneau.apache.org/docs/topics/NextGenRestClient">Next-Generation REST Client</a>
 * </ul>
 *
 * @since 9.2.1
 */
@SuppressWarnings({
   "resource" // RestClient is closed by MockRestClient.close(); transport is owned by the client
})
public final class MockRestClient implements Closeable {

   private static final Map<Class<?>,RestContext> restContextCache = new ConcurrentHashMap<>();

   private final RestClient client;

   private MockRestClient(RestClient client) {
      this.client = client;
   }

   /**
    * Creates an {@link MockRestClient} backed by the given REST bean or bean class.
    *
    * <p>
    * {@link RestContext} instances are cached per class for performance when a {@link Class} is passed;
    * a supplied bean instance always gets its own context.
    *
    * @param impl
    *    The REST bean or bean class annotated with {@link Rest @Rest}.
    *    If a {@link Class}, it must have a no-arg constructor.
    * @return A new client. Never <jk>null</jk>.
    */
   public static MockRestClient create(Object impl) {
      return builder(impl).build();
   }

   /**
    * Returns a new {@link Builder} for the given REST bean or bean class.
    *
    * @param impl
    *    The REST bean or bean class annotated with {@link Rest @Rest}.
    *    If a {@link Class}, it must have a no-arg constructor.
    * @return A new builder. Never <jk>null</jk>.
    */
   public static Builder builder(Object impl) {
      return new Builder(impl);
   }

   /**
    * Creates a GET request to the given path.
    *
    * @param path The request path (relative to the resource's servlet path). Must not be <jk>null</jk>.
    * @return A new {@link RestRequest}. Never <jk>null</jk>.
    */
   public RestRequest get(String path) { return client.get(path); }

   /**
    * Creates a POST request to the given path.
    *
    * @param path The request path. Must not be <jk>null</jk>.
    * @return A new {@link RestRequest}. Never <jk>null</jk>.
    */
   public RestRequest post(String path) { return client.post(path); }

   /**
    * Creates a PUT request to the given path.
    *
    * @param path The request path. Must not be <jk>null</jk>.
    * @return A new {@link RestRequest}. Never <jk>null</jk>.
    */
   public RestRequest put(String path) { return client.put(path); }

   /**
    * Creates a PATCH request to the given path.
    *
    * @param path The request path. Must not be <jk>null</jk>.
    * @return A new {@link RestRequest}. Never <jk>null</jk>.
    */
   public RestRequest patch(String path) { return client.patch(path); }

   /**
    * Creates a DELETE request to the given path.
    *
    * @param path The request path. Must not be <jk>null</jk>.
    * @return A new {@link RestRequest}. Never <jk>null</jk>.
    */
   public RestRequest delete(String path) { return client.delete(path); }

   /**
    * Creates a HEAD request to the given path.
    *
    * @param path The request path. Must not be <jk>null</jk>.
    * @return A new {@link RestRequest}. Never <jk>null</jk>.
    */
   public RestRequest head(String path) { return client.head(path); }

   /**
    * Creates a request with the given HTTP method and path.
    *
    * @param method The HTTP method. Must not be <jk>null</jk>.
    * @param path The request path. Must not be <jk>null</jk>.
    * @return A new {@link RestRequest}. Never <jk>null</jk>.
    */
   public RestRequest request(String method, String path) { return client.request(method, path); }

   /**
    * Returns the underlying {@link RestClient}.
    *
    * @return The client. Never <jk>null</jk>.
    */
   public RestClient getClient() { return client; }

   @Override /* Closeable */
   public void close() throws IOException {
      client.close();
   }

   // -----------------------------------------------------------------------------------------------------------------
   // Inner types
   // -----------------------------------------------------------------------------------------------------------------

   /**
    * Fluent builder for {@link MockRestClient}.
    *
    * @since 9.2.1
    */
   public static final class Builder implements BeanStoreOverridable<Builder> {

      private final Object impl;
      private String contextPath;
      private BeanStore overridingBeanStore;
      private Parser defaultParser;
      private boolean noTrace;

      private Builder(Object impl) {
         this.impl = impl;
      }

      /**
       * Sets the servlet context path (e.g. {@code "/myapp"}).
       *
       * @param value The context path. May be <jk>null</jk>.
       * @return This object.
       */
      public Builder contextPath(String value) {
         contextPath = toValidContextPath(value);
         return this;
      }

      /**
       * Installs a {@link BeanStore} as the {@code overridingParent} of the {@link RestContext}'s
       * bean store, so test-time overrides (e.g. {@code TestBeanStore}) resolve at tier 1 of the
       * lookup chain &mdash; above the resource's local {@code @Bean} factory entries.
       *
       * <p>
       * Setting this disables the per-resource {@link RestContext} cache for the duration of this
       * build, so the overlay is not silently shared with a previously-cached instance.
       *
       * <h5 class='section'>Example:</h5>
       * <p class='bjava'>
       *    <jk>var</jk> <jv>overlay</jv> = <jk>new</jk> TestBeanStore().override(MyService.<jk>class</jk>, mockSvc);
       *    <jk>try</jk> (<jv>client</jv> = MockRestClient.<jsm>builder</jsm>(MyResource.<jk>class</jk>)
       *          .overridingBeanStore(<jv>overlay</jv>)
       *          .build()) {
       *       <jv>client</jv>.get(<js>"/widgets/1"</js>).run().assertStatus().is(200);
       *    }
       * </p>
       *
       * @param value The override layer. Can be <jk>null</jk> to clear a previously-set value.
       * @return This object.
       *
       * @since 10.0.0
       */
      @Override
      public Builder overridingBeanStore(BeanStore value) {
         overridingBeanStore = value;
         return this;
      }

      /**
       * Sets an explicit default parser used when the response {@code Content-Type} matches no registered parser.
       *
       * <p>
       * Setting this also causes the client to advertise the parser's media types in the {@code Accept} header,
       * so the server must be able to produce that content type.  Omit this (the default) when the target
       * resource does not have a JSON serializer configured.
       *
       * <h5 class='section'>Example:</h5>
       * <p class='bjava'>
       *    <jk>try</jk> (<jv>client</jv> = MockRestClient.<jsm>builder</jsm>(MyJsonResource.<jk>class</jk>)
       *          .defaultParser(JsonParser.<jsf>DEFAULT</jsf>)
       *          .build()) {
       *       <jk>var</jk> <jv>api</jv> = <jv>client</jv>.getClient().remote(MyApi.<jk>class</jk>);
       *       <jv>api</jv>.someMethod();
       *    }
       * </p>
       *
       * @param value The parser. May be <jk>null</jk>.
       * @return This object.
       */
      public Builder defaultParser(Parser value) {
         defaultParser = value;
         return this;
      }

      /**
       * Sends a <c>No-Trace: true</c> header with every request, so the server leaves the stack trace of a failed
       * call out of its log record.
       *
       * <p>
       * Opt-in only; no other builder option turns it on. The one-line access record is still logged.  To do the
       * same for a single call, use {@link RestRequest#noTrace()}.
       *
       * <h5 class='section'>Example:</h5>
       * <p class='bjava'>
       *    <jk>try</jk> (<jv>client</jv> = MockRestClient.<jsm>builder</jsm>(MyResource.<jk>class</jk>).noTrace().build()) {
       *       <jv>client</jv>.get(<js>"/missing"</js>).run().assertStatus().is(404);
       *    }
       * </p>
       *
       * @return This object.
       */
      public Builder noTrace() {
         noTrace = true;
         return this;
      }

      /**
       * Builds and returns the {@link MockRestClient}.
       *
       * @return A new instance. Never <jk>null</jk>.
       */
      @SuppressWarnings({
         "java:S112" // Re-wrap as RuntimeException - build() wraps arbitrary checked exceptions from reflection (newInstance) and RestContext init/postInit; no specific type fits and the fluent build() method cannot declare checked exceptions.
      })
      public MockRestClient build() {
         try {
            var isClass = impl instanceof Class<?>;
            var overlay = overridingBeanStore;
            // Only class-based contexts are cached; a caller-supplied instance always gets its own context.
            var cacheable = isClass && overlay == null;
            RestContext restContext = cacheable ? restContextCache.get(impl) : null;
            if (restContext == null) {
               var o = isClass ? ((Class<?>)impl).getDeclaredConstructor().newInstance() : impl;
               restContext = new RestContext(new RestContext.Args(o.getClass(), null, null, () -> o, "", bs -> {
                  bs.addBeanType(RestDebugFormatter.class, BasicTestRestDebugFormatter.class);
               }, overlay, null, RestContext.ContextKind.ROOT)).postInit().postInitChildFirst();
               if (cacheable)
                  restContextCache.put((Class<?>)impl, restContext);
            }

            var servletPath = toValidContextPath(restContext.getFullPath());
            var fullContextPath = emptyIfNull(contextPath) + emptyIfNull(servletPath);

         var transport = new JuneauRestTransport(restContext, emptyIfNull(contextPath), servletPath);
         var clientBuilder = RestClient.builder()
            .transport(transport)
            .rootUrl("http://localhost" + fullContextPath)
            .defaultSerializer(JsonSerializer.DEFAULT);
         if (defaultParser != null)
            clientBuilder.defaultParser(defaultParser);
         if (noTrace)
            clientBuilder.header(NoTrace.NAME, "true");
         var ngClient = clientBuilder.build();

            return new MockRestClient(ngClient);
         } catch (Exception e) {
            throw rex(e, "Could not initialize MockRestClient");
         }
      }

      private static String emptyIfNull(String s) { return s == null ? "" : s; }
   }

   // -----------------------------------------------------------------------------------------------------------------
   // Transport implementation
   // -----------------------------------------------------------------------------------------------------------------

   /**
    * An {@link HttpTransport} that dispatches requests in-process through a Juneau {@link RestContext}.
    */
   private static final class JuneauRestTransport implements HttpTransport {

      private final RestContext restContext;
      private final Object restObject;
      private final String contextPath;
      private final String servletPath;

      JuneauRestTransport(RestContext restContext, String contextPath, String servletPath) {
         this.restContext = restContext;
         this.restObject = restContext.getResource();
         this.contextPath = contextPath;
         this.servletPath = servletPath;
      }

      @Override /* HttpTransport */
      public boolean supportsUrlPolicy() {
         // Requests are dispatched in-process, directly to the RestContext -- there is no real DNS resolution or
         // socket connect to pin-on-connect, so the "cannot honor the connect-time contract" fail-closed
         // rationale does not apply. The deny-private lexical pre-check (RemoteUrlPolicy.requireAllowedUrl)
         // still runs upstream in the @Remote proxy engine before any request reaches this transport, and this
         // class's own "http://localhost" root (see MockRestClient.Builder.build()) is never re-checked by that
         // pre-check -- only an explicit absolute @Url/baseUrl() override on the proxy interface is.
         return true;
      }

      @Override /* HttpTransport */
      public TransportResponse execute(TransportRequest request) throws TransportException {
         if (request.isSsrfGuardActive())
            return PolicyEnforcedRedirects.execute(request, this::dispatch);
         return dispatch(request);
      }

      private TransportResponse dispatch(TransportRequest request) throws TransportException {
         try {
            var method = request.getMethod();
            var uri = request.getUri().toString();

            var servletReq = MockServletRequest.create(method, uri)
               .servletPath(servletPath)
               .contextPath(contextPath);

            for (var h : request.getHeaders())
               servletReq.header(h.name(), h.value());

            var body = request.getBody();
            if (body != null) {
               var baos = new ByteArrayOutputStream();
               body.writeTo(baos);
               servletReq.content(baos.toByteArray());
            }

            var servletRes = MockServletResponse.create();

            var logLevel = servletReq.getLogLevel();
            if (logLevel != null) {
               var target = Logger.getLogger(restObject.getClass().getName());
               var prevLevel = target.getLevel();
               target.setLevel(logLevel);
               try {
                  restContext.execute(restObject, servletReq, servletRes);
               } finally {
                  target.setLevel(prevLevel);
               }
            } else {
               restContext.execute(restObject, servletReq, servletRes);
            }

            var responseBuilder = TransportResponse.builder()
               .statusCode(servletRes.getStatus())
               .reasonPhrase(servletRes.getMessage());

            for (var name : servletRes.getHeaderNames())
               for (var value : servletRes.getHeaders(name))
                  responseBuilder.header(name, value);

            var content = servletRes.getContent();
            if (content.length > 0)
               responseBuilder.body(new ByteArrayInputStream(content));

            return responseBuilder.build();

         } catch (TransportException e) {
            throw e;
         } catch (ServletException | IOException e) {
            throw new TransportException("In-process dispatch failed: " + e.getMessage(), e);
         }
      }
   }
}