    import { Zondy } from '../base'
    import { deepClone, defaultValue, getGUID, Log } from '../util'
    import { FetchMethod, TokenAttachType } from '../base/enum'
    import RequestInterceptor from './RequestInterceptor'
    import ResponseInterceptor from './ResponseInterceptor'
    import FetchServer from './FetchServer'
    import { checkParam, checkPathParameters, formatBaseUrl } from './Utils'

    /**
     * 服务查询基类
     * @class BaseServer
     * @moduleEx ServerModule
     * @param {Object} options 构造参数
     * @param {String} [options.url = 无] 基地址，必填
     * @param {Object} [options.headers = 无] 自定义请求头参数
     * @param {String} [options.tokenKey = 'token'] token名
     * @param {String} [options.tokenValue = 无] token值
     * @param {TokenAttachType} [options.tokenAttachType = TokenAttachType.url] 指定token附加到何处
     * @param {RequestInterceptor} [options.requestInterceptor = 无] 请求发送拦截器
     * @param {ResponseInterceptor} [options.responseInterceptor = 无] 请求响应拦截器
     * @param {Number} [options.requestTimeout = 45000] 请求超时时间，默认45000ms，即45s
     */
    class BaseServer {
      constructor(options) {
        options = defaultValue(options, {})
        /**
         * 服务基地址
         * @member {String} BaseServer.prototype.url
         * @example
         * //设置请求基地址
         * // ES5引入方式
         * const { BaseServer } = Zondy.Service
         * // ES6引入方式
         * import { BaseServer } from "@mapgis/webclient-common"
         * let BaseServer = new BaseServer({
         *   //请求基地址
         *   url: '你的URL'
         * });
         * //动态修改
         * BaseServer.url = '新URL';
         */
        this.url = defaultValue(options.url, '')
        const _urlObj = formatBaseUrl(this.url)
        // 获取纯粹的基地址
        this._url = _urlObj.baseUrl
        // 保存?之后的部分
        this._paramString = _urlObj.paramString ? `${_urlObj.paramString}&` : ''
        /**
         * 是否使用确据唯一的fetch对象，默认为true，当设为false时，会使用自己私有的fetch对象，所有的请求设置不会影响全局
         * @member {Boolean} BaseServer.prototype.enableGlobeFetch
         * @example
         * //设置请求基地址
         * // ES5引入方式
         * const { BaseServer } = Zondy.Service
         * // ES6引入方式
         * import { BaseServer } from "@mapgis/webclient-common"
         * let BaseServer = new BaseServer({
         *   //请求基地址
         *   url: '你的URL',
         *   //使用私有的fetch对象
         *   enableGlobeFetch: false,
         *   //此时设置token等属性，不会影响全局的fetch对象
         *   tokenValue: '你的token'
         * });
         * //继续使用全局fetch
         * BaseServer.enableGlobeFetch = true;
         */
        this.enableGlobeFetch = defaultValue(options.enableGlobeFetch, true)

        /**
         * 客户端id
         * @member {Boolean} BaseServer.prototype.clientId
         */
        this.clientId = defaultValue(options.clientId, getGUID())

        // 私有变量
        // 所有请求发送前会触发的函数
        this._requestInterceptor = defaultValue(
          options.requestInterceptor,
          new RequestInterceptor()
        )
        // 所有请求发送后会触发的函数
        this._responseInterceptor = defaultValue(
          options.responseInterceptor,
          new ResponseInterceptor()
        )
        // 请求超时时间
        this._requestTimeout = defaultValue(options.requestTimeout, 45000)
        // 请求头参数
        this._headers = defaultValue(options.headers, undefined)
        // token名
        this._tokenKey = defaultValue(options.tokenKey, 'token')
        // token值
        this._tokenValue = defaultValue(options.tokenValue, undefined)
        // 指定token附加到何处
        this._tokenAttachType = defaultValue(
          options.tokenAttachType,
          TokenAttachType.url
        )
        // 私有的fetch对象
        this._fetchService = undefined

        // 保存公有fetch的构造参数
        if (this.enableGlobeFetch) {
          this._globeOptions = {
            requestInterceptor: this._requestInterceptor,
            responseInterceptor: this._responseInterceptor,
            requestTimeout: this._requestTimeout,
            headers: this._headers,
            tokenKey: this._tokenKey,
            tokenValue: this._tokenValue,
            tokenAttachType: this._tokenAttachType,
            fetchService: this._fetchService
          }
        } else {
          // 保存私有fetch的构造参数
          this._privateOptions = {
            requestInterceptor: this._requestInterceptor,
            responseInterceptor: this._responseInterceptor,
            requestTimeout: this._requestTimeout,
            headers: this._headers,
            tokenKey: this._tokenKey,
            tokenValue: this._tokenValue,
            tokenAttachType: this._tokenAttachType,
            fetchService: this._fetchService
          }
        }

        // 初始化fetch对象
        this._initFetch()
      }

      /**
       * 获取服务信息，IGS2.0新增服务
       * @param options 查询参数
       * @param {Function} [options.success = 无] 查询成功回调函数，若使用Promise方式则不必填写
       * @param {Function} [options.failure = 无] 查询失败回调函数，若使用Promise方式则不必填写
       * @example <caption><h5>获取服务信息-回调方式</h5></caption>
       * server.queryServerInfo({
       *   success: function (result) {
       *     console.log('请求成功：', result);
       *   },
       *   failure: function (result) {
       *     console.log('请求失败：', result);
       *   }
       * });
       *
       * @example <caption><h5>获取服务信息-promise方式</h5></caption>
       * server.queryServerInfo({
       * })
       * .then(function (result) {
       *   console.log('请求成功：', result);
       * }).catch(function (result) {
       *   console.log('请求失败：', result);
       * });
       */
      queryServerInfo(options) {
        const self = this
        return this._querySimpleInfo(options, function (url) {
          // igs1.0的地图服务
          if (url.indexOf('/igs/rest/mrcs/docs/') > -1) {
            // 拼装返回基地址，必须这样传，否则返回的数据是空的
            return `${url.replace('mrcs/docs', 'mrms/info')}?f=json`
          }
          if (url.indexOf('/igs/rest/mrms/docs/') > -1) {
            // 拼装返回基地址，必须这样传，否则返回的数据是空的
            return `${url.replace('docs', 'info')}?f=json`
          }
          if (url.indexOf('/igs/rest/mrms/tile/') > -1) {
            // 拼装返回基地址，必须这样传，否则返回的数据是空的
            return `${url.replace('tile', 'info')}?f=json`
          }
          // igs1.0的G3D服务
          if (url.indexOf('/igs/rest/g3d/') > -1) {
            // 拼装返回基地址
            return `${url}/GetDocInfo`
          }
          // 拼装返回基地址
          return `${url}?f=json${self._paramString}`
        })
      }

      /**
       * 初始化并分会Fetch对象
       * @private
       * @return Object Fetch对象
       * */
      _initFetch() {
        // 当全局对象不存在时，创建一个
        if (this.enableGlobeFetch && !Zondy.Service._fetchService) {
          // 如果有共有参数，就在初始化时赋予
          if (this._globeOptions) {
            Zondy.Service._fetchService = new FetchServer('', this._globeOptions)
          } else {
            Zondy.Service._fetchService = new FetchServer('', {})
          }
        } else if (!this.enableGlobeFetch && !this._fetchService) {
          // 当私有对象不存在时，创建一个，如果有私有有参数，就在初始化时赋予
          if (this._privateOptions) {
            this._fetchService = new FetchServer('', this._privateOptions)
          } else {
            this._fetchService = new FetchServer('', {})
          }
        }

        return this.enableGlobeFetch
          ? Zondy.Service._fetchService
          : this._fetchService
      }

      /**
       * 获取公有或私有的fetch对象
       * @private
       * @return Object Fetch对象
       * */
      _getFetch() {
        // 获取fetch
        let fetchService = this.enableGlobeFetch
          ? Zondy.Service._fetchService
          : this._fetchService

        // 确保fetch存在
        if (!fetchService) {
          fetchService = this._initFetch()
        }

        return fetchService
      }

      /**
       * 发起GET请求
       * @private
       * @param url 查询链接
       * @param options 查询参数
       * */
      _getRequest(url, options) {
        Log.info('请求链接:', url)
        Log.info('请求参数:', options)
        // 成功回调函数
        const success = defaultValue(options.success, undefined)
        // 失败回调函数
        const failure = defaultValue(options.failure, undefined)

        // 发起请求
        const fetchService = this._getFetch()
        return fetchService.request({
          url,
          method: 'GET',
          success(result) {
            if (result) {
              if (success) success(result)
            }
          },
          failure(result) {
            if (failure) failure(result)
          }
        })
      }

      /**
       * 发起POST请求
       * @private
       * @param url 查询链接
       * @param options 查询参数
       * */
      _postRequest(url, options) {
        return this._sendBodyRequest('POST', url, options)
      }

      /**
       * 发起DELETE请求
       * @private
       * @param url 查询链接
       * @param options 查询参数
       * */
      _deleteRequest(url, options) {
        return this._sendBodyRequest('DELETE', url, options)
      }

      /**
       * 发起PUT请求
       * @private
       * @param url 查询链接
       * @param options 查询参数
       * */
      _putRequest(url, options) {
        return this._sendBodyRequest('PUT', url, options)
      }

      /**
       * 发起PATCH请求
       * @private
       * @param url 查询链接
       * @param options 查询参数
       * */
      _patchRequest(url, options) {
        return this._sendBodyRequest('PATCH', url, options)
      }

      /**
       * 发起所有body请求
       * @private
       * @param method 方法名
       * @param url 查询链接
       * @param options 查询参数
       * */
      _sendBodyRequest(method, url, options) {
        // 成功回调函数
        const success = defaultValue(options.success, undefined)
        // 失败回调函数
        const failure = defaultValue(options.failure, undefined)
        // post请求发送的数据
        const data = defaultValue(options.data, {})
        // 设置headers
        const headers = defaultValue(options.headers, undefined)

        // 发起请求
        const fetchService = this._getFetch()
        return fetchService.request({
          url,
          method,
          data,
          headers,
          success(result) {
            if (result) {
              if (success) success(result)
            }
          },
          failure(result) {
            if (failure) failure(result)
          }
        })
      }

      /**
       * 设置fetch的属性
       * @private
       * @param {String} key 属性名
       * @param {String} value 属性值
       * */
      _setFetchValue(key, value) {
        // 使用全局或私有fetch
        if (this.enableGlobeFetch && Zondy.Service._fetchService) {
          Zondy.Service._fetchService[key] = value
        } else if (!this.enableGlobeFetch) {
          Zondy.Service._fetchService[key] = value
        }
      }

      /**
       * 验证正确性并发送请求
       * @private
       * @param {Object} checkResult 校验对象
       * @param {String} url 请求基地址
       * @param {Object} options 额外参数
       * */
      _checkAndRequest(checkResult, url, options) {
        options = defaultValue(options, {})

        // 只有校验通过才会发送请求
        if (checkResult.isChecked) {
          // 发起查询
          const method = defaultValue(options.method, FetchMethod.get)

          switch (method) {
            case FetchMethod.get:
              return this._getRequest(url + checkResult.queryString, options)
            case FetchMethod.post:
              const postOpts = deepClone(options)
              postOpts.data = checkResult.queryString
              return this._postRequest(url, postOpts)
            case FetchMethod.delete:
              const deleteOpts = deepClone(options)
              deleteOpts.data = checkResult.queryString
              return this._deleteRequest(url, deleteOpts)
            case FetchMethod.put:
              const putOpts = deepClone(options)
              putOpts.data = checkResult.queryString
              return this._putRequest(url, putOpts)
            default:
              return this._getRequest(url + checkResult.queryString, options)
          }
        } else {
          if (
            this.requestInterceptor &&
            this.requestInterceptor.failure &&
            this.requestInterceptor.failure instanceof Function
          ) {
            this.requestInterceptor.failure({
              succeed: false,
              msg: checkResult.errorMessage,
              errorType: checkResult.errorType,
              data: undefined
            })
          }
          if (options.failure && options.failure instanceof Function) {
            options.failure({
              succeed: false,
              msg: checkResult.errorMessage,
              errorType: checkResult.errorType,
              data: undefined
            })
          }
          return Promise.reject({
            succeed: false,
            msg: checkResult.errorMessage,
            data: undefined,
            errorType: checkResult.errorType
          })
        }
      }

      /**
       * 验证所有PathParameter参数的正确性，PathParameter里的参数都是必填参数，必须验证正确性
       * @private
       * @param {Object} options 请求参数对象
       * @param {Object} checkOptions 验证对象
       * @return {Boolean} 是否验证通过
       * */
      _checkPathParameters(options, checkOptions) {
        // 默认只检测layerId
        checkOptions = defaultValue(checkOptions, {
          layerId: {
            type: 'String'
          }
        })
        const checkResult = checkPathParameters(checkOptions, options)

        // 验证失败，调用请求拦截器失败方法
        if (!checkResult.isChecked) {
          if (
            this.requestInterceptor &&
            this.requestInterceptor.failure &&
            this.requestInterceptor.failure instanceof Function
          ) {
            this.requestInterceptor.failure({
              succeed: false,
              msg: checkResult.errorMessage,
              errorType: checkResult.errorType,
              data: undefined
            })
          }

          return {
            succeed: false,
            msg: checkResult.errorMessage,
            errorType: checkResult.errorType
          }
        }

        return {
          succeed: true
        }
      }

      /**
       * 进行简单的info查询，没有任何条件
       * @private
       * @param {Object} options 查询参数
       * @param {Function} callback 处理请求基地址的回调
       * @return {Boolean} 是否验证通过
       * */
      _querySimpleInfo(options, callback) {
        options = defaultValue(options, {})

        if (callback && callback instanceof Function) {
          // 获取url
          const url = callback(this._url) + this._paramString
          // 请求方式为GET
          options.method = FetchMethod.get

          Log.info('发起请求，基地址为：', url)
          return this._checkAndRequest(
            {
              isChecked: true,
              errorMessage: '',
              errorType: '',
              queryString: ''
            },
            url,
            options
          )
        }

        return false
      }

      /**
       * 通过layerId查询信息
       * @private
       * @param {Object} options 查询参数
       * @param {Function} callback 处理请求基地址的回调
       * @return {Boolean} 是否验证通过
       * */
      _queryInfoByLayerId(options, callback) {
        options = defaultValue(options, {})

        // 检查PathParameters参数
        const checkPath = this._checkPathParameters(options)
        if (!checkPath.succeed) {
          if (options.failure && options.failure instanceof Function) {
            options.failure({
              succeed: false,
              msg: checkPath.msg,
              data: undefined
            })
          }
          return Promise.reject({
            succeed: false,
            msg: checkPath.msg,
            data: undefined
          })
        }

        if (callback && callback instanceof Function) {
          // 获取url
          const url = callback(this._url, options)
          // 请求方式为GET
          options.method = FetchMethod.get

          Log.info('发起请求，基地址为：', url)
          return this._checkAndRequest(
            {
              isChecked: true,
              errorMessage: '',
              errorType: '',
              queryString: ''
            },
            url,
            options
          )
        }
      }

      /**
       * 根据接口的PATH PARAMETERS和QUERY PARAMETERS来发起查询
       * @private
       * @param {Object} options 查询参数
       * @param {Object} pathCheck 要检查的路径参数
       * @param {Object} queryCheck 要检查的查询参数
       * @param {Function} callback 处理请求基地址的回调
       * @return {Boolean} 是否验证通过
       * */
      _queryByParameters(options, pathCheck, queryCheck, callback) {
        options = defaultValue(options, {})

        // 检查PathParameters参数
        const checkPath = this._checkPathParameters(options, pathCheck)
        if (!checkPath.succeed) {
          if (options.failure && options.failure instanceof Function) {
            options.failure({
              succeed: false,
              msg: checkPath.msg,
              data: undefined,
              errorType: checkPath.errorType
            })
          }
          return Promise.reject({
            succeed: false,
            msg: checkPath.msg,
            data: undefined,
            errorType: checkPath.errorType
          })
        }

        if (callback && callback instanceof Function) {
          // 获取url
          const url = callback(this._url, options)
          // url += `&clientId=${this.clientId}`

          Log.info('发起请求，基地址为：', url)
          return this._checkAndRequest(
            checkParam(options, queryCheck),
            url,
            options
          )
        }
      }
    }

    Object.defineProperties(BaseServer.prototype, {
      /**
       * 请求发送拦截器
       * @member {Function} BaseServer.prototype.requestInterceptor
       * @example
       * //设置拦截器，任何一个继承自BaseServer的对象都可以设置，全局唯一
       * // ES5引入方式
       * const { BaseServer,RequestInterceptor } = Zondy.Service
       * // ES6引入方式
       * import { BaseServer,RequestInterceptor } from "@mapgis/webclient-common"
       * let BaseServer = new BaseServer({
       *   //设置请求发送拦截器
       *   requestInterceptor: new RequestInterceptor({
       *     //请求发送前进行统一处理
       *     before: function(config) {
       *       //执行你的业务逻辑
       *       //注意必须显示返回config对象，如果返回为空，则不发送请求
       *       return config;
       *     },
       *     //请求发送失败时进行统一处理
       *     failure: function(error) {
       *       //执行你的业务逻辑
       *     }
       *   })
       * });
       * //动态修改
       * BaseServer.requestInterceptor.before = function() {};
       * */
      requestInterceptor: {
        configurable: false,
        get() {
          return this._requestInterceptor
        },
        set(value) {
          // 设置fetch属性
          this._setFetchValue('requestInterceptor', value)
          this._requestInterceptor = value
        }
      },
      /**
       * 请求响应拦截器
       * @member {Function} BaseServer.prototype.responseInterceptor
       * @example
       * //设置拦截器，任何一个继承自BaseServer的对象都可以设置，全局唯一
       * // ES5引入方式
       * const { BaseServer,ResponseInterceptor } = Zondy.Service
       * // ES6引入方式
       * import { BaseServer,ResponseInterceptor } from "@mapgis/webclient-common"
       * let BaseServer = new BaseServer({
       *   //设置请求响应拦截器
       *   responseInterceptor: new ResponseInterceptor({
       *     //执行请求响应，接口调用成功时会执行的回调
       *     success: function(result) {
       *       //执行你的业务逻辑
       *       //注意必须显示返回result对象，如果返回为空，则不执行请求响应成功回调
       *       return result;
       *     },
       *     //请求响应成功，接口调用失败时会执行的函数
       *     failure: function(result) {
       *       //执行你的业务逻辑
       *       //注意必须显示返回result对象，如果返回为空，则不执行回调韩式
       *       return result;
       *     }
       *   })
       * });
       * //动态修改
       * BaseServer.responseInterceptor.success = function() {};
       * */
      responseInterceptor: {
        configurable: false,
        get() {
          return this._responseInterceptor
        },
        set(value) {
          // 设置fetch属性
          this._setFetchValue('responseInterceptor', value)
          this._responseInterceptor = value
        }
      },
      /**
       * 请求超时时间，默认45000ms，即45s
       * @member {String} BaseServer.prototype.requestTimeout
       * @example
       * //设置超时时间
       * //初始化AddressServer服务对象
       * // ES5引入方式
       * const { BaseServer } = Zondy.Service
       * // ES6引入方式
       * import { BaseServer } from "@mapgis/webclient-common"
       * let BaseServer = new BaseServer({
       *   //超时时间
       *   requestTimeout: 2000
       * });
       * //动态修改
       * BaseServer.requestTimeout = 3000;
       * */
      requestTimeout: {
        configurable: false,
        get() {
          return this._requestTimeout
        },
        set(value) {
          // 设置fetch属性
          this._setFetchValue('requestTimeout', value)
          this._requestTimeout = value
        }
      },
      /**
       * 请求头参数
       * @member {String} BaseServer.prototype.headers
       * @example
       * //设置请求头参数
       * // ES5引入方式
       * const { BaseServer } = Zondy.Service
       * // ES6引入方式
       * import { BaseServer } from "@mapgis/webclient-common"
       * let BaseServer = new BaseServer({
       *   //请求头
       *   headers: {
       *      //设置Content-Type为multipart/form-data
       *     'Content-Type': 'multipart/form-data',
       *      //设置token
       *     'token': '你的token'
       *   }
       * });
       * //动态修改
       * BaseServer.headers.token = '新token';
       * */
      headers: {
        configurable: false,
        get() {
          return this._headers
        },
        set(value) {
          // 设置fetch属性
          this._setFetchValue('headers', value)
          this._headers = value
        }
      },
      /**
       * token名
       * @member {String} BaseServer.prototype.tokenKey
       * @example
       * //设置token名
       * // ES5引入方式
       * const { BaseServer } = Zondy.Service
       * // ES6引入方式
       * import { BaseServer } from "@mapgis/webclient-common"
       * let BaseServer = new BaseServer({
       *   //token名
       *   tokenKey: '你的tokenKey'
       * });
       * //动态修改
       * BaseServer.tokenKey = '新tokenKey';
       * */
      tokenKey: {
        configurable: false,
        get() {
          return this._tokenKey
        },
        set(value) {
          // 设置fetch属性
          this._setFetchValue('tokenKey', value)
          this._tokenKey = value
        }
      },
      /**
       * token值
       * @member {String} BaseServer.prototype.tokenValue
       * @example
       * //设置token值
       * // ES5引入方式
       * const { BaseServer } = Zondy.Service
       * // ES6引入方式
       * import { BaseServer } from "@mapgis/webclient-common"
       * let BaseServer = new BaseServer({
       *   //token值
       *   tokenValue: '你的token值'
       * });
       * //动态修改
       * BaseServer.tokenValue = '新token值';
       * */
      tokenValue: {
        configurable: false,
        get() {
          return this._tokenValue
        },
        set(value) {
          // 设置fetch属性
          this._setFetchValue('tokenValue', value)
          this._tokenValue = value
        }
      },
      /**
       * 指定token附加到何处
       * @member {TokenAttachType} BaseServer.prototype.tokenAttachType
       * @example
       * //设置token值
       * // ES5引入方式
       * const { BaseServer } = Zondy.Service
       * const { TokenAttachType } = Zondy.Enum
       * // ES6引入方式
       * import { BaseServer,TokenAttachType } from "@mapgis/webclient-common"
       * let BaseServer = new BaseServer({
       *   //token名
       *   tokenValue: '你的token值',
       *   //token值
       *   tokenValue: '你的token值',
       *   //指定token附加到url后面
       *   tokenAttachType: TokenAttachType.url
       * });
       * //动态修改
       * BaseServer.tokenAttachType = TokenAttachType.header;
       * */
      tokenAttachType: {
        configurable: false,
        get() {
          return this._tokenAttachType
        },
        set(value) {
          // 设置fetch属性
          this._setFetchValue('tokenAttachType', value)
          this._tokenAttachType = value
        }
      }
    })

    Zondy.Service.BaseServer = BaseServer
    export default BaseServer