function useA(){
 wacth(new,old){
  if(start){
    if(new.type =='need')
     const a = {
      a:new.a
     }
     const aa = {
      aa:new.aa
     }
     upload(a)
     upload(aa)
  }
 }
}
// 多處數(shù)據(jù)散落
function useB(){
 // 重復(fù)監(jiān)聽
 wacth(new,old){
 // 全局判斷
  if(start){
    // 不同狀態(tài)判斷
    if(new.type =='need')
     const b = {
      b:new.b
     }
     //重復(fù)數(shù)據(jù)格式
     const aa = {
      b:new.aa
     }
     upload(b)
     upload(aa)
  }
 }
}

/*
 * @Description: 采集公共類
 * @version: 1.0.0
 * @Author: 吳文周
 * @Date: 2021-04-20 19:44:35
 * @LastEditors: 吳文周
 * @LastEditTime: 2021-04-22 15:20:50
 */
/**
 * @name: Dep
 * @msg: 依賴收集對象
 */
class Dep {
  private subs: any = []
  // 添加觀察者
  public addSub(sub: any) {
    if (sub && sub.update) {
      this.subs.push(sub)
    }
  }
  // 發(fā)送通知
  public notify(content: any) {
    this.subs.forEach((sub: any) => {
      sub.update(content)
    })
  }
}
/**
 * @name: Watcher
 * @msg: 觀察者對象
 */
class Watcher {
  private cb!: (arg: any) => void
  constructor(cb: (arg: any) => void) {
    // 回調(diào)函數(shù)負(fù)責(zé)更新
    this.cb = cb
  }
  // 當(dāng)數(shù)據(jù)發(fā)生變化的時候更新
  update(content: any) {
    this.cb(content)
  }
}
/**
 * @name: Channel
 * @msg: 緩存消息管道
 */
class Channel {
  // 管道存儲數(shù)組
  private queue: any = []
  // 管道大小
  private limitSize = 1
  // 管道名稱
  public name: string
  constructor(name: string, limitSize = 1) {
    this.name = name
    // 最小尺寸是1
    limitSize = limitSize >= 1 ? limitSize : 1
    this.limitSize = limitSize
  }
  /**
   * @name: push
   * @msg: 添加的數(shù)據(jù)
   */
  push(item: any) {
    // 如果超出限制尺寸移除第一個
    if (this.limitSize == this.queue.length) {
      this.queue.shift()
    }
    this.queue.push(item)
  }
  /**
   * @name: getLast
   * @msg: 獲取最后添加的數(shù)據(jù)
   */
  getLast() {
    if (this.queue.length > 0) {
      return this.queue[this.queue.length - 1]
    } else {
      throw new Error('no item return')
    }
  }
  /**
   * @name: getLastIndex
   * @msg: 獲取最后倒數(shù)的數(shù)據(jù)
   */
  getLastIndex(index: number) {
    try {
      return this.queue[this.queue.length - index - 1]
    } catch (error) {
      throw new Error('no item return')
    }
  }
  /**
   * @name: isEmpty
   * @msg: 管道是否為空
   */
  isEmpty() {
    return this.queue.length == 0
  }
}
export class Collection {
  // 依賴收集對象
  private dep = new Dep()
  // 各個數(shù)據(jù)頻道分類
  private dataQueue = ['A', 'B', 'C']
  // 頻道集合
  private channelMap = new Map()
  // 上傳隊列
  private MQ!: LiveCollectionMQ
  // 策略模式：數(shù)據(jù)類型不同對應(yīng)不同的處理機制
  private strategies = {
    A: () => {
      // 可以在不同的管道中獲取相對應(yīng)的數(shù)據(jù)進(jìn)行不同邏輯的處理
    },
    B: () => {

    },
    C: () => {
    },
  } as Record<NotifyType, any>
  constructor() {
    this.init()
  }
  private init() {
    // 初始化watcher
    this.intWatcher()
    // 初始化頻道
    this.initChannel()
    // 初始化數(shù)據(jù)
    this.initData()
    // 初始化隊列
    this.initMQ()
  }
  /**
   * @name:intWatcher
   * @msg:初始化監(jiān)聽器
   */
  private intWatcher() {
    this.dep.addSub(
      new Watcher((type: NotifyType) => {
        const handlerBack = this.getHandler(type)
        handlerBack()
      }),
    )
  }
  /**
   * @name: initChannel
   * @msg: 初始化頻道
   */
  private initChannel() {
    this.dataQueue.forEach(item => {
      this.channelMap.set(item, new Channel(item, 3))
    })
  }
  /**
   * @name: initData
   * @msg: 初始化頻道數(shù)據(jù)
   * @param {*}
   */
  private initData() {
    
  }
  /**
   * @name: initMQ
   * @msg: 初始化上傳隊列
   */
  private initMQ() {

  }
  /**
   * @name: getMQ
   * @msg:獲取消息隊列
   */
  public getMQ() {
    return this.MQ
  }
  /**
   * @name:getChannel
   * @msg:根據(jù)頻道名稱獲取頻道實例
   * @param {name}頻道名稱
   */
  private getChannel(name: NotifyType) {
    if (this.channelMap.get(name)) {
      return this.channelMap.get(name)
    } else {
      throw new Error('no channel')
    }
  }
  /**
   * @name:notify
   * @msg:依賴通知方法
   * @param {NotifyType} type
   * @param {any} mes
   */
  public notify(type: NotifyType, mes: any) {
    // 設(shè)置管道緩存
    this.setChannel(type, mes)
    // 全局統(tǒng)一判斷狀態(tài)判斷是否要分發(fā)數(shù)據(jù)
    if (state.value.type) {
      this.dep.notify(type)
    }
  }
  /**
   * @name: setChannel
   * @msg: 設(shè)置頻道緩存
   * @param {NotifyType} name
   * @param {any} mes
   */
  private setChannel(name: NotifyType, mes: any) {
    const channel = this.getChannel(name)
    channel.push(mes)
  }
  /**
   * @name:getHandler
   * @msg: 獲取
   * @param {NotifyType} name
   */
  private getHandler(name: NotifyType) {
    return this.strategies[name]
  }
  /**
   * @name: getChannelLast
   * @msg: 獲取指定管道中的最新的數(shù)據(jù)
   * @param {NotifyType} name
   * @return {*}
   */
  public getChannelLast(name: NotifyType) {
    try {
      const channel = this.getChannel(name)
      return channel.getLast()
    } catch (error) {
      throw new Error(error)
    }
  }
  /**
   * @name: getChannelLast
   * @msg: 獲取指定管道中的倒序數(shù)據(jù)
   * @param {NotifyType} name
   * @param {number} index
   */
  public getChannelItemByLastIndex(name: NotifyType, index: number) {
    try {
      const channel = this.getChannel(name)
      return channel.getLastIndex(index)
    } catch (error) {
      throw new Error(error)
    }
  }
  /**
   * @name: generateA
   * @msg: 生成A數(shù)據(jù)方法
   */
  public generateA() {
    
  }
  /**
   * @name: generateB
   * @msg: 生成B數(shù)據(jù)方法
   */
  public generateB() {
    
  }
  /**
   * @name: generateC
   * @msg: 生成C數(shù)據(jù)方法
   */
  public generateC() {
    
  }
}

export const CollectionHelper = new Collection()