/*
 * Code generated by Microsoft (R) AutoRest Code Generator.
 * Changes may cause incorrect behavior and will be lost if the code is
 * regenerated.
 */

import * as msRest from "@azure/ms-rest-js"; 
import { DefaultAzureCredential } from "@azure/identity" 
 
const getCredentials = async function (connectionString: string, userOptions?: any): Promise<[msRest.TokenCredentials, string, any]> {
  if (!connectionString) {
    throw new Error("Input 'connectionString' is missing");
  }
  /* Read and parse endpoint */
  const connectionPieces = connectionString.split(";").map((segment) => { return segment.split("=") });
  const endpointPair = connectionPieces.find((segment) => { return segment[0].toLowerCase() == "endpoint"});
  const endpoint = endpointPair && endpointPair[1];
  if (!endpoint) {
    throw new Error("Property 'endpoint' is missing from connection string");
  }
  const endpointComponents = endpoint.split("/").filter((value: string) => { return value; });
  const connectionId = endpointComponents[endpointComponents.length - 1];
  const baseUri = (endpoint.match(/(https:\/\/|http:\/\/).*(\.net|\.com)/g)|| [""])[0];
  /* Read and parse auth */
  const authPair = connectionPieces.find((segment) => { return segment[0].toLowerCase() == "auth"});
  const auth = authPair && authPair[0];
  const authValue = authPair && authPair[1];
  if (!(auth && authValue)) {
    throw new Error("Property 'auth' (or value) is missing from connection string");
  }
  let tokenCredential: msRest.TokenCredentials;
  if (authValue.toLowerCase() === "key") {
    const keyPair = connectionPieces.find((segment) => { return segment[0].toLowerCase() == "key"});
    const key = keyPair && keyPair[1];
    if (!key) {
      throw new Error("Property 'key' missing from connection string");
    }
    tokenCredential = new msRest.TokenCredentials(key, "Key");
  } else if (authValue.toLowerCase() === "managed") {
    const creds = new DefaultAzureCredential();
    const accessToken = await creds.getToken("https://management.core.windows.net/"); 
    tokenCredential = new msRest.TokenCredentials((accessToken && accessToken.token) || "", "Bearer");
  } else {
    throw new Error("Auth value is " + authValue + " instead of 'key' or 'managed'");
  }
  return [ tokenCredential, connectionId, Object.assign({ baseUri }, userOptions) ];
}
   
 
let _connectorClient: OutlookConnector  | undefined;
 export const createOutlookConnector  = async function(connectionString: string, options?: Models.OutlookConnectorOptions): Promise<OutlookConnector > {
  const creds = await getCredentials(connectionString);
  if (!_connectorClient) {
    _connectorClient = new OutlookConnector (...creds);
  } 
  return _connectorClient;
}
  
import * as Models from "./models";
import * as Mappers from "./models/mappers";
import * as Parameters from "./models/parameters";
import * as operations from "./operations";
import { OutlookConnectorContext } from "./outlookConnectorContext";

class OutlookConnector extends OutlookConnectorContext {
  // Operation groups
  events: operations.Events;
  mail: operations.Mail;
  optionsEmail: operations.OptionsEmail;
  calendarsTable: operations.CalendarsTable;
  calendarsTableData: operations.CalendarsTableData;
  contactsTable: operations.ContactsTable;
  contactsTableData: operations.ContactsTableData;

  /**
   * Initializes a new instance of the OutlookConnector class.
   * @param connectionId Unique identifier of the connection instance
   * @param credentials Subscription credentials which uniquely identify client subscription.
   * @param [options] The parameter options
   */
  constructor(credentials: msRest.ServiceClientCredentials, connectionId: string, options?: Models.OutlookConnectorOptions) {
    super(credentials, connectionId, options);
    this.events = new operations.Events(this);
    this.mail = new operations.Mail(this);
    this.optionsEmail = new operations.OptionsEmail(this);
    this.calendarsTable = new operations.CalendarsTable(this);
    this.calendarsTableData = new operations.CalendarsTableData(this);
    this.contactsTable = new operations.ContactsTable(this);
    this.contactsTableData = new operations.ContactsTableData(this);
  }

  /**
   * Respond to an event invite.
   * @summary Respond to an event invite
   * @param eventId Id of the event to respond to.
   * @param response Response for the event invite. Possible values include: 'Accept', 'Tentatively
   * Accept', 'Decline'
   * @param [options] The optional parameters
   * @returns Promise<msRest.RestResponse>
   */
  respondToEvent(eventId: string, response: Models.Response1, options?: Models.OutlookConnectorRespondToEventOptionalParams): Promise<msRest.RestResponse>;
  /**
   * @param eventId Id of the event to respond to.
   * @param response Response for the event invite. Possible values include: 'Accept', 'Tentatively
   * Accept', 'Decline'
   * @param callback The callback
   */
  respondToEvent(eventId: string, response: Models.Response1, callback: msRest.ServiceCallback<void>): void;
  /**
   * @param eventId Id of the event to respond to.
   * @param response Response for the event invite. Possible values include: 'Accept', 'Tentatively
   * Accept', 'Decline'
   * @param options The optional parameters
   * @param callback The callback
   */
  respondToEvent(eventId: string, response: Models.Response1, options: Models.OutlookConnectorRespondToEventOptionalParams, callback: msRest.ServiceCallback<void>): void;
  respondToEvent(eventId: string, response: Models.Response1, options?: Models.OutlookConnectorRespondToEventOptionalParams | msRest.ServiceCallback<void>, callback?: msRest.ServiceCallback<void>): Promise<msRest.RestResponse> {
    return this.sendOperationRequest(
      {
        eventId,
        response,
        options
      },
      respondToEventOperationSpec,
      callback);
  }

  /**
   * Forward an email.
   * @summary Forward an email
   * @param messageId Id of the message to forward.
   * @param body Direct forward message.
   * @param [options] The optional parameters
   * @returns Promise<msRest.RestResponse>
   */
  forwardEmail(messageId: string, body: Models.DirectForwardMessage, options?: msRest.RequestOptionsBase): Promise<msRest.RestResponse>;
  /**
   * @param messageId Id of the message to forward.
   * @param body Direct forward message.
   * @param callback The callback
   */
  forwardEmail(messageId: string, body: Models.DirectForwardMessage, callback: msRest.ServiceCallback<void>): void;
  /**
   * @param messageId Id of the message to forward.
   * @param body Direct forward message.
   * @param options The optional parameters
   * @param callback The callback
   */
  forwardEmail(messageId: string, body: Models.DirectForwardMessage, options: msRest.RequestOptionsBase, callback: msRest.ServiceCallback<void>): void;
  forwardEmail(messageId: string, body: Models.DirectForwardMessage, options?: msRest.RequestOptionsBase | msRest.ServiceCallback<void>, callback?: msRest.ServiceCallback<void>): Promise<msRest.RestResponse> {
    return this.sendOperationRequest(
      {
        messageId,
        body,
        options
      },
      forwardEmailOperationSpec,
      callback);
  }
}

// Operation Specifications
const serializer = new msRest.Serializer(Mappers);
const respondToEventOperationSpec: msRest.OperationSpec = {
  httpMethod: "POST",
  path: "apim/outlook/{connectionId}/codeless/api/v2.0/me/events/{event_id}/{response}",
  urlParameters: [
    Parameters.connectionId,
    Parameters.eventId,
    Parameters.response
  ],
  requestBody: {
    parameterPath: [
      "options",
      "body"
    ],
    mapper: Mappers.ResponseToEventInvite
  },
  responses: {
    202: {},
    default: {}
  },
  serializer
};

const forwardEmailOperationSpec: msRest.OperationSpec = {
  httpMethod: "POST",
  path: "apim/outlook/{connectionId}/codeless/api/v2.0/me/messages/{message_id}/forward",
  urlParameters: [
    Parameters.connectionId,
    Parameters.messageId1
  ],
  requestBody: {
    parameterPath: "body",
    mapper: {
      ...Mappers.DirectForwardMessage,
      required: true
    }
  },
  responses: {
    202: {},
    default: {}
  },
  serializer
};

export {
  OutlookConnector,
  OutlookConnectorContext,
  Models as OutlookConnectorModels,
  Mappers as OutlookConnectorMappers
};
export * from "./operations";