import * as cornerstone from 'cornerstone-core'
var taskPool = [] // 请求池
let numRequest = 0 // 正在执行数量
const maxRequest = 6 // 可配置
let taskTimer // 轮询的定时器
var cachedTask = {} // 存放的任务数据

// 执行下载
async function executeTask() {
  // stopTaskTimer()
  if (taskPool.length > 0) {
   
    sortTaskPool()
    var requestNum = Math.min(taskPool.length, maxRequest)
    const tasks = taskPool.splice(0, requestNum);

    const taskPromises = tasks.map((task) => {
      return task.execute().then((result) => {
        task.callback({ success: true, res: result })

      }).catch((error) => {
        task.callback({ success: true, err: error })
      })
    })
    await Promise.all(taskPromises)
  // results.forEach((result, index) => {
  //   const task = tasks[index];
  //   if (task.callback) {
  //     task.callback(result);
  //   }
  // });
    // for (let i = 0; i < requestNum; i++) {
    //   const task = taskPool.shift()
    //   if (!task) continue
    //   tasks.push(task)
    // }
    // // taskPromises.map(task=>task())
    // await Promise.all(tasks.map(task=>task.execute())).then(res=>{
    //   res.map(v=>{
    //     var i = tasks.findIndex(task=>task.key ===v.imageId )
    //     if(i>-1){
    //       tasks[i].callback({ success: true, res: v })
    //     } 
    //   })
    // })
    executeTask()

    // const taskPromises = [];
    // const delay = 50
    // for(let i = 0;i< taskPool.length; i++ ){
    //   taskPromises.push(()=>cornerstone.loadAndCacheImage(taskPool[i].key))
    // }
    // for (let i = 0; i < taskPromises.length; i += maxRequest) {
    //   const tasks = taskPromises.slice(i, i + maxRequest);
    //   await Promise.all(tasks.map(task=>task()));
    //   await new Promise(resolve => setTimeout(resolve, delay));
    // }


    // while (taskPool.length > 0) {
      
    //   var requestNum = taskPool.length > maxRequest ? maxRequest : taskPool.length
    //   for (let i = 0; i < requestNum; i++) {
    //     sortTaskPool()
    //     const task = taskPool.shift()
    //     if (!task) return
    //     batchPromises.push(cornerstone.loadAndCacheImage(task.key))
    //   }
    //   await Promise.all(batchPromises);
    // }
  }else{
    startTaskTimer()
  }
 
}

function sortTaskPool() {
  if (taskPool.length > 0) {
    taskPool.sort((a, b) =>  b.priority-a.priority )
    
  }
}

// 轮询检查请求池中是否有请求需要执行
function startTaskTimer() {
  if (taskTimer) return; // 如果已存在定时器，则不重复启动

  taskTimer = setInterval(() => {
    if (taskPool.length > 0) {
      stopTaskTimer();
      executeTask();
    }
  }, 50);
}

// 停止轮询
function stopTaskTimer() {
  clearInterval(taskTimer)
  taskTimer = null
}
function loadAndCacheImagePlus(imageId,seriesId, priority) {
  return new Promise((resolve, reject) => {
    const imageLoadObject = cornerstone.imageCache.getImageLoadObject(imageId)
    if (imageLoadObject) {
      imageLoadObject.promise.then((image) => {
        resolve(image)
      }, (err) => {
        reject(err)
      })
    } else {
      const imageTask = buildImageRequestTask(imageId,seriesId, { priority })
      addTaskIntoPool(imageTask).then((res) => {
        resolve(res)
      }).catch(e => {
        reject(e)
      })
    }
  })
}
// 预加载池的添加
// function addTaskIntoPool(task) {
//   taskPool.push(task)
//   sortTaskPool()
// }
// 预加载池的添加
function addTaskIntoPool(task) {
  return new Promise((resolve, reject) => {
    const callback = (executeRes) => {
      if (executeRes.success) {
        resolve(executeRes.res)
      } else {
        reject(executeRes.err)
      }
    }
    task.callback =callback
      taskPool.push(task)
  })
}
function removeTask(seriesId){
  stopTaskTimer()
  if (taskPool.length > 0) {
    for(var i =taskPool.length-1; i>=0;i--){
      if(taskPool[i] && taskPool[i].seriesId === seriesId){
        delete cachedTask[taskPool[i].key]
        taskPool.splice(i,1)
       
      }
    }
    
  }
  startTaskTimer()
}
function resetRequestPool(){
  taskPool = []
  pendingList =[]
  cachedTask = {}
}
function resetCachedTask(){
  taskPool = []
  pendingList =[]
  cachedTask = {}
}
function buildImageRequestTask(imageId,seriesId, config = {}) {
  return {
      key: imageId,
      seriesId:seriesId,
      ...config,
      execute: () => {
          return cornerstone.loadAndCacheImage(imageId)
      }
  };
}

export default {
  addTaskIntoPool,
  executeTask,
  startTaskTimer,
  stopTaskTimer,
  loadAndCacheImagePlus,
  removeTask,
  resetRequestPool,
  resetCachedTask
}