context: using System;
  using System.Collections.Generic;
  using System.Globalization;
  using System.Text.RegularExpressions;
  using System.IO;
  using System.Web;
  using System.Linq;
  using System.Net;
  using System.Text;
  using Newtonsoft.Json;
  using RestSharp;
  using RestSharp.Extensions;
  
  namespace IO.Swagger.Client
  {
      /// <summary>
      /// API client is mainly responible for making the HTTP call to the API backend.
      /// </summary>
      public class ApiClient
      {
          private readonly Dictionary<String, String> _defaultHeaderMap = new Dictionary<String, String>();
    
          /// <summary>
          /// Initializes a new instance of the <see cref="ApiClient" /> class.
          /// </summary>
          /// <param name="basePath">The base path.</param>
          public ApiClient(String basePath="https://app.quantimo.do/api/v2")
          {
              BasePath = basePath;
              RestClient = new RestClient(BasePath);
          }
      
          /// <summary>
          /// Gets or sets the base path.
          /// </summary>
          /// <value>The base path</value>
          public string BasePath { get; set; }
      
          /// <summary>
          /// Gets or sets the RestClient.
          /// </summary>
          /// <value>An instance of the RestClient</value>
          public RestClient RestClient { get; set; }
      
          /// <summary>
          /// Gets the default header.
          /// </summary>
          public Dictionary<String, String> DefaultHeader
          {
              get { return _defaultHeaderMap; }
          }
      
          /// <summary>
          /// Makes the HTTP request (Sync).
          /// </summary>
          /// <param name="path">URL path.</param>
          /// <param name="method">HTTP method.</param>
          /// <param name="queryParams">Query parameters.</param>
          /// <param name="postBody">HTTP body (POST request).</param>
          /// <param name="headerParams">Header parameters.</param>
          /// <param name="formParams">Form parameters.</param>
          /// <param name="fileParams">File parameters.</param>
          /// <param name="authSettings">Authentication settings.</param>
          /// <returns>Object</returns>
          public Object CallApi(String path, RestSharp.Method method, Dictionary<String, String> queryParams, String postBody,
              Dictionary<String, String> headerParams, Dictionary<String, String> formParams, 
              Dictionary<String, FileParameter> fileParams, String[] authSettings)
          {
  
              var request = new RestRequest(path, method);
     
              UpdateParamsForAuth(queryParams, headerParams, authSettings);
  
              // add default header, if any
              foreach(var defaultHeader in _defaultHeaderMap)
                  request.AddHeader(defaultHeader.Key, defaultHeader.Value);
  
              // add header parameter, if any
              foreach(var param in headerParams)
                  request.AddHeader(param.Key, param.Value);
  
              // add query parameter, if any
              foreach(var param in queryParams)
                  request.AddParameter(param.Key, param.Value, ParameterType.GetOrPost);
  
              // add form parameter, if any
              foreach(var param in formParams)
                  request.AddParameter(param.Key, param.Value, ParameterType.GetOrPost);
  
              // add file parameter, if any
              foreach(var param in fileParams)
                  request.AddFile(param.Value.Name, param.Value.Writer, param.Value.FileName, param.Value.ContentType);
  
              if (postBody != null) // http body (model) parameter
                  request.AddParameter("application/json", postBody, ParameterType.RequestBody);
  
              return (Object)RestClient.Execute(request);
  
          }
      
          /// <summary>
          /// Add default header.
          /// </summary>
          /// <param name="key">Header field name.</param>
          /// <param name="value">Header field value.</param>
          /// <returns></returns>
          public void AddDefaultHeader(string key, string value)
          {
              _defaultHeaderMap.Add(key, value);
          }
      
          /// <summary>
          /// Escape string (url-encoded).
          /// </summary>
          /// <param name="str">String to be escaped.</param>
          /// <returns>Escaped string.</returns>
          public string EscapeString(string str)
          {
              return RestSharp.Contrib.HttpUtility.UrlEncode(str);
          }
      
          /// <summary>
          /// Create FileParameter based on Stream.
          /// </summary>
          /// <param name="name">Parameter name.</param>
          /// <param name="stream">Input stream.</param>
          /// <returns>FileParameter.</returns>
          public FileParameter ParameterToFile(string name, Stream stream)
          {
              if (stream is FileStream)
                  return FileParameter.Create(name, stream.ReadAsBytes(), Path.GetFileName(((FileStream)stream).Name));
              else
                  return FileParameter.Create(name, stream.ReadAsBytes(), "no_file_name_provided");
          }
      
          /// <summary>
          /// If parameter is DateTime, output in ISO8601 format.
          /// If parameter is a list of string, join the list with ",".
          /// Otherwise just return the string.
          /// </summary>
          /// <param name="obj">The parameter (header, path, query, form).</param>
          /// <returns>Formatted string.</returns>
          public string ParameterToString(object obj)
          {
              if (obj is DateTime)
                  return ((DateTime)obj).ToString ("u");
              else if (obj is List<string>)
                  return String.Join(",", (obj as List<string>).ToArray());
              else
                  return Convert.ToString (obj);
          }
      
          /// <summary>
          /// Deserialize the JSON string into a proper object.
          /// </summary>
          /// <param name="content">HTTP body (e.g. string, JSON).</param>
          /// <param name="type">Object type.</param>
          /// <returns>Object representation of the JSON string.</returns>
          public object Deserialize(string content, Type type, IList<Parameter> headers=null)
          {
              if (type == typeof(Object)) // return an object
              {
                  return content;
              }
  
              if (type == typeof(Stream))
              {
                  var filePath = String.IsNullOrEmpty(Configuration.TempFolderPath)
                      ? Path.GetTempPath()
                      : Configuration.TempFolderPath;
  
                  var fileName = filePath + Guid.NewGuid();
                  if (headers != null)
                  {
                      var regex = new Regex(@"Content-Disposition:.*filename=['""]?([^'""\s]+)['""]?$");
                      var match = regex.Match(headers.ToString());
                      if (match.Success)
                          fileName = filePath + match.Value.Replace("\"", "").Replace("'", "");
                  }
                  File.WriteAllText(fileName, content);
                  return new FileStream(fileName, FileMode.Open);
  
              }
  
              if (type.Name.StartsWith("System.Nullable`1[[System.DateTime")) // return a datetime object
              {
                  return DateTime.Parse(content,  null, System.Globalization.DateTimeStyles.RoundtripKind);
              }
  
              if (type == typeof(String) || type.Name.StartsWith("System.Nullable")) // return primitive type
              {
                  return ConvertType(content, type); 
              }
      
              // at this point, it must be a model (json)
              try
              {
                  return JsonConvert.DeserializeObject(content, type);
              }
              catch (IOException e)
              {
                  throw new ApiException(500, e.Message);
              }
          }
      
          /// <summary>
          /// Serialize an object into JSON string.
          /// </summary>
          /// <param name="obj">Object.</param>
          /// <returns>JSON string.</returns>
          public string Serialize(object obj)
          {
              try
              {
                  return obj != null ? JsonConvert.SerializeObject(obj) : null;
              }
              catch (Exception e)
              {
                  throw new ApiException(500, e.Message);
              }
          }
      
          /// <summary>
          /// Get the API key with prefix.
          /// </summary>
          /// <param name="apiKeyIdentifier">API key identifier (authentication scheme).</param>
          /// <returns>API key with prefix.</returns>
          public string GetApiKeyWithPrefix (string apiKeyIdentifier)
          {
              var apiKeyValue = "";
              Configuration.ApiKey.TryGetValue (apiKeyIdentifier, out apiKeyValue);
              var apiKeyPrefix = "";
              if (Configuration.ApiKeyPrefix.TryGetValue (apiKeyIdentifier, out apiKeyPrefix))
                  return apiKeyPrefix + " " + apiKeyValue;
              else
                  return apiKeyValue;
          }
      
          /// <summary>
          /// Update parameters based on authentication.
          /// </summary>
          /// <param name="queryParams">Query parameters.</param>
          /// <param name="headerParams">Header parameters.</param>
          /// <param name="authSettings">Authentication settings.</param>
          public void UpdateParamsForAuth(Dictionary<String, String> queryParams, Dictionary<String, String> headerParams, string[] authSettings)
          {
  
gt:             if (authSettings == null || authSettings.Length == 0)