export class BaseConfig {

  set(options, notUndefined) {
    options = this.initOptions(options)
    for (let name in options) {
      if (options.hasOwnProperty(name)) {
        if (!(this[name] instanceof Array)) {
          if (notUndefined === true) {
            this[name] = options[name] === undefined ? this[name] : options[name];
          } else {
            this[name] = options[name];
          }
        }
      }
    }
  }

  sets(types, options) {
    options = this.initOptions(options)
    if (types) {
      for (let name in types) {
        if (types.hasOwnProperty(name) && options.hasOwnProperty(name)) {
          options[name].forEach(o => {
            this[name].push(new types[name](o));
          })
        }
      }
    }
  }

  initOptions(options) {
    return options || {};
  }

  isValid() {
    return true;
  }
}

export class KeyValue extends BaseConfig {
  constructor(options) {
    options = options || {};
    options.enable = options.enable === undefined ? true : options.enable;

    super();
    this.name = undefined;
    this.value = undefined;
    this.type = undefined;
    this.files = undefined;
    this.enable = undefined;
    this.uuid = undefined;
    this.time = undefined;
    this.contentType = undefined;
    this.set(options);
  }

  isValid() {
    return (!!this.name || !!this.value) && this.type !== 'file';
  }

  isFile() {
    return (!!this.name || !!this.value) && this.type === 'file';
  }
}

export class Body extends BaseConfig {
  constructor(options) {
    super();
    this.type = "KeyValue";
    this.raw = undefined;
    this.kvs = [];
    this.binary = [];
    this.set(options);
    this.sets({kvs: KeyValue}, {binary: KeyValue}, options);
  }

  isValid() {
    if (this.isKV()) {
      return this.kvs.some(kv => {
        return kv.isValid();
      })
    } else {
      return !!this.raw;
    }
  }

  isKV() {
    return [BODY_TYPE.FORM_DATA, BODY_TYPE.WWW_FORM, BODY_TYPE.BINARY].indexOf(this.type) > 0;
  }
}

export const createComponent = function (name) {
  let component = MODELS[name];
  if (component) {
    return new component();
  } else {
    return new UnsupportedComponent()
  }
}

export const BODY_TYPE = {
  KV: "KeyValue",
  FORM_DATA: "Form_Data",
  RAW: "Raw",
  WWW_FORM: "WWW_FORM",
  XML: "XML",
  JSON: "JSON"
}

export class Scenario extends BaseConfig {
  constructor(options = {}) {
    super();
    this.id = undefined;
    this.name = undefined;
    this.url = undefined;
    this.variables = [];
    this.headers = [];
    this.requests = [];
    this.environmentId = undefined;
    this.dubboConfig = undefined;
    this.environment = undefined;
    this.enableCookieShare = false;
    this.enable = true;
    this.databaseConfigs = [];
    this.tcpConfig = undefined;
    this.set(options);
    this.sets({
      variables: KeyValue,
      headers: KeyValue,
      requests: RequestFactory,
      databaseConfigs: DatabaseConfig
    }, options);
  }

  initOptions(options = {}) {
    options.id = options.id || uuid();
    options.requests = options.requests || [new RequestFactory()];
    options.databaseConfigs = options.databaseConfigs || [];
    options.dubboConfig = new DubboConfig(options.dubboConfig);
    options.tcpConfig = new TCPConfig(options.tcpConfig);
    return options;
  }

  clone() {
    let clone = new Scenario(this);
    clone.id = uuid();
    return clone;
  }

  isValid() {
    if (this.enable) {
      for (let i = 0; i < this.requests.length; i++) {
        let validator = this.requests[i].isValid(this.environmentId, this.environment);
        if (!validator.isValid) {
          return validator;
        }
      }
    }
    return {isValid: true};
  }

  isReference() {
    return this.id.indexOf("#") !== -1
  }
}