// Copyright IBM Corp. 2015,2016. All Rights Reserved.
  // Node module: loopback-swagger
  // This file is licensed under the MIT License.
  // License text available at https://opensource.org/licenses/MIT
  
  'use strict';
  
  // Globalization
  var g = require('strong-globalize')();
  
  var assert = require('assert');
  var typeConverter = require('./type-converter');
  
  var TYPES_PRIMITIVE = [
    'boolean',
    'integer',
    'number',
    'null',
    'string',
    'object',
    'array',
  ];
  
  var KEY_TRANSLATIONS = {
    // LDL : Swagger
    min: 'minimum',
    max: 'maximum',
    length: 'maxLength',
  };
  
  var SWAGGER_DATA_TYPE_FIELDS = [
    'format',
    'default',
    'enum',
    'minimum',
    'minItems',
    'minLength',
    'maximum',
    'maxItems',
    'maxLength',
    'uniqueItems',
    'pattern',
  ];
  
  /**
   * Build a Swagger Schema Object and/or Parameter Object from LoopBack
   * type descriptor.
   *
   * @param {String|Function|Array|Object} ldlDef The loopback type to convert,
   *  the value should be one of the following:
   *   - a string value (type name), e.g. `'string'` or `'MyModel'`
   *   - a constructor function, e.g. `String` or `MyModel`
   *   - an array of a single item in `lbType` format
   *   - an object containing a `type` property with string/function/array value
   *     and validation fields like `length` or `max`
   * @param {TypeRegistry} typeRegistry The registry of known types and models.
   * @returns {Object} Swagger Schema Object that can be used as `schema` field
   *   or as a base for Parameter Object.
   */
  exports.buildFromLoopBackType = function(ldlDef, typeRegistry) {
    assert(!!typeRegistry, 'typeRegistry is a required parameter');
  
    // Normalize non-object values to object format `{ type: XYZ }`
    if (typeof ldlDef === 'string' || typeof ldlDef === 'function') {
      ldlDef = { type: ldlDef };
    } else if (Array.isArray(ldlDef)) {
      ldlDef = { type: ldlDef };
    }
  
    if (!ldlDef.type) {
      ldlDef = { type: 'any' };
    }
  
    var schema = exports.buildMetadata(ldlDef);
  
    var ldlType = ldlDef.type;
    if (ldlType === 'object' && ldlDef.model) {
      ldlType = ldlDef.model;
    }
    ldlType = exports.getLdlTypeName(ldlType);
  
    if (Array.isArray(ldlType)) {
      var itemLdl = ldlType[0] || 'any';
      var itemSchema = exports.buildFromLoopBackType(itemLdl, typeRegistry);
      schema.type = 'array';
      schema.items = itemSchema;
      return schema;
    }
  
    if (ldlType === 'object' && typeof ldlDef.type === 'object') {
      var obj = {};
      for (var prop in ldlDef.type) {
        obj[prop] = exports.buildFromLoopBackType(ldlDef.type[prop], typeRegistry);
      }
      schema.type = 'object';
      schema.properties = obj;
      return schema;
    }
  
    var ldlTypeLowerCase = ldlType.toLowerCase();
    switch (ldlTypeLowerCase) {
      case 'date':
        schema.type = 'string';
        schema.format = 'date-time';
        break;
      case 'buffer':
        schema.type = 'string';
        schema.format = 'byte';
        break;
      case 'number':
        schema.type = 'number';
        schema.format = schema.format || 'double'; // All JS numbers are doubles
        break;
      case 'any':
        schema.$ref = typeRegistry.reference('x-any');
        break;
      default:
        if (exports.isPrimitiveType(ldlTypeLowerCase)) {
          schema.type = ldlTypeLowerCase;
        } else {
          // TODO - register anonymous types
          schema.$ref = typeRegistry.reference(ldlType);
        }
    }
    return schema;
  };
  
  /**
   * @param {String|Function|Array|Object} ldlType LDL type
   * @returns {String|Array} Type name
   */
  exports.getLdlTypeName = function(ldlType) {
    // Value "array" is a shortcut for `['any']`
    if (ldlType === 'array') {
      return ['any'];
    }
  
    if (typeof ldlType === 'string') {
      var arrayMatch = ldlType.match(/^\[(.*)\]$/);
      return arrayMatch ? [arrayMatch[1]] : ldlType;
    }
  
    if (typeof ldlType === 'function') {
      return ldlType.modelName || ldlType.name;
    }
  
    if (Array.isArray(ldlType)) {
      return ldlType;
    }
  
    if (typeof ldlType === 'object') {
      // Anonymous objects, they are allowed e.g. in accepts/returns definitions
      // TODO(bajtos) Build a named schema for this anonymous object
      return 'object';
    }
  
    if (ldlType === undefined) {
      return 'any';
    }
  
    var msg = g.f('Warning: unknown LDL type %j, using "{{any}}" instead', ldlType);
    console.error(msg);
    return 'any';
  };
  
  /**
   * Convert validations and other metadata from LDL format to Swagger format.
   * @param {Object} ldlDef LDL property/argument definition,
   * for example `{ type: 'string', maxLength: 64 }`.
   * @return {Object} Metadata in Swagger format.
   */
  exports.buildMetadata = function(ldlDef) {
    var result = {};
    var key;
  
    for (key in KEY_TRANSLATIONS) {
      if (key in ldlDef) {
        // Skip null as swagger 2.x UI does not support it
        // https://github.com/swagger-api/swagger-spec/issues/229
        if (ldlDef[key] != null) {
          result[KEY_TRANSLATIONS[key]] = ldlDef[key];
        }
      }
    }
  
    /* eslint-disable one-var */
    for (var ix in SWAGGER_DATA_TYPE_FIELDS) {
      key = SWAGGER_DATA_TYPE_FIELDS[ix];
      if (key in ldlDef)
        result[key] = ldlDef[key];
    }
    /* eslint-enable one-var */
    if (ldlDef.description) {
      result.description = typeConverter.convertText(ldlDef.description);
    } else if (ldlDef.doc) {
      result.description = typeConverter.convertText(ldlDef.doc);
    }
  
    return result;
  };
  
  exports.isPrimitiveType = function(typeName) {
    return TYPES_PRIMITIVE.indexOf(typeName.toLowerCase()) !== -1;
  };