//
// Copyright 2018 Google Inc.
//
// 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.
//

#import "Service/Sources/EDOObject.h"

#include <objc/runtime.h>

#import "Service/Sources/EDOBlockObject.h"
#import "Service/Sources/EDOClientService+Private.h"
#import "Service/Sources/EDOClientService.h"
#import "Service/Sources/EDOHostService+Private.h"
#import "Service/Sources/EDOHostService.h"
#import "Service/Sources/EDOInvocationMessage.h"
#import "Service/Sources/EDOMethodSignatureMessage.h"
#import "Service/Sources/EDOObject+Private.h"
#import "Service/Sources/EDOParameter.h"
#import "Service/Sources/EDORemoteException.h"
#import "Service/Sources/EDOServicePort.h"
#import "Service/Sources/EDOServiceRequest.h"

static EDORemoteException *RemoteExceptionWithLocalInformation(EDORemoteException *remoteException,
                                                               EDOObject *target,
                                                               NSInvocation *invocation) {
  NSArray<NSString *> *currentStackTraces = [NSThread callStackSymbols];
  NSUInteger eDOStackIndex = [currentStackTraces
      indexOfObjectPassingTest:^BOOL(NSString *item, NSUInteger idx, BOOL *stop) {
        return [item containsString:@"_CF_forwarding_prep_0"];
      }];
  // If the pattern symbol of eDO entrance is not found, we keep the whole eDO stacks, but we still
  // remove the symbol of this helper C function.
  if (eDOStackIndex == NSNotFound) {
    eDOStackIndex = 0;
  }
  NSArray<NSString *> *localOutputStackTraces = [currentStackTraces
      subarrayWithRange:NSMakeRange(eDOStackIndex + 1,
                                    currentStackTraces.count - eDOStackIndex - 1)];
  NSString *classInfo;
  NSString *methodInfo;
  if (object_getClass(target) == [EDOBlockObject class]) {
    classInfo = @"__block_invoke";
    methodInfo = ((EDOBlockObject *)target).signature;
  } else {
    classInfo = target.className;
    methodInfo = NSStringFromSelector(invocation.selector);
  }
  NSString *separationSymbol =
      [NSString stringWithFormat:@"|---- eDO invocation [%@ %@] ----|", classInfo, methodInfo];

  NSMutableArray<NSString *> *fullStackTraces = [remoteException.callStackSymbols mutableCopy];
  [fullStackTraces addObject:separationSymbol];
  [fullStackTraces addObjectsFromArray:localOutputStackTraces];
  return [[EDORemoteException alloc] initWithName:remoteException.name
                                           reason:remoteException.reason
                                 callStackSymbols:fullStackTraces];
}

// The cache of the instance method signatures.
static NSCache<NSString *, NSMethodSignature *> *gEDOInstanceMethodSignatureCache;

/**
 * Builds the key for the instance method signature cache.
 *
 * @param selector The selector.
 * @param className The class name.
 * @return The key.
 */
static NSString *EDOCreateMethodSignatureCacheKey(SEL selector, NSString *className) {
  return [NSString stringWithFormat:@"%@-%@", className, NSStringFromSelector(selector)];
}

/**
 * Gets the instance method signature for the given selector and class name from the cache.
 *
 * @param selector The selector.
 * @param className The class name.
 * @return The instance method signature.
 */
static NSMethodSignature *EDOInstanceMethodSignatureForSelector(SEL selector, NSString *className) {
  NSString *key = EDOCreateMethodSignatureCacheKey(selector, className);
  NSMethodSignature *methodSignature = [gEDOInstanceMethodSignatureCache objectForKey:key];
  return methodSignature;
}

/**
 * Adds the instance method signature for the given selector and class name to the cache.
 *
 * @param methodSignature The method signature.
 * @param selector The selector.
 * @param className The class name.
 */
static void EDOAddInstanceMethodSignature(NSMethodSignature *methodSignature, SEL selector,
                                          NSString *className) {
  NSString *key = EDOCreateMethodSignatureCacheKey(selector, className);
  [gEDOInstanceMethodSignatureCache setObject:methodSignature forKey:key];
}

/**
 * The extension of EDOObject to handle the message forwarding.
 *
 * When a method is not implemented, the objc runtime executes a sequence of events to recover
 * before it sends doesNotRecognizeSelector: or raises an exception. It requests an
 * NSMethodSignature using -/+methodSignatureForSelector:, which bundles with arguments types and
 * return type information. And from there, it creates an NSInvocation object which captures the
 * full message being sent, including the target, the selector and all the arguments. After this,
 * the runtime invokes -/+forwardInvocation: method and here it serializes all the arguments and
 * sends it across the wire; once it returns, it sets its return value back to the NSInvocation
 * object. This allows us dynamically to turn a local invocation into a remote invocation.
 *
 */
@implementation EDOObject (Invocation)

+ (void)initialize {
  if (self == [EDOObject class]) {
    gEDOInstanceMethodSignatureCache = [[NSCache alloc] init];
  }
}

/**
 * Get an instance method signature for the @c EDOObject
 *
 * This is called from the callee's thread and it is synchronous.
 *
 * @param selector The selector.
 *
 * @return         The instance method signature.
 */
- (NSMethodSignature *)methodSignatureForSelector:(SEL)selector {
  NSString *className = self.className;
  NSMethodSignature *signature = EDOInstanceMethodSignatureForSelector(selector, className);
  if (signature) {
    return signature;
  }
  EDOServiceRequest *request = [EDOMethodSignatureRequest requestWithObject:self.remoteAddress
                                                                       port:self.servicePort
                                                                   selector:selector];
  EDOMethodSignatureResponse *response = (EDOMethodSignatureResponse *)[EDOClientService
      sendSynchronousRequest:request
                      onPort:self.servicePort.hostPort];
  NSString *signatureString = response.signature;
  if (signatureString) {
    signature = [NSMethodSignature signatureWithObjCTypes:signatureString.UTF8String];
    EDOAddInstanceMethodSignature(signature, selector, className);
  }
  return signature;
}

/** Forwards the invocation to the remote. */
- (void)forwardInvocation:(NSInvocation *)invocation {
  [self edo_forwardInvocation:invocation selector:invocation.selector returnByValue:NO];
}

- (void)edo_forwardInvocation:(NSInvocation *)invocation
                     selector:(SEL)selector
                returnByValue:(BOOL)returnByValue {
  // Keep the service until the end of the invocation scope so the nested remote call can be made
  // using this service.
  NS_VALID_UNTIL_END_OF_SCOPE EDOHostService *service =
      [EDOHostService serviceForCurrentOriginatingQueue];
  BOOL useTemporaryService = NO;

  // If there is no host service created for the current queue, a temporary queue is created only
  // within this invocation scope.
  if (!service) {
    service = [EDOHostService temporaryServiceForCurrentThread];
    useTemporaryService = YES;
  }

  EDOInvocationRequest *request = [EDOInvocationRequest requestWithInvocation:invocation
                                                                       target:self
                                                                     selector:selector
                                                                returnByValue:returnByValue
                                                                      service:service];

  EDOExecutor *executor = [EDOHostService serviceForCurrentExecutingQueue].executor;

  // If we create a temp service, use it as the executor.
  if (useTemporaryService && service.valid) {
    NSAssert(!executor, @"The executor from the temporary service is conflicting with the executor "
                        @"from the executing queue.");
    executor = service.executor;
  }

  EDOInvocationResponse *response =
      (EDOInvocationResponse *)[EDOClientService sendSynchronousRequest:request
                                                                 onPort:self.servicePort.hostPort
                                                           withExecutor:executor];

  if (response.exception) {
    // Populate the exception.
    // Note: we throw here rather than -[raise] because we can't make an assumption of what user's
    //       code will throw.
    @throw RemoteExceptionWithLocalInformation(response.exception, self, invocation);  // NOLINT
  }

  NSUInteger returnBufSize = invocation.methodSignature.methodReturnLength;
  char const *ctype = invocation.methodSignature.methodReturnType;
  if (EDO_IS_OBJECT_OR_CLASS(ctype)) {
    id __unsafe_unretained obj;
    [response.returnValue getValue:&obj];
    obj = [EDOClientService unwrappedObjectFromObject:obj];
    obj = [EDOClientService cachedEDOFromObjectUpdateIfNeeded:obj];
    [invocation setReturnValue:&obj];

    // ARC will insert a -release on the return if the method returns a retained object, but because
    // we build the invocation dynamically, the return is not retained, we insert an extra retain
    // here to compensate ARC.
    if (response.returnRetained) {
      CFBridgingRetain(obj);
    }
  } else if (returnBufSize > 0) {
    char *const returnBuf = calloc(returnBufSize, sizeof(char));
    [response.returnValue getValue:returnBuf];
    [invocation setReturnValue:returnBuf];
    free(returnBuf);
  }

  NSArray<EDOBoxedValueType *> *outValues = response.outValues;
  if (outValues.count > 0) {
    NSMethodSignature *method = invocation.methodSignature;
    NSUInteger numOfArgs = method.numberOfArguments;
    for (NSUInteger curArgIdx = selector ? 2 : 1, curOutIdx = 0; curArgIdx < numOfArgs;
         ++curArgIdx) {
      char const *ctype = [method getArgumentTypeAtIndex:curArgIdx];
      if (!EDO_IS_OBJPOINTER(ctype)) {
        continue;
      }

      id __unsafe_unretained *obj;
      [invocation getArgument:&obj atIndex:curArgIdx];

      // Fill the out value back to its original buffer if provided.
      if (obj) {
        [outValues[curOutIdx] getValue:obj];
        *obj = [EDOClientService unwrappedObjectFromObject:*obj];
        // When there is no running service or the object is a true remote object, we will check
        // the local distant objects cache.
        *obj = [EDOClientService cachedEDOFromObjectUpdateIfNeeded:*obj];
      }

      ++curOutIdx;
    }
  }
}

@end