import DataUtils from '../utils/DataUtils';
import PipenetUpstreamProvider from './PipenetUpstreamProvider';
import PipenetDownstreamProvider from './PipenetDownstreamProvider';
import PipenetUpdownstreamProvider from './PipenetUpdownstreamProvider';
import PipenetWhereaboutsProvider from './PipenetWhereaboutsProvider';
import PipenetServiceRangeProvider from './PipenetServiceRangeProvider';
import PipenetConnectivityProvider from './PipenetConnectivityProvider';

/**
 * 定义管网分析提供类
 *
 * @alias PipenetAnalystProvider
 *
 * @summary <用于加载管网分析图层>
 */
export default class PipenetAnalystProvider {
  /**
   * 构造函数
   * @param {Object} options -图层选项
   */
  constructor(options) {
    /**
     * 地图对象
     * @type {Object}
     */
    this._map = options.map;

    /**
     * 最小缩放层级
     * @type {Number}
     */
    this._minzoom = DataUtils.default(options.minzoom, 10);

    /**
     * 是否查询错误管网
     * @type {Boolean}
     */
    this._withError = DataUtils.default(options.error, false);
    /**
     * 是否查询结果
     * @type {Boolean}
     */
    this._withResult = DataUtils.default(options.result, false);
    /**
     * 是否查询设备
     * @type {Boolean}
     */
    this._withDevice = DataUtils.default(options.device, false);

    // 管线颜色
    this._lineColor = '#96143C'; // 2E8B57

    // 线宽
    this._lineWidth = 4.0;

    /** 图层 **/
    this._upstreamProvider = null;    // 上游分析
    this._downstreamProvider = null;  // 下游分析
    this._whereaboutsProvider = null; // 去向分析

    this._updownstreamProvider = null; // 上下游分析(追溯分析)
    this._serviceRangeProvider = null; // 服务范围分析

    this._connectivityProvider = null; // 连通分析
  }

  /** 公有方法 **/
  /**
   * 设置管线路径颜色
   * @param {String} color -16进制颜色字符串
   */
  setColor(color) {
    this._lineColor = color;
  }

  /**
   * 管网分析
   * @param {String} type -分析类型
   * @param {String} code -编码/编码串(管线、检查井、排水户、水厂、泵站)
   * @param {String} layerType -图层类型('pipeline'、'manhole'、'drainentity'、'plant'、'pump')   *
   * @param {Function} callback -回调函数
   *
   * @summery <type参数：
   *   upstream -上游分析;
   *   downstream -下游分析;
   *   updownstream -上下游分析;
   *   whereabouts -去向分析
   *   servicerange -服务范围
   *   connectivity -连通性
   * >
   */
  analyse(type, code, layerType, callback=null) {
    switch (type) {
      case 'upstream': { // 上游分析
        this.upstreamAnalysis(code, layerType, callback);
        break;
      }
      case 'downstream': { // 下游分析
        this.downstreamAnalysis(code, layerType, callback);
        break;
      }
      case 'updownstream': { // 上下游分析(追溯分析)
        this.updownstreamAnalysis(code, layerType, callback);
        break;
      }
      case 'tracingsource': { // 溯源分析
        this.tracingsourceAnalysis(code, layerType, callback);
        break;
      }
      case 'whereabouts': { // 去向分析
        this.whereaboutsAnalysis(code, callback);
        break;
      }
      case 'servicerange': { // 服务范围
        this.serviceRangeAnalysis(code, layerType, callback);
        break;
      }
      case 'connectivity': { // 连通分析
        const pipeIds = code.split(',');
        if (pipeIds.length < 2) return;

        this.connectivityAnalysis(pipeIds[0], pipeIds[1], callback);
        break;
      }
      default:
        break;
    }
  }

  /**
   * 停止
   */
  stop(type) {
    switch (type) {
      case 'upstream': { // 上游分析
        if (this._upstreamProvider) {
          this._upstreamProvider.stop();
        }
        break;
      }
      case 'downstream': { // 下游分析
        if (this._downstreamProvider) {
          this._downstreamProvider.stop();
        }
        break;
      }
      case 'updownstream':    // 上下游分析
      case 'tracingsource': { // 溯源分析
        if (this._updownstreamProvider) {
          this._updownstreamProvider.stop();
        }
        break;
      }
      case 'whereabouts': { // 去向分析
        if (this._whereaboutsProvider) {
          this._whereaboutsProvider.stop();
        }
        break;
      }
      case 'servicerange': { // 服务范围
        if (this._serviceRangeProvider) {
          this._serviceRangeProvider.stop();
        }
        break;
      }
      case 'connectivity': { // 连通分析
        if (this._connectivityProvider) {
          this._connectivityProvider.stop();
        }
        break;
      }
      default:
        break;
    }
  }

  /**
   * 上游分析
   * @param {String} code -管线/检查井编码
   * @param {String} layerType - 图层类型
   * @param {Function} callback -回调函数
   */
  upstreamAnalysis(code, layerType, callback=null) {
    if (!this._upstreamProvider) {
      this._upstreamProvider = new PipenetUpstreamProvider({
        map: this._map,
        minzoom: this._minzoom,
        color: this._lineColor,
        width: this._lineWidth
      });
    }
    // 设置管网颜色
    this._upstreamProvider.setColor(this._lineColor);
    // 停止管网分析
    this._upstreamProvider.stop();

    // 查询管网分析数据
    this._upstreamProvider.queryData(code, layerType, callback);
  }

  /**
   * 下游分析
   * @param {String} code -管线/检查井编码
   * @param {String} layerType - 图层类型
   * @param {Function} callback -回调函数
   */
  downstreamAnalysis(code, layerType, callback=null) {
    if (!this._downstreamProvider) {
      this._downstreamProvider = new PipenetDownstreamProvider({
        map: this._map,
        minzoom: this._minzoom,
        color: this._lineColor,
        width: this._lineWidth,
        layerId: 'map_nh_village'
      });
    }
    // 设置管网颜色
    this._downstreamProvider.setColor(this._lineColor);
    // 停止管线流向
    this._downstreamProvider.stop();

    // 查询管网分析数据
    this._downstreamProvider.queryData(code, layerType, callback);
  }

  /**
   * 去向分析
   * @param {String} drainCode -排水户编码
   * @param {Function} callback -回调函数
   */
  whereaboutsAnalysis(drainCode, callback=null) {
    if (!this._whereaboutsProvider) {
      this._whereaboutsProvider = new PipenetWhereaboutsProvider({
        map: this._map,
        minzoom: this._minzoom,
        color: this._lineColor,
        width: this._lineWidth,
        error: this._withError,
        result: this._withResult
      });
    }
    // 设置管网颜色
    this._whereaboutsProvider.setColor(this._lineColor);
    // 停止管线流向
    this._whereaboutsProvider.stop();

    // 查询管网分析数据
    this._whereaboutsProvider.queryData(drainCode, callback);
  }

  /**
   * 上下游分析
   * @param {String} code -管线/检查井编码
   * @param {String} layerType - 图层类型
   * @param {Function} callback -回调函数
   */
  updownstreamAnalysis(code, layerType, callback=null) {
    if (this._updownstreamProvider) {
      this._updownstreamProvider.stop();
      this._updownstreamProvider = null;
    }

    this._updownstreamProvider = new PipenetUpdownstreamProvider({
      map: this._map,
      minzoom: this._minzoom,
      color: this._lineColor,
      width: this._lineWidth,
      error: this._withError,
      result: this._withResult,
      device: this._withDevice
    });
    // 设置管网颜色
    this._updownstreamProvider.setColor(this._lineColor);

    // 查询管网分析数据
    this._updownstreamProvider.queryData(code, layerType, callback);
  }

  /**
   * 溯源分析
   * @param {String} code -管线/检查井编码
   * @param {String} layerType - 图层类型
   * @param {Function} callback -回调函数
   */
  tracingsourceAnalysis(code, layerType, callback=null) {
    if (this._updownstreamProvider) {
      this._updownstreamProvider.stop();
      this._updownstreamProvider = null;
    }

    this._updownstreamProvider = new PipenetUpdownstreamProvider({
      map: this._map,
      minzoom: this._minzoom,
      color: this._lineColor,
      width: this._lineWidth,
      error: this._withError,
      //result: true
      result: this._withResult
    });
    // 设置管网颜色
    this._updownstreamProvider.setColor(this._lineColor);

    // 查询管网分析数据
    this._updownstreamProvider.queryData(code, layerType, callback);
  }

  /**
   * 服务范围分析
   * @param {String} code -管线/检查井编码
   * @param {String} layerType - 图层类型
   * @param {Function} callback -回调函数
   */
  serviceRangeAnalysis(code, layerType, callback=null) {
    if (!this._serviceRangeProvider) {
      this._serviceRangeProvider = new PipenetServiceRangeProvider({
        map: this._map,
        minzoom: this._minzoom,
        color: this._lineColor,
        width: this._lineWidth,
        error: this._withError,
        result: this._withResult
      });
    }
    // 设置管网颜色
    this._serviceRangeProvider.setColor(this._lineColor);
    // 停止管线流向
    this._serviceRangeProvider.stop();

    // 查询管网分析数据
    this._serviceRangeProvider.queryData(code, layerType, callback);
  }

  /**
   * 连通性分析
   * @param {String} pipeId -起始管线编码
   * @param {String} pipeId2 -终止管线编码
   * @param {Function} callback -回调函数
   */
  connectivityAnalysis(pipeId, pipeId2, callback=null) {
    if (!this._connectivityProvider) {
      this._connectivityProvider = new PipenetConnectivityProvider({
        map: this._map,
        minzoom: this._minzoom,
        color: this._lineColor,
        width: this._lineWidth
      });
    }
    // 设置管网颜色
    this._connectivityProvider.setColor(this._lineColor);
    // 停止管线流向
    this._connectivityProvider.stop();

    // 查询管网分析数据
    this._connectivityProvider.queryData(pipeId, pipeId2, callback);
  }

  /**
   * 移除各图层
   */
  removeAllLayers() {
    // 上游分析
    if (this._upstreamProvider) {
      this._upstreamProvider.removeLayer();
    }
    // 下游分析
    if (this._downstreamProvider) {
      this._downstreamProvider.removeLayer();
    }
    // 去向分析
    if (this._whereaboutsProvider) {
      this._whereaboutsProvider.removeLayer();
    }

    // 上下游分析
    if (this._updownstreamProvider) {
      this._updownstreamProvider.removeLayer();
    }
    // 服务范围分析
    if (this._serviceRangeProvider) {
      this._serviceRangeProvider.removeLayer();
    }
  }

  /**
   * 显示/隐藏社区图层
   * @param {Boolean} isShow -是否显示
   */
  showCoverageLayer(isShow) {
    if (this._downstreamProvider) {
      this._downstreamProvider._villageLayer.showLayer(isShow);
    }
  }
}
