/*
 * 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.
 */

#import "WXTracingManager.h"
#import "WXComponentFactory.h"
#import "WXModuleFactory.h"
#import "WXSDKManager.h"
#import "WXComponentFactory.h"
#import "WXModuleFactory.h"
#import "WXHandlerFactory.h"
#import "WXUtility.h"
#import "WXComponentManager.h"
#import "WXTracingProtocol.h"
#import "WXSDKEngine.h"


@implementation WXTracing

-(NSDictionary *)dictionary {
    return [NSDictionary dictionaryWithObjectsAndKeys:self.ref?:@"",@"ref",self.parentRef?:@"",@"parentRef",self.className?:@"",@"className",self.name?:@"",@"name",self.ph?:@"",@"ph",@(self.ts),@"ts",@(self.traceId),@"traceId",@(self.duration),@"duration",self.fName?:@"",@"fName",self.iid?:@"",@"iid",@(self.parentId)?:0,@"parentId",self.threadName?:@"",@"tName", nil];
}
@end

@implementation WXTracingTask

@end

@interface WXTracingManager()

@property (nonatomic) BOOL isTracing;
@property (nonatomic, strong) NSMutableDictionary *tracingTasks;  // every instance have a task
@property (nonatomic, copy) NSString *currentInstanceId;  // every instance have a task

@end

@implementation WXTracingManager


+ (instancetype) sharedInstance{
    
    static WXTracingManager *instance = nil;
    static dispatch_once_t once;
    
    dispatch_once(&once, ^{
        instance = [[WXTracingManager alloc] initPrivate];
    });
    
    return instance;
}

- (instancetype) initPrivate{
    self = [super init];
    if(self){
        self.isTracing = NO;
    }
    
    return self;
}

+(void)switchTracing:(BOOL )isTracing
{
    [WXTracingManager sharedInstance].isTracing = isTracing;
}

+(BOOL)isTracing
{
    return [WXTracingManager sharedInstance].isTracing;
}

+(void)startTracing:(WXTracing *)tracing
{
    if([self isTracing]){
        if(![WXTracingManager sharedInstance].tracingTasks){
            [WXTracingManager sharedInstance].tracingTasks = [NSMutableDictionary new];
        }
        if(![[WXTracingManager sharedInstance].tracingTasks objectForKey:tracing.iid]){
            WXTracingTask *task = [WXTracingTask new];
            task.iid = tracing.iid;
            if (tracing.iid) {
                [[WXTracingManager sharedInstance].tracingTasks setObject:task forKey:tracing.iid];
            }
        }
        WXTracingTask *task = [[WXTracingManager sharedInstance].tracingTasks objectForKey:tracing.iid];
        if(task.bundleUrl.length == 0){
            if(tracing.bundleUrl.length>0){
                task.bundleUrl = tracing.bundleUrl;
            }
        }
        if(!task.tracings){
            task.tracings = [NSMutableArray new];
        }
        if(WXFloatEqual(tracing.ts,0)){
            NSTimeInterval time=[[NSDate date] timeIntervalSince1970]*1000;
            tracing.ts = time;
        }
        if(WXFloatEqual(tracing.duration,0)){
            tracing.duration = WXTracingDurationDefault;
        }
        if(![WXTracingEnd isEqualToString:tracing.ph]){ // end is should not update
            tracing.traceId = task.counter++;
        }
        if([WXTNetworkHanding isEqualToString:tracing.name] && [WXTracingBegin isEqualToString:tracing.ph]){
            task.tag = WXTNetworkHanding;
        }
        NSTimeInterval ts = [[NSDate date] timeIntervalSince1970]*1000;
        tracing.ts = ts ;
        dispatch_async(dispatch_get_main_queue(), ^{
            [self updateTracings:task tracing:tracing];
        });
    }
}

+(void)setBundleJSType:(NSString *)jsBundleString instanceId:(NSString *)iid
{
    if([self isTracing] && iid.length >0){
        WXTracingTask *task = [[WXTracingManager sharedInstance].tracingTasks objectForKey:iid];
        if(jsBundleString.length >0){
            NSRange range = [jsBundleString rangeOfString:@"}"];
            if (range.location != NSNotFound) {
                NSString *searchStr =  [jsBundleString substringToIndex:range.location+range.length];
                if ([searchStr rangeOfString:@"Vue"].location != NSNotFound){
                    task.bundleJSType = @"Vue";
                }else if([searchStr rangeOfString:@"Rax"].location != NSNotFound){
                    task.bundleJSType = @"Rax";
                }else{
                    task.bundleJSType = @"Weex";
                }
            }
        }
    }
}

+(void)clearTracingData
{
    [WXTracingManager sharedInstance].tracingTasks = nil;
}

+(NSTimeInterval)getCurrentTime
{
    if([self isTracing]){
        return  [[NSDate date] timeIntervalSince1970]*1000;
    }
    return 0;
}

+(void)startTracingWithInstanceId:(NSString *)iid ref:(NSString*)ref className:(NSString *)className name:(NSString *)name phase:(NSString *)phase functionName:(NSString *)functionName options:(NSDictionary *)options
{
    if([self isTracing]){
        WXTracing *tracing = [WXTracing new];
        tracing.parentId = -1;
        if(ref.length>0){
            tracing.ref = ref;
        }else {
            tracing.ref = @"";
        }
        if(className.length>0){
            tracing.className = className;
        }else {
            tracing.className = @"";
        }
        if(name.length>0){
            tracing.name = name;
        }
        if(functionName.length>0){
            tracing.fName = functionName;
        }
        if(phase.length>0){
            tracing.ph = phase;
        }
        if(iid.length>0){
            tracing.iid = iid;
        }
        
        if(options && options[@"ts"]){
            tracing.ts = [options[@"ts"] floatValue];
        }
        if(options && options[@"duration"]){
            tracing.duration =  [options[@"duration"] floatValue];
        }
        if(options && options[@"parentRef"]){
            tracing.parentRef = options[@"parentRef"];
        }
        if(options && options[@"bundleUrl"]){
            tracing.bundleUrl = options[@"bundleUrl"];
        }
        if(options && options[@"threadName"]){
            tracing.threadName = options[@"threadName"];
        }
        if(options && options[@"componentData"]){
            tracing.childrenRefs = [self getChildrenRefs:options[@"componentData"]];
        }
        [self startTracing:tracing];
    }
}

+ (NSMutableArray *)getChildrenRefs:(NSDictionary *)componentData
{
    NSMutableArray *mArray = [NSMutableArray new];
    [self recursively:mArray componentData:componentData];
    return mArray;
}

+(void)recursively:(NSMutableArray *)mArray componentData:(NSDictionary *)componentData
{
    if([componentData valueForKey:@"children"]){
        NSArray *children = [componentData valueForKey:@"children"];
        for(NSDictionary *subcomponentData in children){
            NSString *ref = [subcomponentData objectForKey:@"ref"];
            if(ref){
                [mArray addObject:ref];
            }
            [self recursively:mArray componentData:subcomponentData];
        }
    }
}

+(WXTracing *)copyTracing:(WXTracing *)tracing
{
    WXTracing *newTracing = [WXTracing new];
    if(tracing.ref.length>0){
        newTracing.ref = tracing.ref;
    }
    if(tracing.parentRef.length>0){
        newTracing.parentRef = tracing.parentRef;
    }
    if(tracing.className.length>0){
        newTracing.className = tracing.className;
    }
    if(tracing.name.length>0){
        newTracing.name = tracing.name;
    }
    if(tracing.fName.length>0){
        newTracing.fName = tracing.fName;
    }
    if(tracing.ph.length>0){
        newTracing.ph = tracing.ph;
    }
    if(tracing.iid.length>0){
        newTracing.iid = tracing.iid;
    }
    if(tracing.parentId>0){
        newTracing.parentId = tracing.parentId;
    }
    if(tracing.traceId>0){
        newTracing.traceId = tracing.traceId;
    }
    if(tracing.ts>0){
        newTracing.ts = tracing.ts;
    }
    if(tracing.threadName.length>0){
        newTracing.threadName = tracing.threadName;
    }
    return newTracing;
}

+(NSString *)getclassName:(WXTracing *)tracing
{
    NSString *className = @"";
    if(tracing.ref.length>0 && tracing.name.length >0){
        Class cls = [WXComponentFactory classWithComponentName:tracing.name];
        className = NSStringFromClass(cls);
    }else if(tracing.name.length > 0){
        Class cls = [WXModuleFactory classWithModuleName:tracing.name];
        if(cls){
            className = NSStringFromClass(cls);
        }
    }
    return  className;
}

+(NSInteger )getParentId:(WXTracingTask *)task tracing:(WXTracing *)tracing
{
    NSMutableArray *tracings = task.tracings;
    if([tracing.threadName isEqualToString:WXTJSBridgeThread]) {
        return -1;
    }
    if(tracings && [tracings count]>0){
        for (NSInteger i = [tracings count] - 1; i >= 0; i--) {
            WXTracing *t = tracings[i];
//            if([t.threadName isEqualToString:WXTJSBridgeThread]&& [self compareRef:tracing.ref withTracing:t] && ([t.name isEqualToString:tracing.name] || [t.name isEqualToString:WXTJSCall])){
            if([t.threadName isEqualToString:WXTJSBridgeThread]&& [self compareRef:tracing.ref withTracing:t]){
                if([t.fName isEqualToString:tracing.fName]){
                    return (NSInteger)t.traceId;
                }
            }
        }
    }
    return -1;
}

+(BOOL)compareRef:(NSString *)ref withTracing:(WXTracing *)tracing
{
    if([tracing.ref isEqualToString:ref]){
        return YES;
    }
    if(tracing.childrenRefs && [tracing.childrenRefs count] > 0){
        for (NSString *childRef in tracing.childrenRefs) {
            if([childRef isEqualToString:ref]){
                return YES;
            }
        }
    }
    return NO;
}

+(void)updateTracings:(WXTracingTask *)task tracing:(WXTracing *)tracing
{
    if([WXTNetworkHanding isEqualToString:task.tag]){
        if([WXTExecJS isEqualToString:tracing.name]){
            NSMutableArray *tracings = task.tracings;
            [tracings enumerateObjectsWithOptions:NSEnumerationReverse usingBlock:^(WXTracing *bTracing, NSUInteger idx, BOOL *stop) {
                if(([WXTNetworkHanding isEqualToString:bTracing.name] || [bTracing.ref isEqualToString:tracing.ref])&&[WXTracingBegin isEqualToString:bTracing.ph]){
                    WXTracing *newTracing = [self copyTracing:bTracing];
                    newTracing.iid = tracing.iid;
                    newTracing.ph = WXTracingEnd;
                    newTracing.ts = tracing.ts ;
                    newTracing.duration = newTracing.ts - bTracing.ts ;
                    bTracing.duration = newTracing.duration;
                    [task.tracings addObject:newTracing];
                    *stop = YES;
                }
            }];
            task.tag = WXTExecJS;
        }
    }
    
    if([WXTracingBegin isEqualToString:tracing.ph]){
        if(tracing.ref.length>0){
            WXPerformBlockOnComponentThread(^{
                WXSDKInstance *instance = [WXSDKManager instanceForID:task.iid];
                WXComponent *com = [instance componentForRef:tracing.ref];
                if(task.bundleUrl.length == 0){
                    task.bundleUrl = [instance.scriptURL absoluteString];
                }
                if(com.supercomponent){
                    tracing.parentRef = com.supercomponent.ref;
                }
                tracing.name = com.type;
                if(tracing.className.length == 0){
                    tracing.className = [self getclassName:tracing];
                }
            });
            if(tracing.parentId == -1){
                tracing.parentId = [self getParentId:task tracing:tracing];
            }
        } else {
            if(tracing.parentId == -1){
                tracing.parentId = [self getParentId:task tracing:tracing];
            }
        }
        
    }
    if([WXTracingEnd isEqualToString:tracing.ph]){  // deal end
        NSMutableArray *tracings = task.tracings;
        [tracings enumerateObjectsWithOptions:NSEnumerationReverse usingBlock:^(WXTracing *bTracing, NSUInteger idx, BOOL *stop) {
            if(tracing.ref.length > 0 && bTracing.ref.length>0){
                if(![tracing.ref isEqualToString:bTracing.ref]){
                    return ;
                }
            }
            
            if([bTracing.fName isEqualToString:tracing.fName] &&[WXTracingBegin isEqualToString:bTracing.ph] ){
                tracing.iid = bTracing.iid;
                if(bTracing.ref.length > 0){
                    tracing.ref = bTracing.ref;
                }
                if(bTracing.parentRef.length > 0){
                    tracing.parentRef = bTracing.parentRef;
                }
                tracing.parentId = bTracing.parentId;
                tracing.duration = tracing.ts - bTracing.ts ;
                tracing.traceId = bTracing.traceId;
                tracing.threadName = bTracing.threadName;
                bTracing.duration = tracing.duration;
                tracing.name = bTracing.name;
                *stop = YES;
            }
        }];
    }
    
    [task.tracings addObject:tracing];
    if([@"renderFinish" isEqualToString:tracing.fName] && [WXTracingInstant isEqualToString:tracing.ph] && [WXTUIThread isEqualToString:tracing.threadName]) {
        [WXTracingManager commitTracing:task.iid];
    }
}

+(NSMutableDictionary *)getTracingData
{
    if(![self isTracing]){
        return nil;
    }
    
    return [WXTracingManager sharedInstance].tracingTasks;
}

+(NSDictionary *)getTacingApi
{
    if(![self isTracing]){
        return @{};
     }
    NSMutableDictionary *dict = [NSMutableDictionary new];
    NSMutableArray *componetArray = [NSMutableArray new];
    NSMutableArray *moduleArray = [NSMutableArray new];
    NSMutableArray *handleArray = [NSMutableArray new];
    NSDictionary *componentConfigs = [WXComponentFactory componentConfigs];
    void (^componentBlock)(id, id, BOOL *) = ^(id mKey, id mObj, BOOL * mStop) {
        NSMutableDictionary *componentConfig = [mObj mutableCopy];
        NSDictionary *cDict = [WXComponentFactory componentSelectorMapsWithName:componentConfig[@"name"]];
        if(cDict && [cDict count]>0 && [cDict[@"methods"] count]>0){
            [componentConfig setObject:cDict[@"methods"] forKey:@"methods"];
        }
        [componetArray addObject:componentConfig];
    };
    [componentConfigs enumerateKeysAndObjectsUsingBlock:componentBlock];
    if(componetArray && [componetArray count]>0){
        [dict setObject:componetArray forKey:@"componet"];
    }
    NSDictionary *moduleConfigs = [WXModuleFactory moduleConfigs];
    void (^moduleBlock)(id, id, BOOL *) = ^(id mKey, id mObj, BOOL * mStop) {
        NSDictionary *mDict = [WXModuleFactory moduleSelectorMapsWithName:mKey];
        NSMutableDictionary *subDict = [NSMutableDictionary new];
        [subDict setObject:mKey forKey:@"name"];
        [subDict setObject:mObj forKey:@"class"];
        if([mDict objectForKey:mKey]){
            [subDict setObject:[mDict objectForKey:mKey] forKey:@"methods"];
        }
        [moduleArray addObject:subDict];
    };
    [moduleConfigs enumerateKeysAndObjectsUsingBlock:moduleBlock];
    if(moduleArray && [moduleArray count]>0){
        [dict setObject:moduleArray forKey:@"module"];
    }
    
    NSDictionary *handleConfigs = [[WXHandlerFactory handlerConfigs] mutableCopy];
    void (^handleBlock)(id, id, BOOL *) = ^(id mKey, id mObj, BOOL * mStop) {
        NSMutableDictionary *subDict = [NSMutableDictionary new];
        [subDict setObject:mKey forKey:@"class"];
        [subDict setObject:NSStringFromClass([mObj class]) forKey:@"name"];
        [handleArray addObject:subDict];
    };
    [handleConfigs enumerateKeysAndObjectsUsingBlock:handleBlock];
    if(handleArray && [handleArray count]>0){
        [dict setObject:handleArray forKey:@"handle"];
    }
    
    return dict;
}

+ (void)commitTracing:(NSString *)instanceId
{
    if(![self isTracing]){
        return ;
    }
    id tracingHandle = [WXSDKEngine handlerForProtocol:@protocol(WXTracingProtocol)];
    if ([tracingHandle respondsToSelector:@selector(commitTracingInfo:)]){
        WXTracingTask *task = [[WXTracingManager sharedInstance].tracingTasks objectForKey:instanceId];
        if(task) {
            [tracingHandle commitTracingInfo:task];
        }
        
    }
}

+ (void)commitTracingSummaryInfo:(NSDictionary *)info withInstanceId:(NSString *)instanceId
{
    if(![self isTracing]){
        return ;
    }
    id tracingHandle = [WXSDKEngine handlerForProtocol:@protocol(WXTracingProtocol)];
    if ([tracingHandle respondsToSelector:@selector(commitTracingSummaryInfo:)]){
        if(info) {
            NSMutableDictionary *newInfo = [info mutableCopy];
            if(instanceId.length > 0){
                [newInfo setObject:instanceId forKey:@"instanceId"];
                [newInfo setObject:[[WXUtility getEnvironment] objectForKey:@"platform"] forKey:@"platform"];
            }
            [tracingHandle commitTracingSummaryInfo:newInfo];
        }
        
    }
}

+(void)destroyTraincgTaskWithInstance:(NSString *)instanceId
{
    if(![self isTracing]){
        return ;
    }
    WXTracingTask *task = [[WXTracingManager sharedInstance].tracingTasks objectForKey:instanceId];
    if(task){
        [[WXTracingManager sharedInstance].tracingTasks removeObjectForKey:instanceId];
    }
}

@end