const { Toolbelt } = require("lp-faas-toolbelt");
const sfClient = Toolbelt.SFClient(); // for API docs look @ https://jsforce.github.io/

//This will establish a connection with SF. And leverage Access Token / Refresh Token to login
const con = sfClient.connectToSalesforce({
  loginUrl: "https://test.salesforce.com",
  accessToken: "PROVIDE_YOUR_ACCESS_TOKEN", //Obtain it from Secret Store
  refreshToken: "PROVIDE_YOUR_REFRESH_TOKEN" // Obtain it from Secret Store
});

con.query(query, function(err, queryResult) {});

  // Importing the FaaS Toolbelt
  const { Toolbelt } = require("lp-faas-toolbelt");
  // Obtain an HTTPClient Instance from the Toolbelt
  const httpClient = Toolbelt.HTTPClient(); // For API Docs look @ https://www.npmjs.com/package/request-promise
  httpClient("https://github.com/", {
    method: "GET", // HTTP VERB
    headers: {}, // Your Headers
    simple: false, // IF true => Status Code != 2xx & 3xx will throw
    resolveWithFullResponse: true //IF true => Includes Status Code, Headers etc.
  })
.then(response => {
	...
})
.catch(err => {
  ...
})

  // Importing the FaaS Toolbelt
  const { Toolbelt } = require("lp-faas-toolbelt");
  // Configure MTLSClient with cert & key bundle in PEM format. 
  // Optional you can provide CA-Cert (PEM-Format) in case upstream cert is self-signed 
  // Also a soft format check is performed, which will throw an error if failing. Make sure to catch it.
  const mtlsClient = Toolbelt.MTLSClient({cert: 'cert-string', key: 'key-string'});
  mtlsClient.post('https://your-mtls-endpoint.com', { header: 'test'}, null, {
    json: true, // If true will attempt to parse response body to JSON
    timeout: 10000, // Deadline for request to finish by in MS
    allowSelfSigned: false, // Allow the upstream cert to be self-signed
    })
  .then(response => {
    ...
  })
  .catch(err => {
    ...
  })

const { Toolbelt, LpServices } = require("lp-faas-toolbelt");

// Obtain an LpClient instance from the Toolbelt
const lpClient = Toolbelt.LpClient();

/**
 * Same options as the HTTPClient
 * For possible options look @ https://github.com/request/request#requestoptions-callback
 */
const options = {
    method: "POST",
    body: {
        conversationId
    },
    json: true,
    /** insert the name of your custom authentication secret here - Use only
    *   if you want to bypass the default API-key and understand the ramifications.
    */
    appKeySecretName: 'my-custom-secret-name'
}

lpClient(
  LpServices.MSG_HIST, // LP service name
  `/messaging_history/api/account/${process.env.BRAND_ID}/conversations/conversation/search`, // endpoint of the service
  options // options
)
.then(response => {
	...
})

// import FaaS Toolbelt
const { Toolbelt } = require("lp-faas-toolbelt");
// obtain SecretClient from Toolbelt
const secretClient = Toolbelt.SecretClient();
// this is how you can access your stored secret
secretClient
  .readSecret("my_Secret-Key")
  .then(mySecret => {
    // Fetching the secret value
    const value = mySecret.value;
    // you can also update your secret e.g. if you received a new OAuth2 token
    mySecret.value = "nEw.oaUtH2-tOKeN!!11!";
    return secretClient.updateSecret(mySecret);
  })
  .then(_ => {
    callback(null, { message: "Successfully updated secret" });
  })
  .catch(err => {
    console.error(`Failed during secret operation with ${err.message}`);
    callback(err, null);
  });

    const { Toolbelt } = require("lp-faas-toolbelt");
    const client = Toolbelt.OrchestratorClient();
    const invocations = [
        { 
            uuid: "your_function_uuid",
            payload: {},
            headers: {}
        },
    ];
    const responses = await client.invoke(
        invocations,
        25000
    );
    const response = responses[0];
    console.info(response.uuid);
    console.info(response.body);
    console.info(response.headers);
    console.info(response.statusCode);
    console.info(response.error);

    const { Toolbelt, ErrorStrategy } = require("lp-faas-toolbelt");
    const client = Toolbelt.OrchestratorClient();
    const RETRIABLE_NETWORK_ERRORS = ['ENOTFOUND', 'ECONNRESET', 'ETIMEDOUT', 'ESOCKETTIMEDOUT'];
    const RETRIABLE_ERROR_CODES = [500, 502, 504];
    // only retry on some 5xx status codes and network errors
    const retryFunction = (statusCode, error) => {
        return RETRIABLE_ERROR_CODES.includes(statusCode) || RETRIABLE_NETWORK_ERRORS.includes(error.cause.code);
    }
    const invocations = [
        { 
            uuid: "your_first_function_uuid",
            payload: {},
            headers: {},
            retries: 3,
            retryFunction
        },
        { 
            uuid: "your_second_function_uuid",
            payload: {},
            headers: {},
            retries: 3,
            retryFunction
        },
    ];
    const responses = await client.invoke(
        invocations,
        25000,
        {
            timeout: 10000,
            // both invocations will be executed in parallel
            invokeParallel: true,
            errorStrategy: ErrorStrategy.CONTINUE_ON_ERROR
        }
    );
    const response = responses[0];
    console.info(response.uuid);
    console.info(response.body);
    console.info(response.headers);
    console.info(response.statusCode);
    console.info(response.error);

  // import FaaS Toolbelt
  const { Toolbelt, ConversationContentTypes } = require("lp-faas-toolbelt");

  // Create instance
  const conversationUtil = Toolbelt.ConversationUtil();

  // Define Parameters
  const conversationId = "c911f008-4761-4f43-95445-6948017eace5"
  const contentToRetrieve = [
    ConversationContentTypes.SDES,
    ConversationContentTypes.UNAUTH_SDES
  ]

  // Get conversation
  conversationUtil.getConversationById(conversationId, contentToRetrieve)
  .then(conversation => {}) //TODO: react to the response
  .catch(err => {}); //TODO: React to error

// import FaaS Toolbelt
const { Toolbelt } = require("lp-faas-toolbelt");

// Create instance
const conversationUtil = Toolbelt.ConversationUtil();

// Get conversation
const conversation = await conversationUtil.getConversationById(conversationId);

// Determine Keywords
const keywords = ["Keyword", "awesome"];

// Scan Conversation for Keywords
const scannerResult = conversationUtil.scanConversationForKeywords(
  conversation,
  keywords
);

[
  {
    message: "Will we use Keywords in this conversation?",
    sentTimestamp: 1560764690328,
    sentBy: "Consumer",
    tag: "keywordRef:Keyword"
  },
  {
    message: "We definitely will, because keywords are awesome!",
    sentTimestamp: 1560764734592,
    sentBy: "Agent",
    tag: "keywordRef:Keyword"
  },
  {
    message: "We definitely will, because keywords are awesome!",
    sentTimestamp: 1560764734592,
    sentBy: "Agent",
    tag: "keywordRef:awesome"
  }
];

// import FaaS Toolbelt
const { Toolbelt } = require("lp-faas-toolbelt");

// set file storage credentials (get from Account Manager)
const fileStorageCredentials = {
  username: '...',
  password: '...'
}

// Create instance
const conversationUtil = Toolbelt.ConversationUtil();

// Create GDPR Util instance
const gdprUtil = Toolbelt.GDPRUtil();
const shouldReplace = (filePath) => ... // filter here by returning boolean
const replacementFile = {
  body: Buffer.from('...', 'base64'), // create file from base64
  contentType: 'image/png',
};

// Get conversation and replace files
conversationUtil.getConversationById(conversationId)
  .then(conversation => gdprUtil.replaceConversationFiles(
        conversation,
        fileStorageCredentials,
        shouldReplace, //(optional) defaults to (path) => true
        replacementFile, //(optional) defaults to a black 1px*1px png
  ))
  .then(replacedFiles => //TODO: react on the response)
  .catch(err => //TODO: React to error);

  // import FaaS Toolbelt
  const { Toolbelt, SDETypes } = require("lp-faas-toolbelt");

  // Create instance
  const sdeUtil = Toolbelt.SDEUtil();

  // Define parameters
  const visitorId = "YyY2RlZGY3NzZjYoJhZGQx";
  const sessionId = "bjfYkPt-SYCqqZWDHNwSKQ";
  const sdes = [
    {
        type: SDETypes.PERSONAL_INFO,
        personal: {
            contacts: [
                {
                    email: "john.doe@example.com"
                }
            ]
        }
    }
  ];

  // Add SDEs
  sdeUtil.addSDEs(sdes, visitorId, sessionId)
  .then(response => {}) //TODO: react to the response
  .catch(err => {}); //TODO: React to error

  // import FaaS Toolbelt
  const { Toolbelt, ConversationContentTypes } = require("lp-faas-toolbelt");

  // Create SDE/Conversation-Util instance
  const conversationUtil = Toolbelt.ConversationUtil()
  const sdeUtil = Toolbelt.SDEUtil();

  // Define parameters
  const conversationId = "c944f008-4761-4f43-9536-6948017eace5";
  const contentToRetrieve = [
    ConversationContentTypes.SDES,
    ConversationContentTypes.UNAUTH_SDES
  ]

  // Get Conversation and extract SDEs
  conversationUtil.getConversationById(conversationId, contentToRetrieve)
  .then(conversation => {
    // TODO: define how to procede with the SDEs
    const sdes = sdeUtil.getSDEsFromConv(conversation);
  })
  .catch(err => {}); //TODO: React to error

{
        sdes: {
            events: [
                {
                    customerInfo: {
                      ...
                    },
                    serverTimeStamp: 1569572377158,
                    sdeType: 'CUSTOMER_INFO',
                },
                {
                    personalInfo: {
                      ...
                    },
                    serverTimeStamp: 1569572377270,
                    sdeType: 'PERSONAL_INFO',
                },
            ],
        },
        unAuthSdes: {
            events: [
                {
                    customerInfo: {
                        ...
                    },
                    serverTimeStamp: 1569574433640,
                    sdeType: 'CUSTOMER_INFO',
                },
                {
                    customerInfo: {
                        ...
                    },
                    serverTimeStamp: 1569574433640,
                    sdeType: 'CUSTOMER_INFO',
                },
                {
                    personalInfo: {
                        ...
                    },
                    serverTimeStamp: 1569574433865,
                    sdeType: 'PERSONAL_INFO',
                },
            ],
        },
    }

    const { Toolbelt } = require('lp-faas-toolbelt');
    // creating a secretClient instance
    const secretClient = Toolbelt.SecretClient();
    
    try {
      // retrieving your developer key from the secret storage
      const { value: apiKey } = await secretClient.readSecret('YOUR_DEVELOPER_KEY_SECRET_NAME');
      // retrieving your account ID via e.g. env variable
      const accountId = process.env.BRAND_ID
      const config = {accountId, apiKey}

      // using the config to instantiate the contextServiceClient
      const contextClient = Toolbelt.ContextServiceClient(config);
    } catch(error) {
      // Handle error based on your integration by providing a legit fallback operation.
      console.error(`received following error message: ${error.message}`);
    }