// 定义接口 并不实现
export interface Requestor {
  get(url: string, options: RequestOptions): Promise<Response>
  // ...
}

// 本模块的大部分功能都需要使用到Requestor
let req: Requestor
export function inject(requestor: Requestor) {
  req = requestor
}
export function useRequestor() {
  return req
}

// 创建一个可以重试的请求
export function createRetryRequestor(maxCount = 5) {
  const req = useRequestor()
  // 进一步配置
  return req
}

// 创建一个并发请求
export function createParallelRequestor(maxCount = 5) {
  const req = useRequestor()
  // 进一步配置
  return req
}

import { Requestor } from 'request-core'
import axios from 'axios'

const ins = axios.create()

export requestor:Requestor = {
    get(url,options) {
        // 使用axios实现
    }
    // 其他方法...
}

import { requestor } from 'request-axios-imp'
import { inject } from 'request-core'
inject(requestor)

import { Requestor } from 'request-core'

const ins = axios.create()

export requestor:Requestor = {
    get(url,options) {
        // 使用fetch实现
    }
    // 其他方法...
}

const req = createCacheRequest()
req.get('/a') // 请求
req.get('/a') // 使用缓存
req.get('/b') // 请求
req.get('/b') // 使用缓存

const req = createCacheRequestor({
    key: (config) {
    	// config 为某次请求的配置
    	return config.pathname // 使用pathname作为缓存键
	},
    persist: true // 是否开启持久化缓存
})

export interface CacheStore {
  has(key: string): Promise<boolean>
  set<T>(key: string, ...values: T[]): Promise<void>
  get<T>(key: string): Promise<T>
  // 其他字段
}

export function useCacheStore(isPersist): CacheStore {
  if (!isPersist) {
    return createMemoryStore()
  } else {
    return createStorage()
  }
}

const req = createCacheRequestor({
    duration: 1000 * 60 * 60 //指定缓存时间
    isValid (key, config){
    	// 自定义缓存是否有效,提供配置后,duration配置失效
    	// key表示缓存键, config表示此次请求配置
    	// 返回true表示缓存有效
	}
})

function createCacheRequestor(cacheOptions) {
  // 参数归一化
  const options = normalizeOptions(cacheOptions)
  // 使用缓存仓库
  const store = useCacheSotre(options.persist)
  // 获得请求实例
  const req = useRequestor()
  // 对请求进行配置
  return req
}

// 对请求进行配置
// 注册请求发送前的事件
req.on('beforeRequest', async (config) => {
  const key = option.key(config) // 获得缓存键
  const hashKey = await store.has(key) // 是否存在缓存
  if (hashKey && option.isValid(key, config)) {
    // 返回缓存结果
  }
})

req.on('responseBody', (config, resp) => {
  const key = options.key(config) // 获得缓存键
  store.set(key, resp.toPlain())
})

function genKey(req) {
  const spark = new SparkMD5()
  spark.append(req.url)
  for (const [key, value] of req.headers) {
    spark.append(key)
    spark.append(value)
  }
  spark.append(req.body)
  return spark.end()
}

function createIdempotentRequestor(genKey) {
    return createCacheRequestor({
        key: (config) => genKey > genKey(config) : hashRequest(config),
    	persist: false
    })
}

// request-bus/templet/article.ts

import { createIdempotentRequest } from 'request-core'

/**
 * 发布文章
 */
export const publishArticle = (() => {
  const req = createIdempotentRequest()
  return async (article: Article) => {
    return req.post('/api/article', article).then((resp) => resp.json())
  }
})()

/**
 * 获取文章
 */
export const getArticles = (() => {
  return async (page: number, size: number) => {
    return req
      .get('/api/article', {
        params: {
          page,
          size
        }
      })
      .then((resp) => resp.json())
  }
})()

export class EventEmitter<T extends string> {
  private events: Map<T, Set<Function>>
  constructor() {
    this.events = new Map()
  }
  on(event: T, listener: Function) {
    if (!this.events.has(event)) {
      this.events.set(event, new Set())
    }
    this.events.get(event)?.add(listener)
  }
  off(event: T, listener: Function) {
    if (!this.events.has(event)) return
    this.events.get(event)?.delete(listener)
  }
  once(event: T, listener: Function) {
    const onceListener = (...args: any[]) => {
      listener(...args)
      this.off(event, listener)
    }
    this.on(event, listener)
  }
  emit(event: T, ...args: any[]) {
    if (!this.events.has(event)) {
      return
    }
    this.events.get(event)?.forEach((listener) => {
      listener(...args)
    })
  }
}

// 可并发执行的任务队列
export class TaskQueue extends EventEmitter<'start' | 'pause' | 'drain'> {
  // 待执行的任务
  private tasks: Set<Task> = new Set()
  // 当前正在执行的任务数
  private currentCount = 0
  // 任务状态
  private status: 'paused' | 'running' = 'paused'
  // 最大并发数
  private concurency: number = 4
  constructor() {
    super()
    this.concurency = this.concurency
  }
  // 添加任务
  add(...tasks: Task[]) {
    for (const t of tasks) {
      this.tasks.add(t)
    }
  }
  // 添加任务并执行启动
  addAndStart(...tasks: Task[]) {
    this.add(...tasks)
    this.start()
  }
  // 启动任务
  start() {
    if (this.status === 'running') {
      return
    }
    if (this.tasks.size === 0) {
      // 当前无任务 触发drain事件
      this.emit('drain')
      return
    }
    // 设置任务状态为running
    this.status = 'running'
    // 触发start事件
    this.emit('start')
    // 开始执行下一个任务
    this.runNext()
  }
  private takeHeadTask() {
    const task = this.tasks.values().next().value
    if (task) {
      this.tasks.delete(task)
    }
    return task
  }
  // 执行下一个任务
  private runNext() {
    if (this.status !== 'running') {
      // 如果整体的任务状态不是running 结束
      return
    }
    if (this.currentCount >= this.concurency) {
      // 并发已满 结束
      return
    }
    // 取出第一个任务
    const task = this.takeHeadTask()
    if (!task) {
      // 没有任务了
      this.status = 'paused' // 暂停执行
      this.emit('drain')
      return
    }
    this.currentCount++
    // 执行任务
    Promise.resolve(task.run()).finally(() => {
      // 任务执行完成后, 当前任务数执行下一个任务
      this.currentCount--
      this.runNext()
    })
  }
  // 暂停
  pause() {
    this.status = 'paused'
    this.emit('pause')
  }
}

// chunk.ts
export interface Chunk {
  blob: Blob // 分片的二进制数据
  start: number // 分片的起始位置
  end: number // 分片的结束位置
  hash: string // 分片的hash值
  index: number // 分片在文件的索引
}

// 创建一个不带hash的chunk
export function createChunk(
  file: File,
  index: number,
  chunkSize: number
): Chunk {
  const start = index * chunkSize
  const end = Math.min((index + 1) * chunkSize, file.size)
  const blob = file.slice(start, end)
  return {
    blob,
    start,
    end,
    hash: '',
    index
  }
}

// 计算chunk的hash值
export function calcChunkHash(chunk: Chunk): Promise<string> {
  return new Promise((resolve) => {
    const spark = new SparkMD5.ArrayBuffer()
    const fileReader = new FileReader()
    fileReader.onload = (e) => {
      spark.append(e.target?.result as ArrayBuffer)
      resolve(spark.end())
    }
    fileReader.readAsArrayBuffer(chunk.blob)
  })
}

export type ChunkSplitorEvents = 'chunks' | 'wholeHash' | 'drain'

export abstract class ChunkSplitor extends EventEmitter<ChunkSplitorEvents> {
  protected chunkSize: number // 分片大小 (单位字节)
  protected file: File // 待分片的文件
  protected hash?: string // 整个文件的hash
  protected chunks: Chunk[] // 分片列表
  private handleChunkCount = 0 // 已计算hash的分片数据
  private spark = new SparkMD5() // 计算Hash的工具
  private hasSplited = false // 是否已经分片
  constructor(file: File, chunkSize: number = 1024 * 1024 * 5) {
    super()
    this.file = file
    this.chunkSize = chunkSize
    // 获取分片数组
    const chunkCount = Math.ceil(this.file.size / this.chunkSize)
    this.chunks = new Array(chunkCount)
      .fill(0)
      .map((_, index) => createChunk(this.file, index, this.chunkSize))
  }
  split() {
    if (this.hasSplited) {
      return
    }
    this.hasSplited = true
    const emitter = new EventEmitter<'chunks'>()
    const chunkHanlder = (chunks: Chunk[]) => {
      this.emit('chunks', chunks)
      chunks.forEach((chunk) => {
        this.spark.append(chunk.hash)
      })
      this.handleChunkCount += chunks.length
      if (this.handleChunkCount === this.chunks.length) {
        // 计算完成
        emitter.off('chunks', chunkHanlder)
        this.emit('wholeHash', this.spark.end())
        this.spark.destroy()
        this.emit('drain')
      }
    }
    emitter.on('chunks', chunkHanlder)
    this.calcHash(this.chunks, emitter)
  }
  abstract calcHash(chunks: Chunk[], emitter: EventEmitter<'chunks'>): void
  // 分片完成后一些需要销毁的工作
  abstract dispose(): void
}

// MutilThreadSplitor.ts
export class MutilThreadSplitor extends ChunkSplitor {
  private workers: Worker[] = new Array(navigator.hardwareConcurrency || 4)
    .fill(0)
    .map(
      () =>
        new Worker(new URL('./SplitWorker.ts', import.meta.url), {
          type: 'module'
        })
    )
  calcHash(chunks: Chunk[], emitter: EventEmitter<'chunks'>): void {
    const workerSize = Math.ceil(chunks.length / this.workers.length)
    for (let i = 0; i < this.workers.length; i++) {
      const worker = this.workers[i]
      const start = i * workerSize
      const end = Math.min((i + 1) * workerSize, chunks.length)
      const workerChunks = chunks.slice(start, end)
      worker.postMessage(workerChunks)
      worker.onmessage = (e) => {
        emitter.emit('chunks', e.data)
      }
    }
  }
  dispose(): void {
    this.workers.forEach((worker) => worker.terminate())
  }
}

// SplitWorker.ts
onmessage = function (e) {
  const chunks = e.data as Chunk[]
  for (const chunk of chunks) {
    calcChunkHash(chunk).then((hash) => {
      chunk.hash = hash
      postMessage([chunk])
    })
  }
}

// 请求策略
export interface RequestStrategy {
  // 文件创建请求, 返回token
  createFile(file: File): Promise<string>
  // 分片上传请求
  uploadChunk(chunk: Chunk): Promise<void>
  // 文件合并请求, 返回文件url
  mergeFile(token: string): Promise<string>
  // hash校验请求
  patchHash<T extends 'file' | 'chunk'>(
    token: string,
    hash: string,
    type: T
  ): Promise<
    T extends 'file'
      ? { hasFile: boolean }
      : { hasFile: boolean; rest: number[]; url: string }
  >
}

export class UploadController {
  private requestStrategy: RequestStrategy // 请求策略，没有传递则使用默认策略
  private splitStrategy: ChunkSplitor // 分片策略，没有传递则默认多线程分片
  private taskQueue: TaskQueue // 任务队列
  // 其他属性略

  // 初始化
  async init() {
    // 获取文件token
    this.token = await this.requestStrategy.createFile(this.file)
    // 分片事件监听
    this.splitStrategy.on('chunks', this.handleChunks.bind(this))
    this.splitStrategy.on('wholeHash', this.handleWholeHash.bind(this))
  }

  // 分片事件处理
  private handleChunks(chunks: Chunk[]) {
    // 分片上传任务加入队列
    chunks.forEach((chunk) => {
      this.taskQueue.addAndStart(new Task(this.uploadChunk.bind(this), chunk))
    })
  }

  async uploadChunk(chunk: Chunk) {
    // hash校验
    const resp = await this.requestStrategy.patchHash(
      this.token,
      chunk.hash,
      'chunk'
    )
    if (resp.hasFile) {
      // 文件已存在
      return
    }
    // 分片上传
    await this.requestStrategy.uploadChunk(chunk, this.uploadEmitter)
  }

  // 整体hash事件处理
  private async handleWholeHash(hash: string) {
    // hash校验
    const resp = await this.requestStrategy.patchHash(this.token, hash, 'file')
    if (resp.hasFile) {
      // 文件已存在
      this.emit('end', resp.url)
      return
    }
    // 根据resp.rest重新编排后续任务
    // ...
  }
}