- (void)addKvLogAspect {
    [self wr_Aspect_hookSelector:@selector(viewWillAppear:) withOptions:AspectPositionAfter usingBlock:^{
        KVLog_ReviewTimeline(ReviewTimeline_Open_Tab);
    }error:NULL];
}

+ (id<AspectToken>)aspect_hookSelector:(SEL)selector
                           withOptions:(AspectOptions)options
                            usingBlock:(id)block
                                 error:(NSError **)error;

/// Adds a block of code before/instead/after the current `selector` for a specific instance.
- (id<AspectToken>)aspect_hookSelector:(SEL)selector
                           withOptions:(AspectOptions)options
                            usingBlock:(id)block
                                 error:(NSError **)error;

typedef NS_OPTIONS(NSUInteger, AspectOptions) {
    AspectPositionAfter   = 0,            /// Called after the original implementation (default)
    AspectPositionInstead = 1,            /// Will replace the original implementation.
    AspectPositionBefore  = 2,            /// Called before the original implementation.
    AspectOptionAutomaticRemoval = 1 << 3 /// Will remove the hook after the first execution.
};

// Tracks all aspects for an object/class.
@interface AspectsContainer : NSObject
- (void)addAspect:(AspectIdentifier *)aspect withOptions:(AspectOptions)injectPosition;
- (BOOL)removeAspect:(id)aspect;
- (BOOL)hasAspects;
@property (atomic, copy) NSArray *beforeAspects;
@property (atomic, copy) NSArray *insteadAspects;
@property (atomic, copy) NSArray *afterAspects;
@end

@interface AspectIdentifier : NSObject
+ (instancetype)identifierWithSelector:(SEL)selector object:(id)object options:(AspectOptions)options block:(id)block error:(NSError **)error;
- (BOOL)invokeWithInfo:(id<AspectInfo>)info;
@property (nonatomic, assign) SEL selector;
@property (nonatomic, strong) id block;
@property (nonatomic, strong) NSMethodSignature *blockSignature;
@property (nonatomic, weak) id object;
@property (nonatomic, assign) AspectOptions options;
@end

@interface AspectInfo : NSObject <AspctInfo>
- (id)initWithInstance:(__unsafe_unretained id)instance invocation:(NSInvocation *)invocation;
@property (nonatomic, unsafe_unretained, readonly) id instance;
@property (nonatomic, strong, readonly) NSArray *arguments;
@property (nonatomic, strong, readonly) NSInvocation *originalInvocation;
@end

static id aspect_add(id self, SEL selector, AspectOptions options, id block, NSError **error) {
    ...
    __block AspectIdentifier *identifier = nil;
    aspect_performLocked(^{
        if (aspect_isSelectorAllowedAndTrack(self, selector, options, error)) {//1判断能否hook
            ...//2 记录数据结构
            aspect_prepareClassAndHookSelector(self, selector, error);//3 swizzling
        }
    });
    return identifier;
}

static void aspect_prepareClassAndHookSelector(NSObject *self, SEL selector, NSError **error) {
    Class klass = aspect_hookClass(self, error); //1  swizzling forwardInvocation
    Method targetMethod = class_getInstanceMethod(klass, selector);
    IMP targetMethodIMP = method_getImplementation(targetMethod);
    if (!aspect_isMsgForwardIMP(targetMethodIMP)) {//2  swizzling method
       ...//
    }
}

static Class aspect_hookClass(NSObject *self, NSError **error) {
     ...
     //生成动态子类，并swizzling forwardInvocation方法
     subclass = objc_allocateClassPair(baseClass, subclassName, 0); 
     aspect_swizzleForwardInvocation(subclass);//swizzling forwardinvation方法

     objc_registerClassPair(subclass);
      ...
     object_setClass(self, subclass);//将当前self设置为子类，这里其实只是更改了self的isa指针而已
     return subclass;
}
...
static void aspect_swizzleForwardInvocation(Class klass) {
     ...
    IMP originalImplementation = class_replaceMethod(klass, @selector(forwardInvocation:),     (IMP)__ASPECTS_ARE_BEING_CALLED__, "v@:@");
    if (originalImplementation) {
         class_addMethod(klass, NSSelectorFromString(AspectsForwardInvocationSelectorName),        originalImplementation, "v@:@")
      }
...
}

static void aspect_prepareClassAndHookSelector(NSObject *self, SEL selector, NSError **error) {
     ...
     Method targetMethod = class_getInstanceMethod(klass, selector);
     IMP targetMethodIMP = method_getImplementation(targetMethod);
     if (!aspect_isMsgForwardIMP(targetMethodIMP)) {
     ...
     SEL aliasSelector = aspect_aliasForSelector(selector);//generator aliasSelector
     if (![klass instancesRespondToSelector:aliasSelector]) {
          __unused BOOL addedAlias = class_addMethod(klass, aliasSelector, method_getImplementation(targetMethod), typeEncoding); 
     }
     class_replaceMethod(klass, selector, aspect_getMsgForwardIMP(self, selector), typeEncoding);// point to   _objc_msgForward
   ...
     }
}

static void __ASPECTS_ARE_BEING_CALLED__(__unsafe_unretained NSObject *self, SEL selector, NSInvocation *invocation) {
...
     // Before hooks.  原来逻辑之前执行
    aspect_invoke(classContainer.beforeAspects, info);
    aspect_invoke(objectContainer.beforeAspects, info);
    // Instead hooks.
    BOOL respondsToAlias = YES;
    if (objectContainer.insteadAspects.count || classContainer.insteadAspects.count) {//是否需要替换掉原来的路基
         aspect_invoke(classContainer.insteadAspects, info);
         aspect_invoke(objectContainer.insteadAspects, info);
    } else {
        Class klass = object_getClass(invocation.target);
        do {
              if ((respondsToAlias = [klass instancesRespondToSelector:aliasSelector])) {
                    [invocation invoke];//根据aliasSelector找到原来的逻辑并执行
                    break;
                }
            }while (!respondsToAlias && (klass = class_getSuperclass(klass)));
     }

    // After hooks.  原来逻辑之后执行
     aspect_invoke(classContainer.afterAspects, info);
     aspect_invoke(objectContainer.afterAspects, info);

    // If no hooks are installed, call original implementation (usually to throw an exception)
     if (!respondsToAlias) {//找不到aliasSelector的IMP实现，没有找到原来的逻辑，进行消息转发
          invocation.selector = originalSelector;
          SEL originalForwardInvocationSEL = NSSelectorFromString(AspectsForwardInvocationSelectorName);
          if ([self respondsToSelector:originalForwardInvocationSEL]) {
               ((void( *)(id, SEL, NSInvocation *))objc_msgSend)(self, originalForwardInvocationSEL, invocation);
          } else {
              [self doesNotRecognizeSelector:invocation.selector];
         }
     }                     
...
}

static Class aspect_hookClass(NSObject *self, NSError **error) {
    ...
   subclass = objc_allocateClassPair(baseClass, subclassName, 0);
   ...
   IMP originalImplementation = class_replaceMethod(subclass, @selector(forwardInvocation:), (IMP)__ASPECTS_ARE_BEING_CALLED__, "v@:@");
   if (originalImplementation) {
        class_addMethod(subclass, NSSelectorFromString(AspectsForwardInvocationSelectorName),   originalImplementation, "v@:@");
    } else {
        Method baseTargetMethod = class_getInstanceMethod(baseClass, @selector(forwardInvocation:));
        IMP baseTargetMethodIMP = method_getImplementation(baseTargetMethod);
       if (baseTargetMethodIMP) {
               class_addMethod(subclass, NSSelectorFromString(AspectsForwardInvocationSelectorName), baseTargetMethodIMP, "v@:@");
         }
  }
...
}

if (aspect_isMsgForwardIMP(targetMethodIMP)) {
      SEL aliasSelector = aspect_aliasForSelector(selector);
      Method originalMethod = class_getInstanceMethod(klass, aliasSelector);
      IMP originalIMP = method_getImplementation(originalMethod);
      if (originalIMP) {            
            class_replaceMethod(klass, selector, originalIMP, typeEncoding);
      } 
}

@interface MyClass : NSObject
- (void)test;
- (void)test2;
@end
@implementation MyClass
- (void)test {
    NSLog(@"MyClass origin log");
}
- (void)test2 {
    NSLog(@"MyClass test2 origin log");
}
@end

- (void)jp_hook {
    [JPEngine startEngine];
    NSString *sourcePath = [[NSBundle mainBundle] pathForResource:@"demo" ofType:@"js"];
    NSString *script = [NSString stringWithContentsOfFile:sourcePath encoding:NSUTF8StringEncoding error:nil];
    [JPEngine evaluateScript:script];
}
- (void)aspects_hook {
    [MyClass aspect_hookSelector:@selector(test) withOptions:AspectPositionAfter usingBlock:^(id aspects) {
        NSLog(@"aspects log");
    } error:nil];
}
- (void)aspects_hook_test2 {
    [MyClass aspect_hookSelector:@selector(test2) withOptions:AspectPositionInstead usingBlock:^(id aspects) {
        NSLog(@"aspects test2 log");
    } error:nil];
}

require('MyClass')
defineClass('MyClass', {
    test: function() {
//        self.ORIGtest();
        console.log("jspatch log")
    }
});

// ViewController.m
- (void)viewDidLoad {
    [super viewDidLoad];
    [self jp_hook];
    [self aspects_hook];
    MyClass *a = [[MyClass alloc] init];
    [a test];
}

JPAndAspects[2092:1554779] aspects log

- (void)viewDidLoad {
    [super viewDidLoad];
    [self aspects_hook];
    [self jp_hook];
    MyClass *a = [[MyClass alloc] init];
    [a test];
}

JPAndAspects[2774:1565702] JSPatch.log: jspatch log

// demo.js
require('MyClass')
defineClass('MyClass', {
    test: function() {
        self.ORIGtest();
        console.log("jspatch log")
    }
});
// ViewController.m
- (void)viewDidLoad {
    [super viewDidLoad];
    [self aspects_hook];
    [self jp_hook];
    MyClass *a = [[MyClass alloc] init];
    [a test];
}

JPAndAspects[8668:1705052] -[MyClass ORIGtest]: unrecognized selector sent to instance 0x7ff592421a30

static void JPForwardInvocation(__unsafe_unretained id assignSlf, SEL selector, NSInvocation *invocation)
{
...
  JSValue *jsFunc = getJSFunctionInObjectHierachy(slf, JPSelectorName);
  if (!jsFunc) {
      JPExecuteORIGForwardInvocation(slf, selector, invocation);
      return;
  }
...
}

// demo.js
require('MyClass')
defineClass('MyClass', {
    test: function() {
        console.log("jspatch log")
    }
});
// ViewController.m
- (void)viewDidLoad {
    [super viewDidLoad];
    [self jp_hook];
    [self aspects_hook];
    MyClass *a = [[MyClass alloc] init];
    [a test];
}

JPAndAspects[10943:1756624] aspects log
JPAndAspects[10943:1756624] JSPatch.log: jspatch log

SEL originalSelector = invocation.selector;
    SEL aliasSelector = aspect_aliasForSelector(invocation.selector);
    invocation.selector = aliasSelector;
    AspectsContainer *objectContainer = objc_getAssociatedObject(self, aliasSelector);
    AspectsContainer *classContainer = aspect_getContainerForClass(object_getClass(self), aliasSelector);
    AspectInfo *info = [[AspectInfo alloc] initWithInstance:self invocation:invocation];
    // Before hooks.
    aspect_invoke(classContainer.beforeAspects, info);
    aspect_invoke(objectContainer.beforeAspects, info);
    // Instead hooks.
    BOOL respondsToAlias = YES;
    if (objectContainer.insteadAspects.count || classContainer.insteadAspects.count) {
        aspect_invoke(classContainer.insteadAspects, info);
        aspect_invoke(objectContainer.insteadAspects, info);
    }else {
        Class klass = object_getClass(invocation.target);
        do {
            if ((respondsToAlias = [klass instancesRespondToSelector:aliasSelector])) {
                [invocation invoke];
                break;
            }
        }while (!respondsToAlias && (klass = class_getSuperclass(klass)));
    }
    // After hooks.
    aspect_invoke(classContainer.afterAspects, info);
    aspect_invoke(objectContainer.afterAspects, info);
    // If no hooks are installed, call original implementation (usually to throw an exception)
    if (!respondsToAlias) {
        invocation.selector = originalSelector;
        SEL originalForwardInvocationSEL = NSSelectorFromString(AspectsForwardInvocationSelectorName);
        if ([self respondsToSelector:originalForwardInvocationSEL]) {
            ((void( *)(id, SEL, NSInvocation *))objc_msgSend)(self, originalForwardInvocationSEL, invocation);
        }else {
            [self doesNotRecognizeSelector:invocation.selector];
        }
    }

JPAndAspects[11706:1776713] aspects log
JPAndAspects[11706:1776713] JSPatch.log: jspatch log

// demo.js
require('MyClass')
defineClass('MyClass', {
    test: function() {
        self.ORIGtest();
        console.log("jspatch log")
    }
});
// ViewController.m
- (void)viewDidLoad {
    [super viewDidLoad];
    [self aspects_hook_test2];
    [self jp_hook];
    [self aspects_hook];
    MyClass *a = [[MyClass alloc] init];
    [a test];
}

JPAndAspects[12597:1797663] MyClass origin log
JPAndAspects[12597:1797663] JSPatch.log: jspatch log

static Class aspect_hookClass(NSObject *self, NSError **error) {
    NSCParameterAssert(self);
    Class statedClass = self.class;
    Class baseClass = object_getClass(self);
    NSString *className = NSStringFromClass(baseClass);
    // Already subclassed
    if ([className hasSuffix:AspectsSubclassSuffix]) {
        return baseClass;
        // We swizzle a class object, not a single object.
    }else if (class_isMetaClass(baseClass)) {
        return aspect_swizzleClassInPlace((Class)self);
        // Probably a KVO'ed class. Swizzle in place. Also swizzle meta classes in place.
    }else if (statedClass != baseClass) {
        return aspect_swizzleClassInPlace(baseClass);
    }
    // Default case. Create dynamic subclass.
    const char *subclassName = [className stringByAppendingString:AspectsSubclassSuffix].UTF8String;
    Class subclass = objc_getClass(subclassName);
    if (subclass == nil) {
        subclass = objc_allocateClassPair(baseClass, subclassName, 0);
        if (subclass == nil) {
            NSString *errrorDesc = [NSString stringWithFormat:@"objc_allocateClassPair failed to allocate class %s.", subclassName];
            AspectError(AspectErrorFailedToAllocateClassPair, errrorDesc);
            return nil;
        }
        aspect_swizzleForwardInvocation(subclass);
        aspect_hookedGetClass(subclass, statedClass);
        aspect_hookedGetClass(object_getClass(subclass), statedClass);
        objc_registerClassPair(subclass);
    }
    object_setClass(self, subclass);
    return subclass;
}

static Class aspect_swizzleClassInPlace(Class klass) {
    ...
        if (![swizzledClasses containsObject:className]) {
            aspect_swizzleForwardInvocation(klass);
            [swizzledClasses addObject:className];
        }
    ...
}

if (class_getMethodImplementation(cls, @selector(forwardInvocation:)) != (IMP)JPForwardInvocation) {
}

// demo.js
require('MySubClass')
defineClass('MySubClass', {
    test: function() {
        self.super().test();
        console.log("jspatch log")
    }
});
// ViewController.m
// 增加一个子类
@interface MySubClass : MyClass
@end
@implementation MySubClass
- (void)test {
    NSLog(@"MySubClass origin log");
}
@end
- (void)viewDidLoad {
    [super viewDidLoad];
    [self aspects_hook];
    [self jp_hook];
    MySubClass *a = [[MySubClass alloc] init];
    [a test];
}

JPAndAspects[89642:1600226] -[MySubClass SUPER_test]: unrecognized selector sent to instance 0x7fa4cadabc70