/*
 * 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.server.rrpc;

import static org.apache.juneau.commons.utils.Shorts.*;
import static org.apache.juneau.commons.utils.StringUtils.*;

import java.io.*;
import java.lang.reflect.Method;

import org.apache.juneau.http.*;
import org.apache.juneau.http.remote.*;
import org.apache.juneau.http.response.*;
import org.apache.juneau.marshall.parser.*;
import org.apache.juneau.rest.server.*;

/**
 * A session for a single HTTP request against an RRPC Java method.
 *
 * <h5 class='section'>Notes:</h5><ul>
 *    <li class='warn'>This class is not thread safe.
 * </ul>
 *
 * <h5 class='section'>See Also:</h5><ul>
 *    <li class='link'><a class="doclink" href="https://juneau.apache.org/docs/topics/RestRpc">REST/RPC</a>
 * </ul>
 */
@SuppressWarnings({
   "java:S1192", // Duplicated literals (argument/property names) read more clearly inline than as constants
   "resource" // Resource management handled externally
})
public class RrpcRestOpSession extends RestOpSession {

   /**
    * Builder class.
    */
   public static class Builder extends RestOpSession.Builder {

      private final RrpcRestOpContext ctx2;

      /**
       * Constructor.
       *
       * @param ctx The context object of the RRPC Java method.
       *    <br>Cannot be <jk>null</jk>.
       * @param session The REST session.
       *    <br>Cannot be <jk>null</jk>.
       */
      public Builder(RrpcRestOpContext ctx, RestSession session) {
         super(reqnn("ctx", ctx), reqnn("session", session));
         this.ctx2 = ctx;
      }

      @Override
      public RrpcRestOpSession build() {
         return new RrpcRestOpSession(this);
      }

   }

   /**
    * Static creator.
    *
    * @param ctx The context of the RRPC Java Method.
    *    <br>Cannot be <jk>null</jk>.
    * @param session The REST session creating this session.
    *    <br>Cannot be <jk>null</jk>.
    * @return A new builder.
    */
   public static Builder create(RrpcRestOpContext ctx, RestSession session) {
      return new Builder(reqnn("ctx", ctx), reqnn("session", session));

   }

   private final RrpcRestOpContext ctx;

   /**
    * Constructor.
    *
    * @param builder The builder for this object.
    *    <br>Cannot be <jk>null</jk>.
    */
   protected RrpcRestOpSession(Builder builder) {
      super(builder);
      ctx = builder.ctx2;
   }

   @Override /* Overridden from RestOpSession */
   public RrpcRestOpSession finish() {
      super.finish();
      return this;
   }

   @Override
   @SuppressWarnings({
      "java:S3776" // Cognitive complexity acceptable for RRPC request handling
   })
   public void run() throws Exception {

      super.run();

      RestRequest req = getRequest();
      RestResponse res = getResponse();
      RestSession session = getRestSession();

      final Object o = res.hasContent() ? res.getContent(Object.class) : null;

      if (eq(session.getMethod(), "GET")) {
         res.setContent(ctx.getMeta().getMethodsByPath().keySet());
         return;

      } else if (eq(session.getMethod(), "POST")) {
         // The method-signature path is whatever remains of the URL below this operation's matched path
         // pattern (e.g. pattern "/calc/*" matched against "/calc/add/(int,int)" leaves "add/(int,int)"),
         // NOT merely the last '/'-delimited segment of the full request path. A method-signature path
         // itself contains a '/' (name/(paramTypes)), so truncating at the last slash strips the method
         // name and leaves only the parameter-type token, which can never match a registered method path.
         var match = session.getUrlPathMatch();
         var pip = urlDecode(emptyIfNull(nn(match) ? match.getRemainder() : null));
         RrpcInterfaceMethodMeta rmm = ctx.getMeta().getMethodMetaByPath(pip);
         if (nn(rmm)) {
            Method m = rmm.getJavaMethod();
            try {
               // Parse the args and invoke the method.
               var parserMatchOpt = req.getContent().getParserMatch();
               if (!parserMatchOpt.isPresent())
                  throw new BadRequest("No parser match found for request content");
               Parser p = parserMatchOpt.get().getParser();
               Object[] args = null;
               if (m.getGenericParameterTypes().length == 0)
                  args = new Object[0];
               else {
                  try (Closeable in = p.isReaderParser() ? req.getReader() : req.getInputStream()) {
                     args = p.readArgs(in, m.getGenericParameterTypes());
                  }
               }
               res.setContent(m.invoke(o, args));
               return;
            } catch (BasicHttpException e) {
               throw e;
            } catch (Exception e) {
               throw new InternalServerError(e);
            }
         }
      }
      throw new NotFound();
   }

   @Override /* Overridden from RestOpSession */
   public RrpcRestOpSession status(HttpStatusLine value) {
      super.status(value);
      return this;
   }
}