/**
 * This example uses the SDK to create a brand connection, register the agent as online and accept any ring in waiting state.
 * Then it publishes a welcome message.
 */

const lpm = require('lp-messaging-sdk');
const config = require('./config.json');

const connection = lpm.createConnection({
    appId: config.appId, // Please change to something unique to your application
    accountId: config.accountId,
    userType: lpm.UserType.BRAND,
    authData: config.authData
});

// Define ring callback *before* opening the connection, to ensure no lost events
connection.on('ring', async ring => {
    console.log('ring?');
    if (ring.ringState !== lpm.RingState.WAITING) {
        console.log(`Ring is already in state ${ring.ringState}, ignoring`);
        return;
    }

    await ring.accept();
    console.log('Ring accepted!');
});

connection.on('conversation', async conversation => {
    console.log('conversation received');
    // Emit message only when an assigned agent is added, which in our basic example emulates the bot itself
    conversation.on('participant-added', async participant => {
        if (participant.participant.role === lpm.ParticipantRole.ASSIGNED_AGENT) {
            await conversation.sendMessage('I accepted the ring, how may I help you?');
        }
    })
});

(async() => {
    console.log('Connecting brand bot...');
    // Open the connection
    await connection.open();
    console.log('Brand bot connected!');

    // Register to be able to accept rings
    await connection.createRoutingTaskSubscription();

    await connection.setAgentState({ agentState: lpm.AgentState.ONLINE });
})();

/**
 * This example uses the SDK to create a brand connection,
 * join all open conversations and close them.
 */

const lpm = require('lp-messaging-sdk');
const config = require('./config.json');

const connection = lpm.createConnection({
    appId: config.appId, // Please change to something unique to your application
    accountId: config.accountId,
    userType: lpm.UserType.BRAND,
    authData: config.authData
});

connection.on('conversation', async conversation => {
    try {
        await conversation.join(lpm.ParticipantRole.ASSIGNED_AGENT);
        console.log(`Joined conversation ${conversation.conversationId}`);
    } catch (error) {
        console.log(`Could not join conversation ${conversation.conversationId} due to error - ${error.message}. Will still try to close in case it's already joined.`);
    }

    try {
        await conversation.close();
        console.log(`Closed conversation ${conversation.conversationId}`);
    } catch (error) {
        console.log(`Could not close conversation ${conversation.conversationId} due to error - ${error.message}`);
    }

});

(async() => {
    console.log('Connecting brand bot...');
    // Open the connection
    await connection.open();
    console.log('Brand bot connected!');
})();

/**
 * This example uses the SDK to create a brand connection,
 * join all open conversations and send a file upon receiving a specific message.
 *
 * NOTE: the account needs `messaging.file.sharing.enabled` site setting enabled in order to share files.
 */


const lpm = require('lp-messaging-sdk');
const fs = require('fs');
const path = require('path');

const config = require('./config.json');

const connection = lpm.createConnection({
    appId: config.appId, // Please change to something unique to your application
    accountId: config.accountId,
    userType: lpm.UserType.BRAND,
    authData: config.authData
});

connection.on('conversation', async conversation => {
    try {
        await conversation.join(lpm.ParticipantRole.ASSIGNED_AGENT);
        console.log(`Joined conversation ${conversation.conversationId}`);

        conversation.on('message', async (message) => {
            if (message.body === 'upload') {
                const file = fs.readFileSync(path.resolve(__dirname, 'logo.jpg'));
                await conversation.sendMessage("sending file");
                await conversation.uploadFile(file.buffer, "upload")
                await conversation.sendMessage("done sending file");
            }
        });
    } catch (error) {
        console.log(`Could not join conversation ${conversation.conversationId} due to error - ${error.message}.`);
    }
});

(async() => {
    console.log('Connecting brand bot...');
    // Open the connection
    await connection.open();
    console.log('Brand bot connected!');
})();

/**
 * This example creates a connection, accepts a ring, awaits that the conversation to be loaded
 * and gets the last consumer message if any.
 */

const lpm = require('lp-messaging-sdk');
const config = require('./config.json');

const connection = lpm.createConnection({
  appId: config.appId, // Please change to something unique to your application
  accountId: config.accountId,
  userType: lpm.UserType.BRAND,
  authData: config.authData
});

// process the rings as they arrive
connection.on('ring', async ring => {

  // ignore old rings
  if (ring.ringState !== lpm.RingState.WAITING) return;

  // accept the ring
  await ring.accept();

  // Awaiting the conversation would pause any subsequent code. Instead, utilize then if there is code which should
  // be run without a conversation.
  ring.conversation().then(logLastConsumerMessage);

  console.log('Ring received');
});

function logLastConsumerMessage(conversation) {
  if (conversation) {
    const latestConsumerMessage = conversation.getLatestConsumerMessage();
    if (latestConsumerMessage && latestConsumerMessage.body) {
      console.log(`Last consumer message is: "${latestConsumerMessage.body}"`);
      return;
    }

    // If consumer messages has not yet arrived when the ring is accepted, subscribe to all subsequent messages
    // for the conversation and log it whenever it arrives
    conversation.on('message', (message) => {
      const latestConsumerMessage = message.conversation.getLatestConsumerMessage();
      if (!latestConsumerMessage || !latestConsumerMessage.body) {
        console.log(`Message that we have received is not a consumer message for this conversation with id: ${conversation.conversationId}`);
      } else {
        console.log(`This is the latestConsumerMessage: ${latestConsumerMessage.body} for conversation: ${conversation.conversationId}`);
      }
    });
  }
}

(async () => {
  console.log('Connecting brand bot...');
  // Open the connection
  await connection.open();
  console.log('Brand bot connected!');

  // Register to be able to accept rings
  await connection.createRoutingTaskSubscription();

  await connection.setAgentState({agentState: lpm.AgentState.ONLINE});
})();

const config = require('./config.json');

(async () => {

  // Get the credentials from the config
  const {appId, accountId, authData} = config;
  const brandConnection = lpm.createConnection({
    appId,
    accountId,
    authData,
    userType: lpm.UserType.BRAND,
  });

  brandConnection.on("error", (err) => {
    console.log("error: ", err);
  })
  await brandConnection.open();
  console.log("Running");
  await brandConnection.setAgentState({ agentState: lpm.AgentState.ONLINE });

  brandConnection.on('conversation', async conversation => {
    // join the conversation as "AGENT" role
    await conversation.join(lpm.ParticipantRole.AGENT);
    console.log("joined conversation");
    conversation.on('message', async (message) => {
      if (message.sentByCurrentUser()) return;
      await conversation.sendMessage('hello');
    });

    // listen for the close event
    conversation.on('close', () => {
      console.log('conversation closed');
    });
  })
})()

/**
 * This example showcases how credentials can be shared between multiple connections.
 */

const lpm = require("../../index");
const config = require('./config.json');

async function createBrandConnection(connectionName, appId, accountId, tokenMaintainer) {
  const connection = lpm.createConnection({
    appId,
    accountId,
    query: {
      stage:["OPEN"]
    },
    waitForReady: true,
    userType: lpm.UserType.BRAND,
    tokenMaintainer
  });
  connection.on('conversation', async conversation => {
    // Try to join the conversation
    conversation.join(lpm.ParticipantRole.AGENT).then(() => {
      // Close conversation
      console.log(`${connectionName} Connection: closing conversation ${conversation.conversationId}`);
      return conversation.close();
    }).catch(e => {
      // console.warn(e);
    });
  })
  await connection.open();
  await connection.setAgentState({agentState: lpm.AgentState.ONLINE});
  console.log(`${connectionName} Connection running`);
  return connection;
}

(async () => {
  const {appId, accountId, authData} = config;

  // Create tokenMaintainer with credentials from the config
  const tokenMaintainer = new lpm.TokenMaintainer({ accountId, authData });

  // Share the tokenMaintainer between two brand connections
  // Each connection will try to close the received conversation
  await createBrandConnection("First", appId, accountId, tokenMaintainer);
  await createBrandConnection("Second", appId, accountId, tokenMaintainer);

  // Create a new consumer connection to create new conversations
  const consumerConnection = lpm.createConnection({
    appId: config.appId,
    accountId: config.accountId,
    userType: lpm.UserType.CONSUMER
  });

  await consumerConnection.open();

  // Create a new conversation every two seconds
  setInterval(async () => {
    await consumerConnection.createConversation();
  }, 2000)
})()

/**
 * This example uses the SDK to create a brand connection,
 * join all open conversations and react to each message, based on its content
 *
 * - if it's #time, respond with current time
 * - if it's #close, close the conversation
 * - if it's something else, repeat what the consumer said
 */


const lpm = require('lp-messaging-sdk');
const config = require('./config.json');

const connection = lpm.createConnection({
    appId: config.appId, // Please change to something unique to your application
    accountId: config.accountId,
    userType: lpm.UserType.BRAND,
    authData: config.authData
});

connection.on('conversation', async conversation => {
    try {
        await conversation.join(lpm.ParticipantRole.ASSIGNED_AGENT);
        console.log(`Joined conversation ${conversation.conversationId}`);

        conversation.on('message', async (message) => {
            if (message.participant.role !== lpm.ParticipantRole.CONSUMER) {
                console.log(`Skipping non-consumer (${message.participant.role}) message!`);
                return;
            }
            if (message.body === '#time') {
                await conversation.sendMessage(`Time now is: ${new Date().toISOString()}`);
            } else if (message.body === '#close') {
                await conversation.close();
            } else {
                await conversation.sendMessage(`You said: "${message.body}"`);
            }
        });
    } catch (error) {
        console.log(`Could not join conversation ${conversation.conversationId} due to error - ${error.message}.`);
    }
});

(async() => {
    console.log('Connecting brand bot...');
    // Open the connection
    await connection.open();
    console.log('Brand bot connected!');
})();

/**
 * This example uses the SDK to create a brand connection,
 * join a conversation and if message contains #replay, lists all messages, based on the exact string:
 *
 * - #replay-all - replays all messages in the order they arrived
 * - #replay-reverse - replays all messages in reverse order
 * - #replay-system - replays only the messages sent by controller or brand-bot, in the order they arrived
 */

const lpm = require('lp-messaging-sdk');
const config = require('./config.json');

const connection = lpm.createConnection({
    appId: config.appId, // Please change to something unique to your application
    accountId: config.accountId,
    userType: lpm.UserType.BRAND,
    authData: config.authData
});

connection.on('conversation', async conversation => {
    try {
        await conversation.join(lpm.ParticipantRole.ASSIGNED_AGENT);
        console.log(`Joined conversation ${conversation.conversationId}`);

        conversation.on('message', async (message) => {
            if (message.body.includes('#replay-')) {
                const messagesInDescendingOrder = await conversation.queryMessages();
                switch (message.body) {
                    case '#replay-reverse': {
                        const messageBodies = messagesInDescendingOrder.map((msg) => msg.body);
                        await conversation.sendMessage(`Here are all messages in reverse order:\n-${messageBodies.join('\n-')}`);
                    }break;
                    case '#replay-all': {
                        const messagesInAscendingOrder = messagesInDescendingOrder.map((msg) => msg.body).reverse();
                        await conversation.sendMessage(`Here are all messages in normal order:\n-${messagesInAscendingOrder.join('\n-')}`);
                    }break;
                    case '#replay-system': {
                        const systemMessages = messagesInDescendingOrder
                            .filter((msg) => [lpm.ParticipantRole.CONTROLLER, lpm.ParticipantRole.BRAND_BOT].includes(msg.participant.role))
                            .map((msg) => msg.body)
                            .reverse();
                        await conversation.sendMessage(`Here are the system messages only:\n-${systemMessages.join('\n-')}`);
                    }
                }
            }
        });
    } catch (error) {
        console.log(`Could not join conversation ${conversation.conversationId} due to error - ${error.message}.`);
    }
});

(async() => {
    console.log('Connecting brand bot...');
    // Open the connection
    await connection.open();
    console.log('Brand bot connected!');
})();

/**
 * This example joins a conversation and, upon a certain message, transfers to specific agent.
 *
 * NOTE: You'll need the `Messaging.Transfer_To_Agent` AC Feature enabled to be enabled to be able to transfer to specific agent.
 */

const lpm = require('lp-messaging-sdk');
const originalBrandConnectionConfig = require('./config.json');

const regularBrandConnection = lpm.createConnection({
    appId: originalBrandConnectionConfig.appId, // Please change to something unique to your application
    accountId: originalBrandConnectionConfig.accountId,
    userType: lpm.UserType.BRAND,
    authData: originalBrandConnectionConfig.authData
});

//NOTE: make sure this is the same agent id as the one, described in specificSkillBrandConnectionConfig
const desiredAgentId = '4615909832';
const specificSkillBrandConnectionConfig = require('./specific-skill-config.json');

const specificSkillBrandConnection = lpm.createConnection({
    appId: specificSkillBrandConnectionConfig.appId, // Please change to something unique to your application
    accountId: specificSkillBrandConnectionConfig.accountId,
    userType: lpm.UserType.BRAND,
    authData: specificSkillBrandConnectionConfig.authData
});

regularBrandConnection.on('conversation', async conversation => {
    try {
        await conversation.join(lpm.ParticipantRole.ASSIGNED_AGENT);
        console.log(`Regular bot joined conversation ${conversation.conversationId}`);

        conversation.on('message', async message => {
            if (message.body === '#transfer') {
                // NOTE: when transferring to a specific agent, specify the whole agent id, i.e. `accountId.agentId`,
                // instead of just `agentId`.
                conversation.transfer({agentId: `${originalBrandConnectionConfig.accountId}.${desiredAgentId}`});
            }
        });
    } catch (error) {
        console.log(`Could not join conversation ${conversation.conversationId} due to error - ${error.message}.`);
    }
});

specificSkillBrandConnection.on('conversation', async conversation => {
    conversation.on('transfer-agent', async participant => {
        // Listen to events that transfer to specific agent and check only if all three criterias are fulfulled:
        // - id is the id of the agent
        // - role is assigned_agent
        // - state of the participant is still SUGGESTED (not ACTIVE, which would mean that the agent already has joined)
        if (participant.agentId === `${specificSkillBrandConnectionConfig.accountId}.${desiredAgentId}`
            && participant.role === lpm.ParticipantRole.ASSIGNED_AGENT
            && participant.state === lpm.ParticipantState.SUGGESTED) {
            await conversation.join(lpm.ParticipantRole.ASSIGNED_AGENT);
            console.log(`Specific agent bot joined conversation ${conversation.conversationId}`);
            await conversation.sendMessage('Hi, I heard you are looking for me?');
        } else {
            console.log(`ID: ${participant.agentId}; role: ${participant.role}; state: ${participant.state}`);
        }
    });
});

(async() => {
    console.log('Connecting brand bots...');

    // Open the connections
    await regularBrandConnection.open();
    console.log('Regular brand bot connected!');

    await specificSkillBrandConnection.open();
    console.log('Specific agent brand bot connected!');
})();

/**
 * This example joins a conversation and, upon a certain message, transfers to specific skill.
 */

const lpm = require('lp-messaging-sdk');
const originalBrandConnectionConfig = require('./config.json');

const regularBrandConnection = lpm.createConnection({
    appId: originalBrandConnectionConfig.appId, // Please change to something unique to your application
    accountId: originalBrandConnectionConfig.accountId,
    userType: lpm.UserType.BRAND,
    authData: originalBrandConnectionConfig.authData
});

//NOTE: make sure this skill id is assigned to the brand, using the specificSkillBrandConnectionConfig
const desiredSkillId = '4615909532';
const specificSkillBrandConnectionConfig = require('./specific-skill-config.json');

const specificSkillBrandConnection = lpm.createConnection({
    appId: specificSkillBrandConnectionConfig.appId, // Please change to something unique to your application
    accountId: specificSkillBrandConnectionConfig.accountId,
    userType: lpm.UserType.BRAND,
    authData: specificSkillBrandConnectionConfig.authData
});

regularBrandConnection.on('conversation', async conversation => {
    try {
        await conversation.join(lpm.ParticipantRole.ASSIGNED_AGENT);
        console.log(`Regular bot joined conversation ${conversation.conversationId}`);

        conversation.on('message', async message => {
            if (message.body === '#transfer') {
                conversation.transfer({skillId: desiredSkillId});
            }
        });
    } catch (error) {
        console.log(`Could not join conversation ${conversation.conversationId} due to error - ${error.message}.`);
    }
});

specificSkillBrandConnection.on('conversation', async conversation => {
    // Listen to events that transfer to skill and join if it's changing to the desired skill id
    conversation.on('transfer-skill', async (ev) => {
        if (ev.skillId === desiredSkillId) {
            await conversation.join(lpm.ParticipantRole.ASSIGNED_AGENT);
            console.log(`Specific skill bot joined conversation ${conversation.conversationId}`);
            await conversation.sendMessage('I am your new assistant!');
        }
    });
});

(async() => {
    console.log('Connecting brand bots...');

    // Open the connections
    await regularBrandConnection.open();
    console.log('Regular brand bot connected!');

    await specificSkillBrandConnection.open();
    console.log('Specific skill brand bot connected!');
})();

/**
 * This example creates a connection after a potential downtime caused by restart/disconnect or else. The bot tries to join all new conversation and respond with an message of the last existing consumer message.
 */

const lpm = require('lp-messaging-sdk');
const config = require('./config.json');

const connection = lpm.createConnection({
    appId: config.appId, // Please change to something unique to your application
    accountId: config.accountId,
    userType: lpm.UserType.BRAND,
    authData: config.authData,

    // This flag fix an issues with conversations being lost or stuck after reconnection if set to false. 
    // For more information look at this link: messaging-platform-sdk-overview.html#connection-maintenance
    unsubscribeFromOutdatedConversationsOnReconnect: false, 

    // This way you will fetch all the conversation per brand but be aware that a lot of conversations with a lot of message could cause a problem.
    // For more information look at this link: messaging-platform-sdk-overview.html#loading-all-previous-messages
    getAllMessages: true,

    // This will cause open to only resolve once all conversations have been retrieved.
    waitForReady: true,

    // By default this will fetch all the conversation from UMS even if there are more than 1001, default value is true. If you don't want to take all of them you can switch the value to false. 
    // By doing this you will have just the last 1001 conversation not more than that, but bear in mind that you can loose conversations that are open.
    limitBreakEnabled: true,
});


connection.on('conversation', async conversation => {
    try {
        await conversation.join(lpm.ParticipantRole.ASSIGNED_AGENT);
        console.log(`Joined conversation ${conversation.conversationId}`);
    } catch (error) {
        console.log(`Could not join conversation ${conversation.conversationId} due to error - ${error.message}.`);
    }
    const message = conversation.getLatestConsumerMessage();
    await conversation.sendMessage(`I will reply to this message: ${message.body} for conversation with id: ${conversation.conversationId}`);
});

(async() => {
    console.log('Connecting brand bot...');
    // Open the connection
    await connection.open();

    console.log('Brand bot connected!');

})();

const lpm = require('lp-messaging-sdk');
const config = require('./config.json');

/**
 * This example uses the SDK to create a third party bot.
 *
 * On reconnect/disconnect or manual start/stop of the bot the SDK will create the event listeners out of the box for
 * the brand. This can take a bit of time depending on the traffic of the brand and online agents.
 *
 * A few questions and answers for the routing tasks aka. rings:
 *  1. When a ring is accepted, could it be accepted by another bot/agent?
 *    - Another agent/bot could join the conversation, but it could only be accepted by (thus, assigned to) a single
 *      agent/bot.
 *  2. Do we have rings with the same ids if the conversation has been transferred in between bots/agents?
 *    - The ringId always changes on new rings. When the conversation is transferred to another agent, send back to the
 *      queue or the ring expires or is rejected, a new ring with a new id will be created.
 *  3.  If a ring is rejected by one bot/agent, can the same bot/agent receive the ring again?
 *    - Let's say you have 3 agents/bots with skillA. Agent1 rejects the ring, agent2 is ringed. If agent2 rejects the
 *      new ring, then agent3 is ringed. If agent3 rejects the new ring, then agent1 is ringed again. This means, that
 *      rings will be created until a conversation is accepted.
 *
 * By default, the system waits 30 seconds until the ring is automatically rejected. Use option`messaging.ACD.response.time`
 * to change this.
 *
 * Important, if the example bot is stopped and a new consumer conversation has been created in the meantime, then the
 * agent will not accept the conversation. It will expire after the configured amount of time (30 seconds; see above).
 * Then, if possible, another online agent will be ringed. When the example bot is restarted, it will wait for a ring
 * which will happen only after rings for other agents are expired. Depending on the eligible agents this can take a
 * while.
 *
 * Important, for this example you need to adapt your config file and add an agentId entry:
 * {
 *   "accountId": "testAccount",
 *   "agentId": "accountId.agentId",
 *   "authData": {
 *     // ...
 *   },
 *   "appId": "test-app"
 * }
 *
 * The agentId is the userId of the bot user. It is concatenation of the accountId and agentId. If you are not sure what
 * your agentId is, you can also use connection.agentId once the connection has been opened.
 */

const processedConversations = new Map();

const connection = lpm.createConnection({
  appId: config.appId, // Please change to something unique to your application
  accountId: config.accountId,
  userType: lpm.UserType.BRAND,
  authData: config.authData,

  // If set to false, this flag fixes an issue with conversations being lost or stuck after reconnection
  // For more information look at this link: messaging-platform-sdk-overview.html#connection-maintenance
  unsubscribeFromOutdatedConversationsOnReconnect: false,

  // If set to true, this will fetch all the conversation per brand but be aware that a lot of conversations with a lot of message could lead to performance issues on startup.
  // For more information look at this link: messaging-platform-sdk-overview.html#loading-all-previous-messages
  getAllMessages: true,

  // If set to true, this will cause `connection.open` to resolve only once all conversations have been retrieved.
  // This operation is time-consuming, so it can also lead to performance issues on startup.
  waitForReady: true,

  // This can be used to configure the timeout, used when fetching the conversation, assigned to the ring:
  // messaging-platform-sdk-overview.html#accepting-conversation-on-the-ring
  ringConversationTimeout: 2000,

  // Depending on the connection type (Brand or Consumer), the SDK will create a subscription for conversations by
  // default. For brand connections the SDK subscribes to all open conversations of the brand. However,
  // third party bots are acting as an agent, and, thus, are only interested in conversations which they joined. This
  // is why this option is set to false. Later in the example, there is a corresponding subscription. For more
  // information visit: messaging-platform-sdk-overview.html#the-default-subscription
  createDefaultSubscription: false
});

// Define the callbacks *before* opening the connection, to ensure no lost events
connection.on('ring', async ring => {
  if (ring.ringState !== lpm.RingState.WAITING) {
    console.log(`Ring is already in state ${ring.ringState}, ignoring for conversation: ${ring.conversationId}`);
    return;
  }

  await ring.accept();

  console.log('Ring accepted!');
  try {
    console.log('Trying to fetch conversation from the ring');
    const conversation = await ring.conversation();

    await processNewConversation(conversation);
  } catch (error) {
    console.log('Error when trying to respond to the last consumer message', error);
  }
});

connection.on('conversation', async conversation => {
  try {
    await conversation.join(lpm.ParticipantRole.ASSIGNED_AGENT);

    await processNewConversation(conversation);
    console.log(`I joined a conversation with id: ${conversation.conversationId}`);
  } catch (error) {
    console.log(`Already joined ${conversation.conversationId}`);
  }
});

/**
 * Processes new conversations.
 *
 * Use this an example of what could be implemented.
 *
 * @param conversation which should be processed
 * @returns {Promise<void>}
 */
async function processNewConversation(conversation) {
  const latestConsumerMessage = conversation.getLatestConsumerMessage();
  if (latestConsumerMessage && latestConsumerMessage.body && !processedConversations.has(conversation.conversationId)) {
    console.log(`Last consumer message is: "${latestConsumerMessage.body} and i will respond for conversation with id: ${conversation.conversationId}`);
    await conversation.sendMessage(`Message received for you conversation for this conversationId: ${conversation.conversationId}`);
    processedConversations.set(conversation.conversationId, conversation);
    deleteProcessedConversation(conversation.conversationId);
    return;
  }

  // If consumer messages have not yet arrived when the ring is accepted, subscribe to all subsequent messages
  // for the conversation and log whenever it arrives
  conversation.on('message', async (message) => {
    const latestConsumerMessage = message.conversation.getLatestConsumerMessage();
    if (!latestConsumerMessage || !latestConsumerMessage.body && !processedConversations.has(conversation.conversationId)) {
      console.log(`Message that we have received is not a consumer message for this conversation with id: ${conversation.conversationId}`);
    } else {
      await conversation.sendMessage(`Message received for you conversation for this conversationId: ${conversation.conversationId}`);
      processedConversations.set(conversation.conversationId, conversation);
      deleteProcessedConversation(conversation.conversationId);
    }
  });
}

function deleteProcessedConversation(conversationId) {
  setTimeout(() => {
    processedConversations.delete(conversationId);
  }, 60000); // You can increase according to the use case
}

(async() => {
  console.log('Connecting brand bot...');

  connection.on('error', (err) => console.log(err));
  connection.on('disconnect', () => console.log(`sdk disconnect event hit for account id: ${config.accountId}`));
  connection.on('reconnect', () => console.log(`sdk reconnect event hit for account id: ${config.accountId}`));

  // Open the connection
  await connection.open();
  console.log('Brand bot connected!');

  console.log('Subscribing to routing task subscriptions (rings)');
  // With this subscription, the bot will be ringed when there is a new conversation and the bot is eligible to join it.
  await connection.createRoutingTaskSubscription({ query: { agentId: `${config.accountId}.${config.agentId}`, accountId: config.accountId } });
  console.log('Subscribed to routing task subscriptions (rings)');

  console.log('Subscribing to conversations of this agent');
  // With this manual subscription, we ensure that we only subscribe to conversations which the agent joined.
  const query = {stage:["OPEN"], agentId: `${config.accountId}.${config.agentId}`};
  // waitForReady means that the application should block until all conversations are received before continuing.
  // In this case we set it to false. Corresponding conversations will be received but the bot will not block here.
  const waitForReady = false;
  await connection.createConversationSubscription({query, waitForReady});
  console.log('Subscribed to conversations of this agent');

  console.log('Setting Agent to online');
  await connection.setAgentState({ agentState: lpm.AgentState.ONLINE });
  console.log('Agent is online');
})();

/**
 * This is the most basic example of a consumer connection, using all default values,
 * sends a message and closes the conversation after 5 seconds
 */

const lpm = require('lp-messaging-sdk');
const config = require('./config.json');

const connection = lpm.createConnection({
    appId: config.appId, // TODO: please change to something unique to your application
    accountId: config.accountId,
    userType: lpm.UserType.CONSUMER
});

// log any internal errors (auth errors, etc)
connection.on('error', err => {
    console.error(err);
});

const waitSeconds = (time) => {
    return new Promise((resolve) => setTimeout(resolve, time * 1000));
};

(async() => {
    console.log('Connecting consumer...');

    // connect & open conversation
    await connection.open();

    console.log('Consumer connected!');

    // create conversation
    const conversation = await connection.createConversation();

    console.log('Conversation created!');

    // send a message
    await conversation.sendMessage('Example message');

    await waitSeconds(5);

    // close the main dialog
    await conversation.close();

    // close the connection
    await connection.close();

    console.log('Conversation and connection closed!');
})();

/**
 * This example creates a connection and a conversation and subscribes to messages.
 * Upon receiving a message with exact content "42" it thanks the agent and closes the conversation.
 */

const lpm = require('lp-messaging-sdk');
const config = require('./config.json');

const connection = lpm.createConnection({
    appId: config.appId, // TODO: please change to something unique to your application
    accountId: config.accountId,
    userType: lpm.UserType.CONSUMER
});

// log any internal errors (auth errors, etc)
connection.on('error', err => {
    console.error(err);
});

const waitSeconds = (time) => {
    return new Promise((resolve) => setTimeout(resolve, time * 1000));
};

(async() => {
    console.log('Connecting consumer...');

    // connect & open conversation
    await connection.open();

    console.log('Consumer connected!');

    // create conversation
    const conversation = await connection.createConversation();

    conversation.on('message', async message => {
        if (message.body === '42') {
            await conversation.sendMessage('Thank you for answering everything!');
            await conversation.close();
            await connection.close();
            console.log('Conversation and connection closed!');
        }
    });

    console.log('Conversation created!');

    await waitSeconds(2);

    // send a message
    await conversation.sendMessage('Tell me everything');
})();

/**
 * This example creates a connection, gets its token, creates a conversation and sends a message in it,
 * then closes the connection, reopens a new connection with the same token and sends another message in the same conversation
 */

const lpm = require('lp-messaging-sdk');
const config = require('./config.json');

const connection1 = lpm.createConnection({
    appId: config.appId, // TODO: please change to something unique to your application
    accountId: config.accountId,
    userType: lpm.UserType.CONSUMER
});

const waitSeconds = (time) => {
    return new Promise((resolve) => setTimeout(resolve, time * 1000));
};

(async() => {
    console.log('Connecting consumer...');

    // connect & open conversation
    await connection1.open();

    // get and store the token
    const token = await connection1.getToken();

    // create conversation
    const conversation = await connection1.createConversation();
    const conversationId = conversation.conversationId;

    console.log(`Conversation #${conversationId} created!`);

    // send a message
    await conversation.sendMessage('Example message #1 using the first connection');

    await waitSeconds(1);

    // close the first connection
    await connection1.close();

    console.log('First connection closed!');

    // open new connection with the same token
    const connection2 = lpm.createConnection({
        userType: lpm.UserType.CONSUMER,
        appId: config.appId, // TODO: please change to something unique to your application
        accountId: config.accountId,
        token,
        waitForReady: true
    });

    await connection2.open();

    console.log('Second connection created!');

    // Find the conversation based on the conversation id, in case there are many conversations in the connection
    const conversation2 = Array.from(connection2._conversations.values()).find((conversation) => conversation.conversationId === conversationId);
    await conversation2.sendMessage('Example message #2 after reopening connection with the same token');

    // close the second conversation
    await conversation2.close();

    // close the second connection
    await connection2.close();

    console.log('Second conversation and connection closed!');
})();

/**
 * This example creates a conversation for a specific skill only, and sends a message to it.
 */

const lpm = require('lp-messaging-sdk');
const config = require('./config.json');

const connection = lpm.createConnection({
    appId: config.appId, // TODO: please change to something unique to your application
    accountId: config.accountId,
    userType: lpm.UserType.CONSUMER
});


// log any internal errors (auth errors, etc)
connection.on('error', err => {
    console.error(err);
});

(async() => {
    console.log('Connecting consumer...');

    // connect & open conversation
    await connection.open();

    console.log('Consumer connected!');

    // create conversation
    const conversation = await connection.createConversation({
        skillId: config.skillId
    });

    console.log('Conversation created!');

    // send a message
    await conversation.sendMessage('Example message');
})();