// import package
import 'package:flagship/flagship.dart';

//////////////////////////////////////////////
/////// Start sdk with default options ///////
//////////////////////////////////////////////

await Flagship.start("your_env_id", "your_api_key");

//import package
import 'package:flagship/flagship.dart';

/////////////////////////////////////////////////////////////
// Create visitor when SDK is ready, using the statusListener
/////////////////////////////////////////////////////////////
    FlagshipConfig customConfig = ConfigBuilder()
        .withMode(Mode.DECISION_API)
        .withStatusListener((newStatus) {
          // When the status is Ready
          if (newStatus == Status.READY) {
            // Do things ...
          }
        })
        .withTimeout(2500)
        .withLogLevel(Level.ALL)
        .build();

    // Start SDK
    Flagship.start(
        "your_env_id", "your_api_key",
        config: customConfig);

//////////////////////////////////////////////
/////// Start SDK with custom options  ///////
//////////////////////////////////////////////

// - timeout   = 2500 ms
// - level     = warning message
// - statusListener callback

FlagshipConfig customConfig = ConfigBuilder()
    .withMode(Mode.DECISION_API)
    .withStatusListener((newStatus) {
      // Do things when status change ...
    })
    .withTimeout(2500)
    .withLogLevel(Level.WARNING)
    .build();
    
// Start SDK
await Flagship.start("your_env_id", "your_api_key", config: customConfig);

//////////////////////////////////////////////
/////// Start SDK with custom options  ///////
//////////////////////////////////////////////


// Create a config manager with a custom settings:
// - timeout   = 1500 ms
// - level     = warning message
// - statusListener callback
// - Time Intreval : 20
// - Maximum size pool : 20
// - Strategy : BATCH_CONTINUOUS_CACHING

// Create a custom tracking manager  
    var customTrackingConfig = TrackingManagerConfig(
        batchIntervals: 20,
        poolMaxSize: 20,
        batchStrategy: BatchCachingStrategy.BATCH_CONTINUOUS_CACHING);


// Create customConfig config manager 
    FlagshipConfig customConfig = ConfigBuilder()
        .withMode(Mode.DECISION_API)
        .withStatusListener((newStatus) {
          // Do things when status change ...
        })
        .withTimeout(1500)
        .withLogLevel(Level.WARNING)
        .withTrackingConfig(customTrackingConfig)
        .build();

// Start SDK with a custom configuration
    Flagship.start("your_env_id", "your_api_key", config: customConfig);
  }

// Create config and disabled usage tracking 
   FlagshipConfig customConfig = ConfigBuilder().withDisableDeveloperUsageTracking(true)
        .build();
// Start SDK
    await Flagship.start("your_env_id", "your_api_key", config: customConfig);

typedef OnVisitorExposed = void Function(VisitorExposed visitorExposed, ExposedFlag fromFlag)?;

// Inside the callBack we use toJson() method to get the json representation.
// This block is a part of confuguration builder, for more information 
// go to #flagship-configuration-options section
.withOnVisitorExposed((exposedUser, fromFlag) {
          // Get the json representation                  
          print(fromFlag.toJson());
          print(exposedUser.toJson());
        })
        
// Representation of VisitorExposed  
{
  "id": "visitor_1",
  "anonymousId": null,
  "context": {
    "sdk_firstTimeInit": false,
    "sdk_deviceLanguage": "fr_US",
    "sdk_deviceType": "Mobile",
    "sdk_deviceModel": "iPhone",
    "sdk_osName": "ios",
    "sdk_osVersionName": "ios",
    "sdk_fsVersion": "2.1.0,",
    "customer": "QA",
    "country": "FR"
  }
}

// Representation of ExposedFlag 
{
  "key": "btnColor",
  "value": "Green",
  "metadata": {
    "campaignId": "cfv24sokqu3h6tka0sv0",
    "variationGroupId": "cfv24sokqu3h6tka0t00",
    "variationId": "cfv24sokqu3h6tka0t10",
    "isReference": false,
    "campaignType": "ab",
    "slug": null
  }
}

// import package
import 'package:flagship/flagship.dart';

//////////////////////////////////////////////
///////        Create visitor          ///////
//////////////////////////////////////////////

// Start SDK
await Flagship.start("your_env_id", "your_api_key");

Visitor visitor1 =
      Flagship.newVisitor(visitorId:"visitor_1",hasConsented: true)
              .withContext({"isVip": true})
              .isAuthenticated(true).build();

// import package
import 'package:flagship/flagship.dart';

/////////////////////////////////////////////////////////////
// Create visitor when SDK is ready, using the statusListener
/////////////////////////////////////////////////////////////

    FlagshipConfig customConfig = ConfigBuilder()
        .withMode(Mode.DECISION_API)
        .withStatusListener((newStatus) {
          // When the status is Ready
          if (newStatus == Status.READY) {
            // Get the current visitor
            if (Flagship.getCurrentVisitor() == null) {
              // Create new visitor when the current visitor is null
              // By default the created visitor is a shared instance
              Flagship.newVisitor("user")
                  .withContext({"isVip": true})
                  .hasConsented(true)
                  .isAuthenticated(true)
                  .build();
            }
            // Fetch flags
            Flagship.getCurrentVisitor()?.fetchFlags().whenComplete(() {
              // Do things
            });
          }
        })
        .withTimeout(2500)
        .withLogLevel(Level.ALL)
        .build();

    // Start SDK
    Flagship.start(
        "your_env_id", "your_api_key",
        config: customConfig);

// import package
import 'package:flagship/flagship.dart';

//////////////////////////////////////////
/////// set the current visitor //////////
//////////////////////////////////////////

// Create not shared instance visitor
Visitor newVisitor = Flagship.newVisitor(visitorId: "visitor_1",hasConsented: true, instanceType: Instance.NEW_INSTANCE)
        						.withContext({"isVip": true})
        						.isAuthenticated(true)
        						.build();

// Set as current visitor
Flagship.setCurrentVisitor(newVisitor);

// import package
import 'package:flagship/flagship.dart';

//////////////////////////////////////////
/////// Get the current visitor //////////
//////////////////////////////////////////

var visitor = Flagship.getCurrentVisitor();

// Get the current status for the SDK
   var currentStatus = Flagship.getStatus();

// Using getStatus to check if the SDK is SDK_INITIALIZED

// Create the visitor 
   var visitor = Flagship.newVisitor(visitorId: "user1", hasConsented: true).withContext({"isVip":true}).build();

// Fetch Flags the modifications 
   visitor.fetchFlags().whenComplete(() {
    
// Get the status and check the mode
   Status currentState =  Flagship.getStatus();
    if (currentState == Status.SDK_INITIALIZED) {
      // The SDK is INITIALIZED
    }
  });

// import package
import 'package:flagship/flagship.dart';

//////////////////////////////
/////// Update context ///////
//////////////////////////////

var currentVisitor = Flagship.getCurrentVisitor();

// Update context with key/value
currentVisitor?.updateContext("lastPurchaseDate", 1615384464);

// Update context with Map
currentVisitor?.updateContextWithMap({"isVip": true, "key1": 12.5, "key2": "title", "key3": 2});

// Update the location country
currentVisitor?.updateFlagshipContext(FlagshipContext.LOCATION_COUNTRY, "FRANCE");

// Update the carrier name
currentVisitor?.updateFlagshipContext(FlagshipContext.CARRIER_NAME, "SFR");

// Import package
import 'package:flagship/flagship.dart';

/////////////////////////////
/////// Clear context ///////
/////////////////////////////

var currentVisitor = Flagship.getCurrentVisitor();

currentVisitor?.clearContext();

/////////////////////////////////////////
///////     Fetch Flags           ///////
/////////////////////////////////////////

import 'package:flagship/flagship.dart';
// Get the current visitor
var currentVisitor = Flagship.getCurrentVisitor();
// Fetch Flags
currentVisitor?.fetchFlags().whenComplete(() {
  // The fetch is done.
  // If the panic mode is ON or the fetch fail for another reason
  // the value for flag will be a default value
});

enum FlagStatus { 
  // The flags are fetched from the API or re-evaluated in bucketing mode and up to date.
  FETCHED, 
  // Flags are currently being fetched from the API or re-evaluated in bucketing mode.
  FETCHING, 
  // Flags need to be re-fetched due to a change in the visitor context, visitor authentication or because the flags were loaded from cache.
  FETCH_REQUIRED,
  // The SDK is in PANIC mode: All features are disabled except for the one to fetch flags. Flags default value will be returned.
  PANIC 
}

Visitor visitor = Flagship.newVisitor(
        visitorId: "visitor",
        hasConsented: true,)
    .withContext({"isVip": true}))
    .build();
// Get visitor status before fetching
visitor.flagStatus; // The value should be FETCH_REQUIRED
// Fetch Flags
visitor.fetchFlags().whenComplete(() {
  visitor.flagStatus; // The value should be FETCHED, we assume no error occured during the fetch
});

enum FetchFlagsRequiredStatusReason {
  // Indicate that the visitor is created for the first time or without cache
  FLAGS_NEVER_FETCHED,
  // Indicates that a context has been updated or changed.
  VISITOR_CONTEXT_UPDATED,
  // Indicates that the XPC method 'authenticate' has been called.
  VISITOR_AUTHENTICATED,
  // Indicates that the XPC method 'unauthenticate' has been called.
  VISITOR_UNAUTHENTICATED,
  // Indicates that fetching flags has failed.
  FLAGS_FETCHING_ERROR,
  // Indicates that flags have been fetched from the cache.
  FLAGS_FETCHED_FROM_CACHE,
  // No reason; the state should be  FETCHED,  FETCHING, PANIC
  NONE
}

import 'package:flagship/flagship.dart';
import 'package:flagship/status.dart';

// Create Visitor 
Visitor visitor = Flagship.newVisitor(
        visitorId: "visitor",
        hasConsented: true,)
        .withContext({"isVip": true})
        .build();
// Get visitor status before fetching
visitor.flagStatus; // The value should be FETCH_REQUIRED
// Get reason status before fetching
visitor.fetchReasons; // The value should be FLAGS_NEVER_FETCHED
// Fetch Flags
visitor.fetchFlags().whenComplete(() {
      visitor.flagStatus; // The value should be FETCHED, we assume no error occured during the fetch
      visitor.fetchReasons; // The value should be None
});

////////////////////////////////
///////    Get Flag      ///////
////////////////////////////////

import 'package:flagship/flagship.dart';
import 'package:flagship/model/flag.dart';

// Get the current visitor
    var currentVisitor = Flagship.getCurrentVisitor();

// Fetch flags
    currentVisitor?.fetchFlags().whenComplete(() {
      // Ex: get flag for vip feature
      Flag flag = currentVisitor.getFlag("displayVipFeature");
    });

// The getFlag function can be directly called through the "currentVisitor" instance if you
// already fetched it elsewhere in the application

//////////////////////////////////////
/////// Manage visitor consent ///////
//////////////////////////////////////

// Create visitor with NO consent
var visitor = Flagship.newVisitor(visitorId: "user1", hasConsented: false).withContext({"isVip":true}).build()
// Set the consent to true on run time
visitor.setConsent(true);

// Create visitor with random_Id
  Visitor visitor = Flagship.newVisitor(visitorId: "random_Id", hasConsented: true).withContext({"isVip": true}).build();
// Fetch flags
  visitor.fetchFlags().whenComplete(() {
    // .. Do things
  });

// Example
// You fetch the visitor_id from your DB
// let visitorId = db.getUserId();

// Authenticate
   visitor.authenticate("visitorId");

// Since your visitor has changed (is now logged-in)
// You have to check if the proper targeting and flags are set

  visitor.fetchFlags().whenComplete(() {
    // .. Do things
  });

// Unauthenticate
  visitor.unauthenticate();

// Since your visitor has changed (is now logged-out)
// You have to check if the proper targeting and flags are set
  visitor.fetchFlags().whenComplete(() {
    // .. Do things
  });

// Create a visitor
Visitor visitor = Flagship.newVisitor(visitorId: "random_Id", hasConsented: true).withContext({"isVip": true}).build();

// Fetch flags
  visitor.fetchFlags().whenComplete(() {
     // ... Do things ....
   });

// You fetch the visitor_id from your DB
// let visitorId = db.getUserId();

// Call the authenticate function
 visitor.authenticate("visitorId");

// Fetch the flags to update the visitor decision
   visitor.fetchFlags().whenComplete(() {
      // ... Do things ....
   });

// If you want to unauthenticate the visitor
   visitor.unauthenticate();

// Fetch the flags to update the visitor decision
visitor.fetchFlags().whenComplete(() {
  // ... Do things ....
});

import 'package:flagship/flagship.dart';
import 'package:flagship/model/flag.dart';

// Get the current visitor
 var currentVisitor = Flagship.getCurrentVisitor();
// Fetch flags
   currentVisitor?.fetchFlags().whenComplete(() {
     // Ex: get flag for vip feature
     Flag flag = currentVisitor.getFlag("displayVipFeature");
     // Use this flag value to enable displaying the vip feature
     // The default value is false
     bool shouldDisplayVipFeature = flag.value(false);
   });

import 'package:flagship/flagship.dart';
import 'package:flagship/model/flag.dart';

// Get the current visitor
   var currentVisitor = Flagship.getCurrentVisitor();

// Fetch flags
   currentVisitor?.fetchFlags().whenComplete(() {
   // Ex: get flag for vip feature
   Flag flag = currentVisitor.getFlag("displayVipFeature", false);

   // Use this flag value to enable displaying the vip feature
   bool shouldDisplayVipFeature = flag.value();
      
   // Use this flag to get the metadata      
       FlagMetadata metadata = flag.metadata();
   });

// Get the current visitor
   var currentVisitor = Flagship.getCurrentVisitor();

// Fetch flags
   currentVisitor?.fetchFlags().whenComplete(() {
   // Ex: get flag for vip feature
   Flag flag = currentVisitor.getFlag("displayVipFeature");

   // Use this flag value to enable displaying the vip feature with expose to false
   bool shouldDisplayVipFeature = flag.value(true, visitorExposed: false);
      
   // Expose this flag later in the code
   flag.visitorExposed();
   });

// Get the current visitor
   var currentVisitor = Flagship.getCurrentVisitor();

// Fetch flags
   currentVisitor?.fetchFlags().whenComplete(() {
      
   // Ex: get flag for vip feature and check if it exists
      bool isDisplayVipFeatureExists = currentVisitor.getFlag("do_not_exists").exists();
   });
 }

{
  {
    "key":"btnTitle",
    "campaignId": "xxxxxxxxxx",
    "campaignName": "xxxxxxx",
    "variationGroupdId": "xxxxxxxxxx",
    "variationGroupName": "xxxxxxxxx",
    "variationId": "xxxxxxxxxx",
    "isReference": false,
    "campaignType": "ab",
    "slug": "xxxx"
   },
   {
    "key":"btnColor",
    "campaignId":"xxxxxxxxxx",
    "campaignName": "xxxxxxx",
    "variationGroupdId":"xxxxxxxxxx",
    "variationGroupName":"xxxxxxxxx",
    "variationId":"xxxxxxxxxx",
    "isReference": false,
    "campaignType": "ab",
    "slug": "xxxx"
   }
}

// User get all flag
FlagCollection flagCollection = visitor.getFlags();
// Apply filter
var result = flagCollection.filter((keyFlag, flag){
          return flag.metadata().campaignId == "Original";
 });
 // result will contain a flag that correspond to the condition : variationName == "Original"

// User get flag collection
FlagCollection flagCollection = visitor.getFlags();
// Apply forEach
// Expose flags associated with the variationName == "Original"
flagCollection.forEach((keyFlag, flag) {
  if (flag.metadata().campaignName == "Original") {
       flag.visitorExposed();
     }
});

// Implement IHitCacheImplementation
class CustomCacheHit with IHitCacheImplementation {
  @override
  void cacheHits(Map<String,Object> hits) {
     // Save the Map that represent {"hitId": {data hit}}
  }

  @override
  void flushAllHits() {
    // Remove all hits in database    
  }

  @override
  void flushHits(List<String> hitIds) {
    // Remove the hit's id given with List 
  }

  @override
  Future<List<Map>> lookupHits()async {
    // Return the saved hit in your database

  }
}

// Implement IVisitorCacheImplementation

class CustomVisitorCache with IVisitorCacheImplementation {
  @override
  void cacheVisitor(String visitorId, String jsonString) {
     // Save the json that represent the data information for visitorId
  }

  @override
  void flushVisitor(String visitorId) {
    // Remove the data for visitorId
  }

  @override
  Future<String> lookupVisitor(String visitoId) async {
    // Return the saved data to visitorId

  }
}

 // Create a config object and specify the custom hit and custom visitor
    var config = ConfigBuilder()
        .withCacheHitManager(CustomCacheHit())
        .withCacheVisitorManager(CustomVisitorCache())
        .build();
    
// Start the SDK with the config 
   await Flagship.start("envId", "apiKey", config: config);

//////////////////////////
/////// Screen hit ///////
//////////////////////////

var visitor = Flagship.getCurrentVisitor();
// Send screen hit 
visitor?.sendHit(Screen(location: "My page"));

//////////////////////////
/////// Page  hit ///////
//////////////////////////

var visitor = Flagship.getCurrentVisitor();
// Send page hit 
visitor?.sendHit(Page(location: "https://www.my_domain_com/my_page"));

///////////////////////////////
/////// Transaction hit ///////
///////////////////////////////

var visitor = Flagship.getCurrentVisitor();
visitor?.sendHit(Transaction(
  transactionId   : "YOUR_TRANSACTION_ID",
  affiliation     : "GOAL_NAME", // The goal name set in Flagship campaign
  revenue         :	100,
  shipping        :	10,
  tax             :	5,
  currency        : "EUR",
  couponCode      : "discount",
  paymentMethod   : "Card",
  shippingMethod  : "postal",
  itemCount       : 2,
));

////////////////////////
/////// Item hit ///////
////////////////////////

var visitor = Flagship.getCurrentVisitor();
visitor?.sendHit(Item(
  transactionId	: "YOUR_TRANSACTION_ID",
  name					: "item name",
  code					: "item code",
  price					: 10.5,
  quantity			: 5,
  category			: "item category"
));

/////////////////////////
/////// Event hit ///////
/////////////////////////

var visitor = Flagship.getCurrentVisitor();
visitor?.sendHit(Event(
  action		: "Event action", // The name of the goal defined in your campaign
  category	: EventCategory.Action_Tracking,
  label			: "custom label",
  value			: 2
));