import Foundation

final class DeeplinkHandler {
    private init() {}

    static func handleSchemeDeeplink(url: URL) -> Bool {
        if url.scheme != "YOUR_SCHEME" {
            return false
        }

        // REQUIRE: show content

        return true
    }

    static func handleOtherDeeplink(url: URL) -> Bool {
        // OPTION: show content

        return true
    }
}

#import <Foundation/Foundation.h>

@implementation ABDeeplinkHandler

- (instancetype) init __unavailable;

+ (BOOL)handleSchemeDeeplink:(NSURL *)url;
+ (BOOL)handleOtherDeeplink:(NSURL *)url;

@end
...
#import "ABDeeplinkHandler.h"

@interface ABDeeplinkHandler : NSObject

+ (BOOL)handleSchemeDeeplink:(NSURL *)url {
    if (![url.scheme isEqualToString:@"YOUR_SCHEME"]) {
        return NO;
    }

    // REQUIRE: show content

    return YES;
}

+ (BOOL)handleOtherDeeplink:(NSURL *)url {
    // OPTION: show content

    return YES;
}

@end

import SwiftUI
import Airbridge

@main
struct ActualApp: App {
    var body: some Scene {
        WindowGroup {
            ContentView()
                // when app is opened with scheme deeplink or universal links
                .onOpenURL { url in
                    // track deeplink
                    Airbridge.trackDeeplink(url: url)

                    // handle airbridge deeplink
                    var isHandled = Airbridge.handleDeeplink(url: url) { url in
                        DeeplinkHandler.handleSchemeDeeplink(url: url)
                    }
                    if isHandled { return }

                    // handle scheme deeplink
                    isHandled = DeeplinkHandler.handleSchemeDeeplink(url: url)
                    if isHandled { return }

                    // handle other deeplink
                    isHandled = DeeplinkHandler.handleOtherDeeplink(url: url)
                }
        }
    }
}

#import "AppDelegate.h"
#import "ABDeeplinkHandler.h"
#import <Airbridge/Airbridge.h>

@interface AppDelegate ()

@end

@implementation AppDelegate

// when app is opened with scheme deeplink
- (BOOL)application:(UIApplication *)app openURL:(NSURL *)url options:(NSDictionary<UIApplicationOpenURLOptionsKey,id> *)options {
    // track deeplink
    [Airbridge trackDeeplinkWithUrl:url];

    // handle airbridge deeplink
    BOOL isHandled = [Airbridge handleDeeplinkWithUrl:url onSuccess:^(NSURL* url) {
        [ABDeeplinkHandler handleSchemeDeeplink:url];
    }];
    if (isHandled) { return isHandled; }
    
    // handle scheme deeplink
    isHandled = [ABDeeplinkHandler handleSchemeDeeplink:url];
    if (isHandled) { return isHandled; }
    
    // handle other deeplink
    isHandled = [ABDeeplinkHandler handleOtherDeeplink:url];
    
    return isHandled;
}

// when app is opened with universal links
- (BOOL)application:(UIApplication *)application continueUserActivity:(NSUserActivity *)userActivity restorationHandler:(void (^)(NSArray<id<UIUserActivityRestoring>> * _Nullable))restorationHandler {
    // track deeplink
    [Airbridge trackDeeplinkWithUserActivity:userActivity];

    // handle airbridge deeplink
    BOOL isHandled = [Airbridge handleDeeplinkWithUserActivity:userActivity onSuccess:^(NSURL* url) {
        [ABDeeplinkHandler handleSchemeDeeplink:url];
    }];
    if (isHandled) { return isHandled; }
    
    // handle other deeplink
    NSURL* url = userActivity.webpageURL;
    if (url != nil) {
        isHandled = [ABDeeplinkHandler handleOtherDeeplink:url];
    }
    
    return isHandled;
}

@end

import Airbridge
...
let option = AirbridgeOptionBuilder(name: "YOUR_APP_NAME", token: "YOUR_APP_SDK_TOKEN")
    .build()
Airbridge.initializeSDK(option: option)
...
let isHandled = Airbridge.handleDeferredDeeplink() { url in
    if let url {
        DeeplinkHandler.handleSchemeDeeplink(url)
    }
}

#import <Airbridge/Airbridge.h>
...
AirbridgeOptionBuilder* optionBuilder = [[AirbridgeOptionBuilder alloc] initWithName:@"YOUR_APP_NAME"
                                                                               token:@"YOUR_APP_SDK_TOKEN"];
AirbridgeOption* option = [optionBuilder build];
[Airbridge initializeSDKWithOption:option];
...
[Airbridge handleDeferredDeeplinkOnSuccess:^(NSURL* url) {
    if (url != nil) {
        [ABDeeplinkHandler handleSchemeDeeplink:url];
    }
}];

import Airbridge
...
let option = AirbridgeOptionBuilder(name: "YOUR_APP_NAME", token: "YOUR_APP_TOKEN")
    .setTrackingLinkCustomDomains(["YOUR_CUSTOM_DOMAIN"])
    .build()
Airbridge.initializeSDK(option: option)

#import <Airbridge/Airbridge.h>
...
AirbridgeOptionBuilder* optionBuilder = [[AirbridgeOptionBuilder alloc] initWithName:@"YOUR_APP_NAME"
                                                                               token:@"YOUR_APP_TOKEN"];
[optionBuilder setTrackingLinkCustomDomains:@[@"YOUR_CUSTOM_DOMAIN"]];
AirbridgeOption* option = [optionBuilder build];
[Airbridge initializeSDKWithOption:option];

import Airbridge
...
// setCategory
Airbridge.trackEvent(
    category: AirbridgeCategory.ORDER_COMPLETED,
    semanticAttributes: [
        // setAction
        AirbridgeAttribute.ACTION: "Tool",
        // setLabel
        AirbridgeAttribute.LABEL: "Hammer",
        // setValue
        AirbridgeAttribute.VALUE: 10,
        // setSemantics (using ABSemanticsKey)
        AirbridgeAttribute.CURRENCY: "USD",
        AirbridgeAttribute.PRODUCTS: [
            [
                // setSemantics value (using ABProductKey)
                AirbridgeAttribute.PRODUCT_ID: "12345",
                // setSemantics value (using String)
                "name": "PlasticHammer",
            ],
        ],
        // setSemantics (using String)
        "totalQuantity": 1,
    ],
    customAttributes: [
        // setCustoms
        "promotion": "FirstPurchasePromotion",
    ]
)

import Airbridge
...
Airbridge.setDeviceAlias(key: "string", value: "string")
Airbridge.removeDeviceAlias(key: "string")
Airbridge.clearDeviceAlias()

#import <Airbridge/Airbridge.h>
...
[Airbridge trackEventWithCategory:@"event" semanticAttributes:@{
    // action
    AirbridgeAttribute.ACTION: @"Tool",
    // label
    AirbridgeAttribute.LABEL: @"Hammer",
    // value
    AirbridgeAttribute.VALUE: @(10),
    // semantic attribute (provided by sdk)
    AirbridgeAttribute.CURRENCY: @"USD",
    AirbridgeAttribute.PRODUCTS: @[
        @{
            // semantic attribute value (provided by sdk)
            AirbridgeAttribute.PRODUCT_ID: @"12345",
            // semantic attribute value (not provided by sdk)
            @"name": @"PlasticHammer",
        },
    ],
    // semantic attribute (not provided by sdk)
    @"totalQuantity": @(1),
}, customAttributes:@{
    // custom attribute
    @"promotion": @"FirstPurchasePromotion",
}];

#import <Airbridge/Airbridge.h>
...
BOOL isHandled = [Airbridge impressionWithTrackingLink:url onSuccess:^{
    // when url is tracking link and succeed
} onFailure:^(NSError * _Nonnull) {
    // when url is tracking link and failed
}];
if (!isHandled) {
    // when url is not tracking link
}

import Airbridge
...
// identifier
Airbridge.setUserID("string")
Airbridge.clearUserID()
// addtional identifier
Airbridge.setUserAlias(key: "string", value: "string")
Airbridge.removeUserAlias(key: "string")
Airbridge.clearUserAlias()
...
// email, phone
Airbridge.setUserEmail("string")
Airbridge.clearUserEmail()
Airbridge.setUserPhone("string")
Airbridge.clearUserPhone()
// addtional attribute
Airbridge.setUserAttribute(key: "string", value: "string")
Airbridge.setUserAttribute(key: "number", value: 1000)
Airbridge.removeUserAttribute(key: "string")
Airbridge.clearUserAttributes()

#import <Airbridge/Airbridge.h>
...
// identifier
[Airbridge setUserID:@"string"];
[Airbridge clearUserID];
// additional identifier
[Airbridge setUserAliasWithKey:@"string" value:@"string"];
[Airbridge removeUserAliasWithKey:@"string"];
[Airbridge clearUserAlias];
...
// email, phone
[Airbridge setUserEmail:@"string"];
[Airbridge clearUserEmail];
[Airbridge setUserPhone:@"string"];
[Airbridge clearUserPhone];
// addtional attribute
[Airbridge setUserAttributeWithKey:@"string" value:@"string"];
[Airbridge setUserAttributeWithKey:@"number" value:@(1000)];
[Airbridge removeUserAttributeWithKey:@"string"];
[Airbridge clearUserAttributes];

import Airbridge
...
let isHandled = Airbridge.click(trackingLink: url) {
    // when url is tracking link and succeed
} onFailure: { error in
    // when url is tracking link and failed
    // example: url is another app's tracking link, internet is not connected
}
if !isHandled {
    // when url is not tracking link
}
...
let isHandled = Airbridge.impression(trackingLink: url) {
    // when url is tracking link and succeed
} onFailure: { error in
    // when url is tracking link and failed
}
if !isHandled {
    // when url is not tracking link
}

#import <Airbridge/Airbridge.h>
...
BOOL isHandled = [Airbridge clickWithTrackingLink:url onSuccess:^{
    // when url is tracking link and succeed
} onFailure:^(NSError * _Nonnull) {
    // when url is tracking link and failed
    // example: url is another app's tracking link, internet is not connected
}];
if (!isHandled) {
    // when url is not tracking link
}
...
BOOL isHandled = [Airbridge impressionWithTrackingLink:url onSuccess:^{
    // when url is tracking link and succeed
} onFailure:^(NSError * _Nonnull) {
    // when url is tracking link and failed
}];
if (!isHandled) {
    // when url is not tracking link
}

import Airbridge
...
Airbridge.setWebInterface(
    controller: controller,
    webToken: "YOUR_WEB_TOKEN"
)

#import <Airbridge/Airbridge.h>
...
[Airbridge setWebInterfaceWithController:controller webToken:@"YOUR_WEB_TOKEN"];

import UIKit
import Airbridge

class SceneDelegate: UIResponder, UIWindowSceneDelegate {
    var window: UIWindow?

    // when terminated app is opened with scheme deeplink or universal links
    func scene(
        _ scene: UIScene,
        willConnectTo session: UISceneSession,
        options connectionOptions: UIScene.ConnectionOptions
    ) {
        // when app is opened with scheme deeplink
        if let url = connectionOptions.urlContexts.first?.url {
            // track deeplink
            Airbridge.trackDeeplink(url: url)

            // handle airbridge deeplink
            var isHandled = Airbridge.handleDeeplink(url: url) { url in
                DeeplinkHandler.handleSchemeDeeplink(url: url)
            }
            if isHandled { return }

            // handle scheme deeplink
            isHandled = DeeplinkHandler.handleSchemeDeeplink(url: url)
            if isHandled { return }

            // handle other deeplink
            isHandled = DeeplinkHandler.handleOtherDeeplink(url: url)
        }
        // when app is opened with universal links
        else if let userActivity = connectionOptions.userActivities.first {
            // track deeplink
            Airbridge.trackDeeplink(userActivity: userActivity)

            // handle airbridge deeplink
            var isHandled = Airbridge.handleDeeplink(userActivity: userActivity) { url in
                DeeplinkHandler.handleSchemeDeeplink(url: url)
            }
            if isHandled { return }

            // handle other deeplink
            if let url = userActivity.webpageURL {
                isHandled = DeeplinkHandler.handleOtherDeeplink(url: url)
            }
        }
    }

    // when backgrounded app is opened with scheme deeplink
    func scene(
        _ scene: UIScene,
        openURLContexts URLContexts: Set<UIOpenURLContext>
    ) {
        guard let url = URLContexts.first?.url else { return }

        // track deeplink
        Airbridge.trackDeeplink(url: url)

        // handle airbridge deeplink
        var isHandled = Airbridge.handleDeeplink(url: url) { url in
            DeeplinkHandler.handleSchemeDeeplink(url: url)
        }
        if isHandled { return }

        // handle scheme deeplink
        isHandled = DeeplinkHandler.handleSchemeDeeplink(url: url)
        if isHandled { return }

        // handle other deeplink
        isHandled = DeeplinkHandler.handleOtherDeeplink(url: url)
    }

    // when backgrounded app is opened with universal links
    func scene(
        _ scene: UIScene,
        continue userActivity: NSUserActivity
    ) {
        // track deeplink
        Airbridge.trackDeeplink(userActivity: userActivity)

        // handle airbridge deeplink
        var isHandled = Airbridge.handleDeeplink(userActivity: userActivity) { url in
            DeeplinkHandler.handleSchemeDeeplink(url: url)
        }
        if isHandled { return }

        // handle other deeplink
        if let url = userActivity.webpageURL {
            isHandled = DeeplinkHandler.handleOtherDeeplink(url: url)
        }
    }
}

#import "SceneDelegate.h"
#import "ABDeeplinkHandler.h"
#import <Airbridge/Airbridge.h>

@interface SceneDelegate ()

@end

@implementation SceneDelegate

// when terminated app is opened with scheme deeplink or universal links
- (void)scene:(UIScene *)scene willConnectToSession:(UISceneSession *)session options:(UISceneConnectionOptions *)connectionOptions {
    // when app is opened with scheme deeplink
    NSURL* url = connectionOptions.URLContexts.allObjects.firstObject.URL;
    NSUserActivity* userActivity = connectionOptions.userActivities.allObjects.firstObject;
    if (url != nil) {
        // track deeplink
        [Airbridge trackDeeplinkWithUrl:url];

        // handle airbridge deeplink
        BOOL isHandled = [Airbridge handleDeeplinkWithUrl:url onSuccess:^(NSURL* url) {
            [ABDeeplinkHandler handleSchemeDeeplink:url];
        }];
        if (isHandled) { return; }

        // handle scheme deeplink
        isHandled = [ABDeeplinkHandler handleSchemeDeeplink:url];
        if (isHandled) { return; }

        // handle other deeplink
        isHandled = [ABDeeplinkHandler handleSchemeDeeplink:url];
    }
    else if (userActivity != nil) {
        // track deeplink
        [Airbridge trackDeeplinkWithUserActivity:userActivity];

        // handle airbridge deeplink
        BOOL isHandled = [Airbridge handleDeeplinkWithUserActivity:userActivity onSuccess:^(NSURL* url) {
            [ABDeeplinkHandler handleSchemeDeeplink:url];
        }];
        if (isHandled) { return; }

        // handle other deeplink
        NSURL* url = userActivity.webpageURL;
        if (url != nil) {
            isHandled = [ABDeeplinkHandler handleOtherDeeplink:url];
        }
    }
}

// when backgrounded app is opened with scheme deeplink
- (void)scene:(UIScene *)scene openURLContexts:(NSSet<UIOpenURLContext *> *)URLContexts {
    NSURL* url = URLContexts.allObjects.firstObject.URL;
    if (url == nil) { return; }

    // track deeplink
    [Airbridge trackDeeplinkWithUrl:url];

    // handle airbridge deeplink
    BOOL isHandled = [Airbridge handleDeeplinkWithUrl:url onSuccess:^(NSURL* url) {
        [ABDeeplinkHandler handleSchemeDeeplink:url];
    }];
    if (isHandled) { return; }

    // handle scheme deeplink
    isHandled = [ABDeeplinkHandler handleSchemeDeeplink:url];
    if (isHandled) { return; }

    // handle other deeplink
    isHandled = [ABDeeplinkHandler handleSchemeDeeplink:url];
}

// when backgrounded app is opened with universal links
- (void)scene:(UIScene *)scene continueUserActivity:(NSUserActivity *)userActivity {
    // track deeplink
    [Airbridge trackDeeplinkWithUserActivity:userActivity];

    // handle airbridge deeplink
    BOOL isHandled = [Airbridge handleDeeplinkWithUserActivity:userActivity onSuccess:^(NSURL* url) {
        [ABDeeplinkHandler handleSchemeDeeplink:url];
    }];
    if (isHandled) { return; }

    // handle other deeplink
    NSURL* url = userActivity.webpageURL;
    if (url != nil) {
        isHandled = [ABDeeplinkHandler handleOtherDeeplink:url];
    }
}

@end

import UIKit
import Airbridge

@main
class AppDelegate: UIResponder, UIApplicationDelegate {   
    var window: UIWindow?

    // when app is opened with scheme deeplink
    func application(
        _ app: UIApplication,
        open url: URL,
        options: [UIApplication.OpenURLOptionsKey : Any] = [:]
    ) -> Bool {
        // track deeplink
        Airbridge.trackDeeplink(url: url)

        // handle airbridge deeplink
        var isHandled = Airbridge.handleDeeplink(url: url) { url in
            DeeplinkHandler.handleSchemeDeeplink(url: url)
        }
        if isHandled { return isHandled }

        // handle scheme deeplink
        isHandled = DeeplinkHandler.handleSchemeDeeplink(url: url)
        if isHandled { return isHandled }

        // handle other deeplink
        isHandled = DeeplinkHandler.handleOtherDeeplink(url: url)

        return isHandled
    }

    // when app is opened with universal links
    func application(
        _ application: UIApplication,
        continue userActivity: NSUserActivity,
        restorationHandler: @escaping ([UIUserActivityRestoring]?) -> Void
    ) -> Bool {
        // track deeplink
        Airbridge.trackDeeplink(userActivity: userActivity)

        // handle airbridge deeplink
        var isHandled = Airbridge.handleDeeplink(userActivity: userActivity) { url in
            DeeplinkHandler.handleSchemeDeeplink(url: url)
        }
        if isHandled { return isHandled }

        // handle other deeplink
        if let url = userActivity.webpageURL {
            isHandled = DeeplinkHandler.handleOtherDeeplink(url: url)
        }

        return isHandled
    }
}